@audius/sdk 0.0.0

package/src/services/wormhole/index.js

@@ -0,0 +1,424 @@
+const bs58 = require('bs58')
+const { toBuffer } = require('ethereumjs-util')
+const { zeroPad } = require('ethers/lib/utils')
+const { providers } = require('ethers/lib/index')
+const wormholeSDK = require('@certusone/wormhole-sdk')
+
+const SolanaUtils = require('../solanaWeb3Manager/utils')
+const { Utils } = require('../../utils')
+const { wAudioFromWeiAudio } = require('../solanaWeb3Manager/wAudio')
+const { sign, getTransferTokensDigest } = require('../../utils/signatures')
+/** Singleton state-manager for Audius Eth Contracts */
+
+class Wormhole {
+  /**
+   * Wormhole constructor
+   * @param {object} hedgehog
+   * @param {object} ethWeb3Manager
+   * @param {object} ethContracts
+   * @param {object} identityService
+   * @param {object} solanaWeb3Manager
+   * @param {Array<string>} rpcHosts
+   * @param {string} solBridgeAddress
+   * @param {string} solTokenBridgeAddress
+   * @param {string} ethBridgeAddress
+   * @param {string} ethTokenBridgeAddress
+   * @param {boolean} isServer
+  */
+  constructor (
+    hedgehog,
+    ethWeb3Manager,
+    ethContracts,
+    identityService,
+    solanaWeb3Manager,
+    rpcHosts,
+    solBridgeAddress,
+    solTokenBridgeAddress,
+    ethBridgeAddress,
+    ethTokenBridgeAddress,
+    isServer
+  ) {
+    // Wormhole service dependecies
+    this.hedgehog = hedgehog
+    this.ethWeb3Manager = ethWeb3Manager
+    this.ethContracts = ethContracts
+    this.identityService = identityService
+    this.solanaWeb3Manager = solanaWeb3Manager
+
+    // Wormhole config
+    this.rpcHosts = rpcHosts
+    this.solBridgeAddress = solBridgeAddress
+    this.solTokenBridgeAddress = solTokenBridgeAddress
+    this.ethBridgeAddress = ethBridgeAddress
+    this.ethTokenBridgeAddress = ethTokenBridgeAddress
+    this.wormholeSDK = wormholeSDK
+  }
+
+  async getSignedVAAWithRetry (
+    hosts,
+    emitterChain,
+    emitterAddress,
+    sequence,
+    extraGrpcOpts = {},
+    retryTimeout = 5000,
+    retryAttempts = 60
+  ) {
+    let currentWormholeRpcHost = -1
+    const getNextRpcHost = () => ++currentWormholeRpcHost % hosts.length
+    let result
+    let attempts = 0
+    while (!result) {
+      attempts++
+      await new Promise((resolve) => setTimeout(resolve, retryTimeout))
+      try {
+        result = await this.wormholeSDK.getSignedVAA(
+          hosts[getNextRpcHost()],
+          emitterChain,
+          emitterAddress,
+          sequence,
+          extraGrpcOpts
+        )
+      } catch (e) {
+        if (retryAttempts !== undefined && attempts > retryAttempts) {
+          throw e
+        }
+      }
+    }
+    return result
+  }
+
+  /**
+   * Sends `amount` tokens to `solanaAccount` by way of the wormhole
+   * @param {string} ethTxReceipt The tx receipt
+   * @param {function} [customSignTransaction] Optional custom sign transaction parameter
+   * @param {Object?} options The grpc options passed to get signed VAA for different transport
+   *
+   * else will attempt to relay
+   * @returns {Promise} Promise object of {
+        transactionSignature: string,
+        error: Error,
+        phase: string,
+        logs: Array<string>
+      }
+   */
+  async attestAndCompleteTransferEthToSol (ethTxReceipt, customSignTransaction, options = {}) {
+    const phases = {
+      GET_RECEIPT: 'GET_RECEIPT',
+      GET_SIGNED_VAA: 'GET_SIGNED_VAA',
+      POST_VAA_SOLANA: 'POST_VAA_SOLANA',
+      REDEEM_ON_SOLANA: 'REDEEM_ON_SOLANA'
+    }
+    let phase = phases.GET_RECEIPT
+    const logs = [`Attest and complete transfer for eth to sol for reciept ${ethTxReceipt}`]
+    try {
+      const receipt = await this.ethWeb3Manager.web3.eth.getTransactionReceipt(ethTxReceipt)
+      const sequence = this.wormholeSDK.parseSequenceFromLogEth(receipt, this.ethBridgeAddress)
+      const emitterAddress = this.wormholeSDK.getEmitterAddressEth(this.ethTokenBridgeAddress)
+      phase = phases.GET_SIGNED_VAA
+      const { vaaBytes } = await this.getSignedVAAWithRetry(
+        this.rpcHosts,
+        this.wormholeSDK.CHAIN_ID_ETH,
+        emitterAddress,
+        sequence,
+        options
+      )
+
+      const connection = this.solanaWeb3Manager.connection
+      let signTransaction
+      if (customSignTransaction) {
+        signTransaction = customSignTransaction
+      } else {
+        signTransaction = async (transaction) => {
+          const { blockhash } = await connection.getLatestBlockhash()
+          // Must call serialize message to set the correct signatures on the transaction
+          transaction.serializeMessage()
+          const transactionData = {
+            recentBlockhash: blockhash,
+            instructions: transaction.instructions.map(SolanaUtils.prepareInstructionForRelay),
+            signatures: transaction.signatures.map(sig => ({
+              publicKey: sig.publicKey.toString(),
+              signature: sig.signature
+            }))
+          }
+
+          const { transactionSignature } = await this.identityService.solanaRelayRaw(transactionData)
+          logs.push(`Relay sol tx for postVAA with signature ${transactionSignature}`)
+          return {
+            serialize: () => {}
+          }
+        }
+        connection.sendRawTransaction = async () => ''
+        connection.confirmTransaction = async () => ''
+      }
+      phase = phases.POST_VAA_SOLANA
+      await this.wormholeSDK.postVaaSolana(
+        connection,
+        signTransaction,
+        this.solBridgeAddress,
+        this.solanaWeb3Manager.feePayerAddress.toString(), // payerAddress
+        vaaBytes
+      )
+
+      // Finally, redeem on Solana
+      phase = phases.REDEEM_ON_SOLANA
+      const transaction = await this.wormholeSDK.redeemOnSolana(
+        connection,
+        this.solBridgeAddress,
+        this.solTokenBridgeAddress,
+        this.solanaWeb3Manager.feePayerAddress.toString(), // payerAddress,
+        vaaBytes
+      )
+
+      let finalTxSignature
+      // Must call serialize message to set the correct signatures on the transaction
+      if (customSignTransaction) {
+        const signedTransaction = await signTransaction(transaction)
+        const txid = await connection.sendRawTransaction(signedTransaction.serialize())
+        finalTxSignature = txid
+
+        await connection.confirmTransaction(txid)
+      } else {
+        transaction.serializeMessage()
+
+        const { blockhash } = await connection.getLatestBlockhash()
+        const transactionData = {
+          recentBlockhash: blockhash,
+          instructions: transaction.instructions.map(SolanaUtils.prepareInstructionForRelay),
+          signatures: transaction.signatures.map(sig => ({
+            publicKey: sig.publicKey.toString(),
+            signature: sig.signature
+          }))
+        }
+
+        const { transactionSignature } = await this.identityService.solanaRelayRaw(transactionData)
+        finalTxSignature = transactionSignature
+      }
+      logs.push(`Complete redeem on sol with signature ${finalTxSignature}`)
+      return {
+        transactionSignature: finalTxSignature,
+        error: null,
+        phase,
+        logs
+      }
+    } catch (error) {
+      return {
+        error: error.message,
+        phase,
+        logs
+      }
+    }
+  }
+
+  /**
+   * Sends `amount` tokens to `solanaAccount` by way of the wormhole
+   * @param {BN} amount The amount of AUDIO to send in Wrapped Audio (8 decimals)
+   * @param {string} ethTargetAddress The eth address to transfer AUDIO
+   * @param {Object?} options The grpc options passed to get signed VAA for different transport
+   */
+  async sendTokensFromSolToEthViaWormhole (amount, ethTargetAddress, options = {}) {
+    const phases = {
+      GENERATE_SOL_ROOT_ACCT: 'GENERATE_SOL_ROOT_ACCT',
+      TRANSFER_WAUDIO_TO_ROOT: 'TRANSFER_WAUDIO_TO_ROOT',
+      TRANFER_FROM_SOL: 'TRANFER_FROM_SOL',
+      GET_SIGNED_VAA: 'GET_SIGNED_VAA',
+      GET_EMITTER_ADDR: 'GET_EMITTER_ADDR',
+      REDEEM_ON_ETH: 'REDEEM_ON_ETH'
+    }
+    let phase = phases.GENERATE_SOL_ROOT_ACCT
+    const logs = [`Transferring ${amount} WAUDIO to ${ethTargetAddress}`]
+    try {
+      const wAudioAmount = wAudioFromWeiAudio(amount)
+      // Generate a solana keypair derived from the hedgehog private key
+      // NOTE: The into to fromSeed is a 32 bytes Uint8Array
+      const rootSolanaAccount = this.solanaWeb3Manager.solanaWeb3.Keypair.fromSeed(
+        this.hedgehog.wallet.getPrivateKey()
+      )
+
+      const solanaAddress = rootSolanaAccount.publicKey.toString()
+      logs.push(`Root Solana Account: ${solanaAddress}`)
+
+      // Find the token account owned by the root solana account and get the token account's info
+      const associatedTokenAccount = await this.solanaWeb3Manager.findAssociatedTokenAddress(solanaAddress)
+      const tokenAccountInfo = await this.solanaWeb3Manager.getAssociatedTokenAccountInfo(associatedTokenAccount.toString())
+
+      // If it's not a valid token account, create the token account
+      if (!tokenAccountInfo) {
+        logs.push(`Creating Associated Token Account: ${associatedTokenAccount.toString()}`)
+        await this.solanaWeb3Manager.createAssociatedTokenAccount(solanaAddress)
+      } else {
+        logs.push(`Associated Token Account Exits: ${associatedTokenAccount.toString()}`)
+      }
+
+      phase = phases.TRANSFER_WAUDIO_TO_ROOT
+      // Move wrapped audio from then user bank account to the user's token wallet
+      await this.solanaWeb3Manager.transferWAudio(tokenAccountInfo.address.toString(), amount)
+      logs.push(`Transferred waudio ${wAudioAmount.toString()} balance to associated token account`)
+      phase = phases.TRANFER_FROM_SOL
+
+      const connection = this.solanaWeb3Manager.connection
+
+      // Submit transaction - results in a Wormhole message being published
+      const tx = await this.wormholeSDK.transferFromSolana(
+        connection, // solana web3 Connection
+        this.solBridgeAddress, // bridge address
+        this.solTokenBridgeAddress, // token bridge address
+        this.solanaWeb3Manager.feePayerAddress, // payerAddress
+        tokenAccountInfo.address.toString(), // fromAddress
+        this.solanaWeb3Manager.mintAddress, // mintAddress
+        wAudioAmount, // BigInt
+        zeroPad(toBuffer(ethTargetAddress), 32), // Uint8Array of length 32 targetAddress
+        this.wormholeSDK.CHAIN_ID_ETH, // ChainId targetChain
+        zeroPad(toBuffer(this.ethContracts.AudiusTokenClient.contractAddress), 32), // Uint8Array of length 32 originAddress
+        this.wormholeSDK.CHAIN_ID_ETH, //  ChainId originChain
+        solanaAddress // from owner address
+      )
+
+      // Must call serialize message to set the correct signatures on the transaction
+      tx.serializeMessage()
+      tx.partialSign(rootSolanaAccount)
+
+      const { blockhash } = await connection.getLatestBlockhash()
+      const transactionData = {
+        recentBlockhash: blockhash,
+        instructions: tx.instructions.map(SolanaUtils.prepareInstructionForRelay),
+        signatures: tx.signatures.map(sig => ({
+          publicKey: sig.publicKey.toString(),
+          signature: sig.signature
+        }))
+      }
+      const { transactionSignature } = await this.identityService.solanaRelayRaw(transactionData)
+      logs.push(`Transferred to wormhole with signature: ${transactionSignature}`)
+      phase = phases.GET_EMITTER_ADDR
+
+      // Get the sequence number and emitter address required to fetch the signedVAA of our message
+      const info = await connection.getTransaction(transactionSignature)
+      const sequence = this.wormholeSDK.parseSequenceFromLogSolana(info)
+      const emitterAddress = await this.wormholeSDK.getEmitterAddressSolana(this.solTokenBridgeAddress)
+      // Fetch the signedVAA from the Wormhole Network (this may require retries while you wait for confirmation)
+      phase = phases.GET_SIGNED_VAA
+      const { vaaBytes } = await this.getSignedVAAWithRetry(
+        this.rpcHosts,
+        this.wormholeSDK.CHAIN_ID_SOLANA,
+        emitterAddress,
+        sequence,
+        options
+      )
+
+      // Redeem on Ethereum
+      // NOTE: The signer should be the user's personal wallet
+      phase = phases.REDEEM_ON_ETH
+      const signer = (new providers.Web3Provider(window.ethereum)).getSigner()
+      await this.wormholeSDK.redeemOnEth(this.ethTokenBridgeAddress, signer, vaaBytes)
+      logs.push('Redeemed on eth')
+      return { phase, logs, error: null }
+    } catch (error) {
+      return {
+        error: error.message,
+        phase,
+        logs
+      }
+    }
+  }
+
+  /**
+   * Locks assets owned by `fromAccount` into the Solana wormhole with a target
+   * solanaAccount destination via the provided relayer wallet.
+   * @param {string} fromAccount the account holding the ETH AUDIO to transfer
+   * @param {BN} amount The amount of AUDIO to send in WEI (18 decimals)
+   * @param {string} solanaAccount The solana token account
+   */
+  async _getTransferTokensToEthWormholeParams (fromAccount, amount, solanaAccount) {
+    const web3 = this.ethWeb3Manager.getWeb3()
+    const wormholeClientAddress = this.ethContracts.WormholeClient.contractAddress
+
+    const chainId = await web3.eth.getChainId()
+
+    const currentBlockNumber = await web3.eth.getBlockNumber()
+    const currentBlock = await web3.eth.getBlock(currentBlockNumber)
+
+    // 1 hour, sufficiently far in future
+    const deadline = currentBlock.timestamp + (60 * 60 * 1)
+    const solanaB58 = bs58.decode(solanaAccount).toString('hex')
+    const recipient = toBuffer(`0x${solanaB58}`)
+    const nonce = await this.ethContracts.WormholeClient.nonces(fromAccount)
+    const arbiterFee = Utils.toBN('0')
+
+    const digest = getTransferTokensDigest(
+      web3,
+      'AudiusWormholeClient',
+      wormholeClientAddress,
+      chainId,
+      {
+        from: fromAccount,
+        amount,
+        recipientChain: chainId,
+        recipient,
+        arbiterFee
+      },
+      nonce,
+      deadline
+    )
+    const myPrivateKey = this.hedgehog.wallet._privKey
+    const signedDigest = sign(digest, myPrivateKey)
+    return {
+      chainId,
+      deadline,
+      recipient,
+      arbiterFee,
+      signedDigest
+    }
+  }
+
+  /**
+   * Locks assets owned by `fromAccount` into the Solana wormhole with a target
+   * solanaAccount destination via the provided relayer wallet.
+   * @param {string} fromAccount the account holding the ETH AUDIO to transfer
+   * @param {BN} amount The amount of AUDIO to send in WEI (18 decimals)
+   * @param {string} solanaAccount The solana token account
+   * @param {string} relayer The eth relayer to permission to aprrove and transfer
+   */
+  async transferTokensToEthWormhole (fromAccount, amount, solanaAccount, relayer) {
+    const {
+      chainId,
+      deadline,
+      recipient,
+      arbiterFee,
+      signedDigest
+    } = await this._getTransferTokensToEthWormholeParams(fromAccount, amount, solanaAccount)
+    const tx = await this.ethContracts.WormholeClient.transferTokens(
+      fromAccount,
+      amount,
+      chainId,
+      recipient,
+      arbiterFee,
+      deadline,
+      signedDigest,
+      relayer
+    )
+    return tx
+  }
+
+  async getTransferTokensToEthWormholeMethod (fromAccount, amount, solanaAccount, relayer) {
+    const {
+      chainId,
+      deadline,
+      recipient,
+      arbiterFee,
+      signedDigest
+    } = await this._getTransferTokensToEthWormholeParams(fromAccount, amount, solanaAccount)
+    const method = await this.ethContracts.WormholeClient.WormholeContract.methods.transferTokens(
+      fromAccount,
+      amount,
+      chainId,
+      recipient,
+      arbiterFee,
+      deadline,
+      signedDigest.v,
+      signedDigest.r,
+      signedDigest.s
+    )
+    return method
+  }
+}
+
+module.exports = Wormhole

