github.com/ethereum-optimism/optimism@v1.7.2/packages/sdk/src/utils/coercion.ts (about)

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