@audius/sdk 0.0.0

package/src/services/ethContracts/ServiceTypeManagerClient.ts

@@ -0,0 +1,112 @@
+import { Utils } from '../../utils'
+import { GovernedContractClient } from '../contracts/GovernedContractClient'
+
+export class ServiceTypeManagerClient extends GovernedContractClient {
+  /**
+   *
+   * @param serviceType Type of service to set the version, either `discovery-node` or `content-node`
+   * @param serviceVersion Version string to set on chain
+   * @param privateKey Optional privateKey to pass along to web3Manager sendTransaction
+   * @param dryRun Optional parameter to return the generated parameters without sending tx
+   * @returns comma-separated String of serviceType and serviceVersion if dryRun; else response from web3Manager.sendTransaction
+   */
+  async setServiceVersion(
+    serviceType: string,
+    serviceVersion: string,
+    privateKey: string | null = null,
+    dryRun = false
+  ) {
+    const method = await this.getGovernedMethod(
+      'setServiceVersion',
+      Utils.utf8ToHex(serviceType),
+      Utils.utf8ToHex(serviceVersion)
+    )
+
+    if (dryRun) {
+      return `${Utils.utf8ToHex(serviceType)},${Utils.utf8ToHex(
+        serviceVersion
+      )}`
+    }
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      await this.governanceClient.getAddress(),
+      privateKey
+    )
+  }
+
+  async addServiceType(
+    serviceType: string,
+    serviceTypeMin: string,
+    serviceTypeMax: string,
+    privateKey: string | null = null
+  ) {
+    const method = await this.getGovernedMethod(
+      'addServiceType',
+      Utils.utf8ToHex(serviceType),
+      serviceTypeMin,
+      serviceTypeMax
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      await this.governanceClient.getAddress(),
+      privateKey
+    )
+  }
+
+  async getValidServiceTypes() {
+    const method = await this.getMethod('getValidServiceTypes')
+    const types: string[] = await method.call()
+    return types.map((t) => Utils.hexToUtf8(t))
+  }
+
+  async getCurrentVersion(serviceType: string) {
+    const method = await this.getMethod(
+      'getCurrentVersion',
+      Utils.utf8ToHex(serviceType)
+    )
+    const hexVersion = await method.call()
+    return Utils.hexToUtf8(hexVersion)
+  }
+
+  async getVersion(serviceType: string, serviceTypeIndex: number) {
+    const serviceTypeBytes32 = Utils.utf8ToHex(serviceType)
+    const method = await this.getMethod(
+      'getVersion',
+      serviceTypeBytes32,
+      serviceTypeIndex
+    )
+    const version = await method.call()
+    return Utils.hexToUtf8(version)
+  }
+
+  async getNumberOfVersions(serviceType: string) {
+    const method = await this.getMethod(
+      'getNumberOfVersions',
+      Utils.utf8ToHex(serviceType)
+    )
+    return parseInt(await method.call())
+  }
+
+  /**
+   * @notice Add a new service type
+   * @returns {
+   *  isValid: Is the types type is isValid
+   *  minStake: minimum stake for service type
+   *  maxStake: minimum stake for service type
+   * }
+   */
+  async getServiceTypeInfo(serviceType: string) {
+    const method = await this.getMethod(
+      'getServiceTypeInfo',
+      Utils.utf8ToHex(serviceType)
+    )
+    const response = await method.call()
+    return {
+      isValid: response[0],
+      minStake: Utils.toBN(response[1]),
+      maxStake: Utils.toBN(response[2])
+    }
+  }
+}

package/src/services/ethContracts/StakingProxyClient.ts