package/src/types.ts

@@ -0,0 +1,8 @@
+import AudiusLibs from './libs'
+
+export { sdk } from './sdk'
+
+export const libs: any = AudiusLibs
+export { Utils } from './utils'
+export { CreatorNode } from './services/creatorNode'
+export * from './sanityChecks'

package/src/userStateManager.ts

@@ -0,0 +1,53 @@
+import { CURRENT_USER_EXISTS_LOCAL_STORAGE_KEY } from './constants'
+
+const supportsLocalStorage = () =>
+  typeof window !== 'undefined' && window && window.localStorage
+
+export type CurrentUser = {
+  user_id: string
+  wallet: string
+  blocknumber: number
+  track_blocknumber: number
+  creator_node_endpoint: string
+  is_creator: boolean
+}
+
+/**
+ * Singleton class to store the current user if initialized.
+ * Some instances of AudiusLibs and services require a current user to
+ * return valid queries, e.g. requesting the a discprov to return a reposted track.
+ */
+export class UserStateManager {
+  currentUser: CurrentUser | null
+
+  constructor() {
+    // Should reflect the same fields as discovery node's /users?handle=<handle>
+    this.currentUser = null
+  }
+
+  /**
+   * Sets this.currentUser with currentUser
+   * @param {Object} currentUser fields to override this.currentUser with
+   */
+  setCurrentUser(currentUser: CurrentUser) {
+    this.currentUser = currentUser
+    if (supportsLocalStorage()) {
+      window.localStorage.setItem(CURRENT_USER_EXISTS_LOCAL_STORAGE_KEY, 'true')
+    }
+  }
+
+  getCurrentUser() {
+    return this.currentUser
+  }
+
+  getCurrentUserId() {
+    return this.currentUser ? this.currentUser.user_id : null
+  }
+
+  clearUser() {
+    this.currentUser = null
+    if (supportsLocalStorage()) {
+      window.localStorage.removeItem(CURRENT_USER_EXISTS_LOCAL_STORAGE_KEY)
+    }
+  }
+}

