1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import {
Provider,
TransactionReceipt,
TransactionResponse,
} from '@ethersproject/abstract-provider'
import { Signer } from '@ethersproject/abstract-signer'
import { ethers, BigNumber } from 'ethers'
import { assert } from './assert'
import {
SignerOrProviderLike,
ProviderLike,
TransactionLike,
NumberLike,
AddressLike,
} from '../interfaces'
/**
* Converts a SignerOrProviderLike into a Signer or a Provider. Assumes that if the input is a
* string then it is a JSON-RPC url.
*
* @param signerOrProvider SignerOrProviderLike to turn into a Signer or Provider.
* @returns Input as a Signer or Provider.
*/
export const toSignerOrProvider = (
signerOrProvider: SignerOrProviderLike
): Signer | Provider => {
if (typeof signerOrProvider === 'string') {
return new ethers.providers.JsonRpcProvider(signerOrProvider)
} else if (Provider.isProvider(signerOrProvider)) {
return signerOrProvider
} else if (Signer.isSigner(signerOrProvider)) {
return signerOrProvider
} else {
throw new Error('Invalid provider')
}
}
/**
* Converts a ProviderLike into a Provider. Assumes that if the input is a string then it is a
* JSON-RPC url.
*
* @param provider ProviderLike to turn into a Provider.
* @returns Input as a Provider.
*/
export const toProvider = (provider: ProviderLike): Provider => {
if (typeof provider === 'string') {
return new ethers.providers.JsonRpcProvider(provider)
} else if (Provider.isProvider(provider)) {
return provider
} else {
throw new Error('Invalid provider')
}
}
/**
* Converts a ProviderLike into a JsonRpcProvider.
*
* @param provider ProviderLike to turn into a JsonRpcProvider.
* @returns Input as a JsonRpcProvider.
*/
export const toJsonRpcProvider = (
provider: ProviderLike
): ethers.providers.JsonRpcProvider => {
const coerced = toProvider(provider)
if ('send' in coerced) {
// Existence of "send" is basically the only function that matters for determining if we can
// use this provider as a JsonRpcProvider, because "send" is the function that we usually want
// access to when we specifically care about having a JsonRpcProvider.
return coerced as ethers.providers.JsonRpcProvider
} else {
throw new Error('Invalid JsonRpcProvider, does not have "send" function')
}
}
/**
* Pulls a transaction hash out of a TransactionLike object.
*
* @param transaction TransactionLike to convert into a transaction hash.
* @returns Transaction hash corresponding to the TransactionLike input.
*/
export const toTransactionHash = (transaction: TransactionLike): string => {
if (typeof transaction === 'string') {
assert(
ethers.utils.isHexString(transaction, 32),
'Invalid transaction hash'
)
return transaction
} else if ((transaction as TransactionReceipt).transactionHash) {
return (transaction as TransactionReceipt).transactionHash
} else if ((transaction as TransactionResponse).hash) {
return (transaction as TransactionResponse).hash
} else {
throw new Error('Invalid transaction')
}
}
/**
* Converts a number-like into an ethers BigNumber.
*
* @param num Number-like to convert into a BigNumber.
* @returns Number-like as a BigNumber.
*/
export const toBigNumber = (num: NumberLike): BigNumber => {
return ethers.BigNumber.from(num)
}
/**
* Converts a number-like into a number.
*
* @param num Number-like to convert into a number.
* @returns Number-like as a number.
*/
export const toNumber = (num: NumberLike): number => {
return toBigNumber(num).toNumber()
}
/**
* Converts an address-like into a 0x-prefixed address string.
*
* @param addr Address-like to convert into an address.
* @returns Address-like as an address.
*/
export const toAddress = (addr: AddressLike): string => {
if (typeof addr === 'string') {
assert(ethers.utils.isAddress(addr), 'Invalid address')
return ethers.utils.getAddress(addr)
} else {
assert(ethers.utils.isAddress(addr.address), 'Invalid address')
return ethers.utils.getAddress(addr.address)
}
}