@@ -0,0 +1,97 @@
+import type { ContractABI, Logger } from '../../utils'
+import { ContractClient, GetRegistryAddress } from '../contracts/ContractClient'
+import type { EthWeb3Manager } from '../ethWeb3Manager'
+import type { AudiusTokenClient } from './AudiusTokenClient'
+import type BN from 'bn.js'
+
+export class StakingProxyClient extends ContractClient {
+  audiusTokenClient: AudiusTokenClient
+  toBN: (value: string | number) => BN
+
+  constructor(
+    ethWeb3Manager: EthWeb3Manager,
+    contractABI: ContractABI['abi'],
+    contractRegistryKey: string,
+    getRegistryAddress: GetRegistryAddress,
+    audiusTokenClient: AudiusTokenClient,
+    logger: Logger = console
+  ) {
+    super(
+      ethWeb3Manager,
+      contractABI,
+      contractRegistryKey,
+      getRegistryAddress,
+      logger
+    )
+    this.audiusTokenClient = audiusTokenClient
+    this.toBN = ethWeb3Manager.getWeb3().utils.toBN
+  }
+
+  async token() {
+    const method = await this.getMethod('token')
+    return method.call()
+  }
+
+  async totalStaked() {
+    const method = await this.getMethod('totalStaked')
+    return this.toBN(await method.call())
+  }
+
+  async supportsHistory() {
+    const method = await this.getMethod('supportsHistory')
+    return method.call()
+  }
+
+  async totalStakedFor(account: string) {
+    const method = await this.getMethod('totalStakedFor', account)
+    return this.toBN(await method.call())
+  }
+
+  async totalStakedForAt(account: string, blockNumber: string) {
+    const method = await this.getMethod(
+      'totalStakedForAt',
+      account,
+      blockNumber
+    )
+    return this.toBN(await method.call())
+  }
+
+  async totalStakedAt(blockNumber: number) {
+    const method = await this.getMethod('totalStakedAt', blockNumber)
+    return this.toBN(await method.call())
+  }
+
+  async isStaker(account: string) {
+    const method = await this.getMethod('isStaker', account)
+    return method.call()
+  }
+
+  async getDelegateManagerAddress() {
+    const method = await this.getMethod('getDelegateManagerAddress')
+    return method.call()
+  }
+
+  async getClaimsManagerAddress() {
+    const method = await this.getMethod('getClaimsManagerAddress')
+    return method.call()
+  }
+
+  async getServiceProviderFactoryAddress() {
+    const method = await this.getMethod('getServiceProviderFactoryAddress')
+    return method.call()
+  }
+
+  async getGovernanceAddress() {
+    const method = await this.getMethod('getGovernanceAddress')
+    return method.call()
+  }
+
+  async getLastClaimedBlockForUser() {
+    const method = await this.getMethod(
+      'lastClaimedFor',
+      this.web3Manager.getWalletAddress()
+    )
+    const tx = await method.call()
+    return tx
+  }
+}

package/src/services/ethContracts/TrustedNotifierManagerClient.ts

@@ -0,0 +1,101 @@
+import { GovernedContractClient } from '../contracts/GovernedContractClient'
+
+export class TrustedNotifierManagerClient extends GovernedContractClient {
+  /**
+   * Register Trusted Notifier with specified fields (wallet, endpoint, email)
+   * @notice Only callable by Governance contract
+   * @notice All fields must be unique and non-falsey
+   * @notice New Trusted Notifier is assigned an auto-incremented integer ID
+   * @returns Newly assigned integer ID
+   */
+  async registerNotifier(
+    wallet: string,
+    endpoint: string,
+    email: string,
+    privateKey: string | null = null
+  ) {
+    const method = await this.getGovernedMethod(
+      'registerNotifier',
+      wallet,
+      endpoint,
+      email
+    )
+    return await this.web3Manager.sendTransaction(
+      method,
+      await this.governanceClient.getAddress(),
+      privateKey
+    )
+  }
+
+  /**
+   * Deregister Trusted Notifier associated with wallet
+   * @notice Only callable by Governance contract or wallet
+   * @returns ID of deregistered Trusted Notifier
+   */
+  async deregisterNotifier(wallet: string, privateKey: string | null = null) {
+    const method = await this.getGovernedMethod('deregisterNotifier', wallet)
+    return await this.web3Manager.sendTransaction(
+      method,
+      await this.governanceClient.getAddress(),
+      privateKey
+    )
+  }
+
+  async getLatestNotifierID() {
+    const method = await this.getMethod('getLatestNotifierID')
+    const ID = await method.call()
+    return parseInt(ID)
+  }
+
+  /**
+   * Returns all TrustedNotifier info associated with ID
+   */
+  async getNotifierForID(ID: string) {
+    const method = await this.getMethod('getNotifierForID', ID)
+    const notifierInfo = await method.call()
+    return {
+      wallet: notifierInfo.wallet,
+      endpoint: notifierInfo.endpoint.replace(/\/$/, ''),
+      email: notifierInfo.email.replace(/\/$/, '')
+    }
+  }
+
+  /**
+   * Returns all TrustedNotifier info associated with wallet
+   */
+  async getNotifierForWallet(wallet: string) {
+    const method = await this.getMethod('getNotifierForWallet', wallet)
+    const notifierInfo = await method.call()
+    return {
+      ID: notifierInfo.ID,
+      endpoint: notifierInfo.endpoint.replace(/\/$/, ''),
+      email: notifierInfo.email.replace(/\/$/, '')
+    }
+  }
+
+  /**
+   * Returns all TrustedNotifier info associated with endpoint
+   */
+  async getNotifierForEndpoint(endpoint: string) {
+    const method = await this.getMethod('getNotifierForEndpoint', endpoint)
+    const notifierInfo = await method.call()
+    return {
+      ID: notifierInfo.ID,
+      wallet: notifierInfo.wallet,
+      email: notifierInfo.email.replace(/\/$/, '')
+    }
+  }
+
+  /**
+   * Returns all TrustedNotifier info associated with email
+   */
+  async getNotifierForEmail(email: string) {
+    const method = await this.getMethod('getNotifierForEmail', email)
+    const notifierInfo = await method.call()
+    return {
+      ID: notifierInfo.ID,
+      wallet: notifierInfo.wallet,
+      endpoint: notifierInfo.endpoint.replace(/\/$/, '')
+    }
+  }
+}