package/src/utils/apiSigning.ts

@@ -0,0 +1,51 @@
+import assert from 'assert'
+import type Web3 from 'web3'
+
+interface WalletResponse {
+  signature: string
+  signer: string
+}
+
+/**
+ * Recover the public wallet address given the response contains the signature and timestamp
+ * @param {object} response entire service provider response (not axios)
+ */
+export function recoverWallet(web3: Web3, response: WalletResponse) {
+  let recoveredDelegateWallet = null
+
+  const dataForRecovery = JSON.parse(JSON.stringify(response))
+  delete dataForRecovery.signature
+  const dataForRecoveryStr = JSON.stringify(sortObjectKeys(dataForRecovery))
+
+  try {
+    const hashedData = web3.utils.keccak256(dataForRecoveryStr)
+    recoveredDelegateWallet = web3.eth.accounts.recover(
+      hashedData,
+      response.signature
+    )
+
+    assert.strictEqual(response.signer, recoveredDelegateWallet)
+  } catch (e) {
+    console.error(`Issue with recovering public wallet address: ${e}`)
+  }
+
+  return recoveredDelegateWallet
+}
+
+type ValueOrArray<T> = undefined | string | T | Array<ValueOrArray<T>>
+type SortObject = ValueOrArray<Record<string, string>>
+
+/**
+ * Recursively sorts object keys alphabetically
+ */
+export function sortObjectKeys(x: SortObject): SortObject {
+  if (typeof x !== 'object' || !x) {
+    return x
+  }
+  if (Array.isArray(x)) {
+    return x.map(sortObjectKeys)
+  }
+  return Object.keys(x)
+    .sort()
+    .reduce((o, k) => ({ ...o, [k]: sortObjectKeys(x[k]) }), {})
+}

package/src/utils/captcha.ts

@@ -0,0 +1,97 @@
+import FormData from 'form-data'
+import axios from 'axios'
+
+declare global {
+  interface Window {
+    grecaptcha: {
+      ready: (callback: () => void) => Promise<void>
+      execute: (siteKey: string, config: { action: string }) => Promise<string>
+    }
+  }
+}
+
+const VERIFY_ENDPOINT = 'https://www.google.com/recaptcha/api/siteverify'
+const IS_BROWSER = typeof window !== 'undefined' && window !== null
+
+interface CaptchaConfig {
+  siteKey: string
+  serviceKey: string
+}
+
+export class Captcha {
+  siteKey: string
+  serviceKey: string
+  constructor({ siteKey, serviceKey }: CaptchaConfig) {
+    this.siteKey = siteKey
+    this.serviceKey = serviceKey
+
+    this.generate = this.generate.bind(this)
+    this.verify = this.verify.bind(this)
+  }
+
+  /**
+   * Intended to be called by clients. Will generate a token used to calculate recaptcha score.
+   * @param action name for this "action" for grouping
+   */
+  async generate(action: string) {
+    if (!this.siteKey) {
+      throw new Error('No siteKey provided')
+    }
+
+    if (!IS_BROWSER) {
+      throw new Error('Expected a browser/client context')
+    }
+
+    if (!window.grecaptcha) {
+      throw new Error('No captcha found, did you forget to import it?')
+    }
+
+    return await new Promise<string>((resolve) => {
+      window.grecaptcha.ready(() => {
+        window.grecaptcha.execute(this.siteKey, { action }).then((token) => {
+          resolve(token)
+        })
+      })
+    })
+  }
+
+  /**
+   * Intended to be called by services. According to recaptcha v3 docs:
+   * A score of 1.0 is very likely a good interaction, 0.0 is very likely a bot
+   * @param token
+   * @param minScore score must be >= minScore to be ok
+   * @returns
+   *    {boolean | null} ok - whether score > minScore (false if something went wrong)
+   *    {number | null} score - the raw score [0, 1] (or null if a score was not computed)
+   */
+  async verify(token: string, minScore = 0.5) {
+    if (!this.serviceKey) {
+      throw new Error('No serviceKey provided')
+    }
+
+    let score, ok, hostname
+
+    const formData = new FormData()
+    formData.append('response', token)
+    formData.append('secret', this.serviceKey)
+
+    try {
+      const resp = await axios.post(VERIFY_ENDPOINT, formData, {
+        headers: formData.getHeaders(),
+        adapter: IS_BROWSER
+          ? require('axios/lib/adapters/xhr')
+          : require('axios/lib/adapters/http')
+      })
+
+      score = resp.data.score
+      ok = score >= minScore
+      hostname = resp.data.hostname
+    } catch (e) {
+      console.error('Error with verifying captcha request', e)
+      score = null
+      ok = true
+      hostname = null
+    }
+    return { score, ok, hostname }
+  }
+}