package/src/services/ethContracts/WormholeClient.ts

@@ -0,0 +1,97 @@
+import type Web3 from 'web3'
+import type { ContractABI } from '../../utils'
+import type { EthWeb3Manager } from '../ethWeb3Manager'
+import type { AudiusTokenClient } from './AudiusTokenClient'
+import type { Contract } from 'web3-eth-contract'
+import type BN from 'bn.js'
+
+export class WormholeClient {
+  ethWeb3Manager: EthWeb3Manager
+  contractABI: ContractABI['abi']
+  contractAddress: string
+  web3: Web3
+  audiusTokenClient: AudiusTokenClient
+  WormholeContract: Contract
+
+  constructor(
+    ethWeb3Manager: EthWeb3Manager,
+    contractABI: ContractABI['abi'],
+    contractAddress: string,
+    audiusTokenClient: AudiusTokenClient
+  ) {
+    this.ethWeb3Manager = ethWeb3Manager
+    this.contractABI = contractABI
+    this.contractAddress = contractAddress
+
+    this.web3 = this.ethWeb3Manager.getWeb3()
+    this.audiusTokenClient = audiusTokenClient
+    this.WormholeContract = new this.web3.eth.Contract(
+      this.contractABI,
+      this.contractAddress
+    )
+  }
+
+  // Get the name of the contract
+  async nonces(wallet: string) {
+    // Pass along a unique param so the nonce value is always not cached
+    const nonce = await this.WormholeContract.methods.nonces(wallet).call({
+      _audiusBustCache: Date.now()
+    })
+    const number = this.web3.utils.toBN(nonce).toNumber()
+    return number
+  }
+
+  /* ------- SETTERS ------- */
+
+  async initialize(fromAcct: string, wormholeAddress: string, relayer: string) {
+    const method = this.WormholeContract.methods.initialize(
+      this.audiusTokenClient.contractAddress,
+      wormholeAddress
+    )
+
+    const tx = await this.ethWeb3Manager.relayTransaction(
+      method,
+      this.contractAddress,
+      fromAcct,
+      relayer,
+      /* retries */ 0
+    )
+    return { txReceipt: tx }
+  }
+
+  /**
+   * Transfers in eth from the user's wallet to the wormhole contract and
+   * specifies a solana wallet to realized the tokens in SOL
+   */
+  async transferTokens(
+    fromAcct: string,
+    amount: BN,
+    chainId: number,
+    solanaAccount: string,
+    arbiterFee: string,
+    deadline: string,
+    signedDigest: { v: string; r: string; s: string },
+    relayer: string
+  ) {
+    const method = this.WormholeContract.methods.transferTokens(
+      fromAcct,
+      amount,
+      chainId,
+      solanaAccount,
+      arbiterFee,
+      deadline,
+      signedDigest.v,
+      signedDigest.r,
+      signedDigest.s
+    )
+    const tx = await this.ethWeb3Manager.relayTransaction(
+      method,
+      this.contractAddress,
+      fromAcct,
+      relayer,
+      /* retries */ 0,
+      null
+    )
+    return tx
+  }
+}