package/src/utils/estimateGas.ts

@@ -0,0 +1,64 @@
+import type Wallet from 'ethereumjs-wallet'
+
+// Default multiplier on top of gas estimate to be extra safe that txns
+// will go through
+const GAS_LIMIT_MULTIPLIER = 1.05
+
+export interface ContractMethod {
+  arguments: string[]
+  estimateGas: (config: {
+    from: Wallet | string | undefined
+    gas: number | undefined
+  }) => Promise<number>
+  _method: {
+    name: string
+    inputs: Array<{ type: string }>
+  }
+  encodeABI: () => string
+  send: <Tx>(config: {
+    from: Wallet | string | undefined
+    gas: number
+    gasPrice?: number
+  }) => Tx
+}
+
+interface EstimateGasConfig {
+  method: ContractMethod
+  from?: Wallet | string
+  gasLimitMaximum: number
+  multiplier?: number
+}
+
+/**
+ * Returns estimated gas use for a txn for a contract method
+ * @param options
+ * @param options.method the contract method
+ * @param options.from address the method will be sent from (required if the contract requires a certain sender, e.g. guardian)
+ * @param options.gasLimitMaximum the maximum amount of gas we will allow
+ * (likely will return a number much smaller than this)
+ * @param options.multipler the multiplier to safe-guard against estimates that are too low
+ */
+export const estimateGas = async ({
+  method,
+  from,
+  gasLimitMaximum,
+  multiplier = GAS_LIMIT_MULTIPLIER
+}: EstimateGasConfig) => {
+  try {
+    const estimatedGas = await method.estimateGas({
+      from,
+      gas: gasLimitMaximum
+    })
+    // Rounding is necessary here as fractional gas limits will break
+    const safeEstimatedGas = Math.ceil(estimatedGas * multiplier)
+    console.info(
+      `Estimated gas limit ${safeEstimatedGas} for method ${method._method.name}`
+    )
+    return safeEstimatedGas
+  } catch (e) {
+    console.error(
+      `Unable to estimate gas for transaction ${method._method.name}, using ${gasLimitMaximum}`
+    )
+    return gasLimitMaximum
+  }
+}