package/src/services/ethContracts/index.ts

@@ -0,0 +1 @@
+export * from './EthContracts'

package/src/services/ethWeb3Manager/EthWeb3Manager.ts

@@ -0,0 +1,239 @@
+import Web3 from '../../web3'
+import type Web3Type from 'web3'
+import { MultiProvider, estimateGas, ContractMethod, Maybe } from '../../utils'
+import { Transaction as EthereumTx } from 'ethereumjs-tx'
+import retry from 'async-retry'
+import type { IdentityService, RelayTransaction } from '../identity'
+import type { Hedgehog } from '@audius/hedgehog'
+import type { AxiosError } from 'axios'
+import type Wallet from 'ethereumjs-wallet'
+import type { TransactionReceipt } from 'web3-core'
+
+const MIN_GAS_PRICE = Math.pow(10, 9) // 1 GWei, ETH minimum allowed gas price
+const HIGH_GAS_PRICE = 250 * MIN_GAS_PRICE // 250 GWei
+const DEFAULT_GAS_PRICE = 100 * MIN_GAS_PRICE // 100 Gwei is a reasonably average gas price
+const MAX_GAS_LIMIT = 5000000 // We've seen prod tx's take up to 4M. Set to the highest we've observed + a buffer
+
+export type EthWeb3Config = {
+  ownerWallet: Wallet | string
+  providers: string[]
+}
+
+type EthWeb3ManagerConfig = {
+  web3Config: EthWeb3Config
+  identityService: IdentityService
+  hedgehog?: Hedgehog
+}
+
+/** Singleton state-manager for Audius Eth Contracts */
+export class EthWeb3Manager {
+  web3Config: EthWeb3Config
+  web3: Web3Type
+  identityService: IdentityService
+  hedgehog?: Hedgehog
+  ownerWallet: Maybe<Wallet | string>
+
+  constructor({ web3Config, identityService, hedgehog }: EthWeb3ManagerConfig) {
+    if (!web3Config) throw new Error('web3Config object not passed in')
+    if (!web3Config.providers)
+      throw new Error('missing web3Config property: providers')
+
+    // MultiProvider implements a web3 provider with fallback.
+    const provider = new MultiProvider(web3Config.providers)
+
+    this.web3Config = web3Config
+    this.web3 = new Web3(provider)
+    this.identityService = identityService
+    this.hedgehog = hedgehog
+
+    // Hedgehog might not exist (in the case of @audius/sdk)
+    if (this.hedgehog) {
+      if (this.web3Config.ownerWallet) {
+        this.ownerWallet = this.web3Config.ownerWallet
+      } else {
+        const storedWallet = this.hedgehog.getWallet()
+        if (storedWallet) {
+          this.ownerWallet = storedWallet
+        }
+      }
+    }
+  }
+
+  getWeb3() {
+    return this.web3
+  }
+
+  getWalletAddress() {
+    if (this.ownerWallet) {
+      // @ts-expect-error TODO extend ethereum-js-wallet to include toLowerCase
+      return this.ownerWallet.toLowerCase()
+    }
+    throw new Error('Owner wallet not set')
+  }
+
+  /**
+   * Signs provided string data (should be timestamped).
+   */
+  async sign(data: string) {
+    // @ts-expect-error TODO: sign expected to take a password as 3rd argument
+    return await this.web3.eth.personal.sign(
+      this.web3.utils.fromUtf8(data),
+      this.getWalletAddress()
+    )
+  }
+
+  async sendTransaction(
+    contractMethod: ContractMethod,
+    contractAddress: string | null = null,
+    privateKey: string | null = null,
+    txRetries = 5,
+    txGasLimit: number | null = null
+  ): Promise<TransactionReceipt> {
+    const gasLimit =
+      txGasLimit ??
+      (await estimateGas({
+        method: contractMethod,
+        from: this.ownerWallet,
+        gasLimitMaximum: MAX_GAS_LIMIT
+      }))
+    if (contractAddress && privateKey) {
+      let gasPrice = parseInt(await this.web3.eth.getGasPrice())
+      if (isNaN(gasPrice) || gasPrice > HIGH_GAS_PRICE) {
+        gasPrice = DEFAULT_GAS_PRICE
+      } else if (gasPrice === 0) {
+        // If the gas is zero, the txn will likely never get mined.
+        gasPrice = MIN_GAS_PRICE
+      }
+      const gasPriceStr = '0x' + gasPrice.toString(16)
+
+      const privateKeyBuffer = Buffer.from(privateKey, 'hex')
+      const walletAddress = this.getWalletAddress()
+      const txCount = await this.web3.eth.getTransactionCount(walletAddress)
+      const encodedABI = contractMethod.encodeABI()
+      const txParams = {
+        nonce: this.web3.utils.toHex(txCount),
+        gasPrice: gasPriceStr,
+        gasLimit,
+        data: encodedABI,
+        to: contractAddress,
+        value: '0x00'
+      }
+      const tx = new EthereumTx(txParams)
+      tx.sign(privateKeyBuffer)
+      const signedTx = '0x' + tx.serialize().toString('hex')
+
+      // Send the tx with retries
+      const response = await retry(
+        async () => {
+          return await this.web3.eth.sendSignedTransaction(signedTx)
+        },
+        {
+          // Retry function 5x by default
+          // 1st retry delay = 500ms, 2nd = 1500ms, 3rd...nth retry = 4000 ms (capped)
+          minTimeout: 500,
+          maxTimeout: 4000,
+          factor: 3,
+          retries: txRetries,
+          onRetry: (err) => {
+            if (err) {
+              console.log(
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string -- TODO
+                `libs ethWeb3Manager transaction send retry error : ${err}`
+              )
+            }
+          }
+        }
+      )
+
+      return response
+    }
+
+    const gasPrice = parseInt(await this.web3.eth.getGasPrice())
+    return await contractMethod.send({
+      from: this.ownerWallet,
+      gas: gasLimit,
+      gasPrice: gasPrice
+    })
+  }
+
+  /**
+   * Relays an eth transaction via the identity service with retries
+   * The relay pays for the transaction fee on behalf of the user
+   * The gas Limit is estimated if not provided
+   */
+  async relayTransaction(
+    contractMethod: ContractMethod,
+    contractAddress: string,
+    ownerWallet: Wallet | string,
+    relayerWallet?: Wallet | string,
+    txRetries = 5,
+    txGasLimit: number | null = null
+  ): Promise<Maybe<RelayTransaction['resp']>> {
+    const encodedABI = contractMethod.encodeABI()
+    const gasLimit =
+      txGasLimit ??
+      (await estimateGas({
+        from: relayerWallet,
+        method: contractMethod,
+        gasLimitMaximum: MAX_GAS_LIMIT
+      }))
+
+    const response = await retry<Maybe<RelayTransaction>>(
+      async (bail) => {
+        try {
+          const attempt = await this.identityService.ethRelay(
+            contractAddress,
+            ownerWallet,
+            encodedABI,
+            gasLimit.toString()
+          )
+          return attempt
+        } catch (e) {
+          const error = e as AxiosError
+          if (error.response?.status === 429) {
+            // Don't retry in the case we are getting rate limited
+            bail(new Error('Please wait before trying again'))
+            return
+          }
+          // Trigger a retry
+          throw error
+        }
+      },
+      {
+        // Retry function 5x by default
+        // 1st retry delay = 500ms, 2nd = 1500ms, 3rd...nth retry = 4000 ms (capped)
+        minTimeout: 500,
+        maxTimeout: 4000,
+        factor: 3,
+        retries: txRetries,
+        onRetry: (err) => {
+          if (err) {
+            console.log(
+              // eslint-disable-next-line @typescript-eslint/no-base-to-string -- TODO
+              `libs ethWeb3Manager transaction relay retry error : ${err}`
+            )
+          }
+        }
+      }
+    )
+    return response?.resp
+  }
+
+  async getRelayMethodParams(
+    contractAddress: string,
+    contractMethod: ContractMethod,
+    relayerWallet: Wallet
+  ) {
+    const encodedABI = contractMethod.encodeABI()
+    const gasLimit = await estimateGas({
+      from: relayerWallet,
+      method: contractMethod,
+      gasLimitMaximum: HIGH_GAS_PRICE
+    })
+    return {
+      contractAddress,
+      encodedABI,
+      gasLimit
+    }
+  }
+}

package/src/services/ethWeb3Manager/index.ts

@@ -0,0 +1 @@
+export * from './EthWeb3Manager'