@audius/sdk 0.0.0

package/src/services/ethContracts/AudiusTokenClient.ts

@@ -0,0 +1,163 @@
+import type Web3 from 'web3'
+import type { EthWeb3Manager } from '../ethWeb3Manager'
+import type { Contract } from 'web3-eth-contract'
+import type { AbiItem } from 'web3-utils'
+import type BN from 'bn.js'
+
+export class AudiusTokenClient {
+  ethWeb3Manager: EthWeb3Manager
+  contractABI: AbiItem[]
+  contractAddress: string
+  web3: Web3
+  AudiusTokenContract: Contract
+  bustCacheNonce: number
+
+  constructor(
+    ethWeb3Manager: EthWeb3Manager,
+    contractABI: AbiItem[],
+    contractAddress: string
+  ) {
+    this.ethWeb3Manager = ethWeb3Manager
+    this.contractABI = contractABI
+    this.contractAddress = contractAddress
+
+    this.web3 = this.ethWeb3Manager.getWeb3()
+    this.AudiusTokenContract = new this.web3.eth.Contract(
+      this.contractABI,
+      this.contractAddress
+    )
+
+    this.bustCacheNonce = 0
+  }
+
+  /* ------- GETTERS ------- */
+
+  async bustCache() {
+    this.bustCacheNonce += 1
+  }
+
+  async balanceOf(account: string) {
+    let args
+    if (this.bustCacheNonce > 0) {
+      args = { _audiusBustCache: this.bustCacheNonce }
+    }
+    const balance = await this.AudiusTokenContract.methods
+      .balanceOf(account)
+      .call(args)
+    return this.web3.utils.toBN(balance)
+  }
+
+  // Get the name of the contract
+  async name() {
+    const name = await this.AudiusTokenContract.methods.name().call()
+    return name
+  }
+
+  // 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.AudiusTokenContract.methods.nonces(wallet).call({
+      _audiusBustCache: Date.now()
+    })
+    const number = this.web3.utils.toBN(nonce).toNumber()
+    return number
+  }
+
+  /* ------- SETTERS ------- */
+
+  async transfer(recipient: string, amount: BN) {
+    const contractMethod = this.AudiusTokenContract.methods.transfer(
+      recipient,
+      amount
+    )
+    const tx = await this.ethWeb3Manager.sendTransaction(contractMethod)
+    return { txReceipt: tx }
+  }
+
+  async transferFrom(
+    owner: string,
+    recipient: string,
+    relayer: string,
+    amount: BN
+  ) {
+    const method = this.AudiusTokenContract.methods.transferFrom(
+      owner,
+      recipient,
+      amount
+    )
+    const tx = await this.ethWeb3Manager.relayTransaction(
+      method,
+      this.contractAddress,
+      owner,
+      relayer,
+      /* retries */ 0
+    )
+    return { txReceipt: tx }
+  }
+
+  // Permit meta transaction of balance transfer
+  async permit(
+    owner: string, // address
+    spender: string, // address
+    value: BN, // uint
+    deadline: number, // uint
+    v: number, // uint8
+    r: Uint8Array | Buffer, // bytes32
+    s: Uint8Array | Buffer // bytes32
+  ) {
+    const contractMethod = this.AudiusTokenContract.methods.permit(
+      owner,
+      spender,
+      value,
+      deadline,
+      v,
+      r,
+      s
+    )
+    const tx = await this.ethWeb3Manager.relayTransaction(
+      contractMethod,
+      this.contractAddress,
+      owner,
+      spender,
+      /* retries */ 0
+    )
+    return tx
+  }
+
+  // Allow spender to withdraw from calling account up to value amount
+  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
+  async approve(spender: string, value: BN, privateKey = null) {
+    const contractMethod = this.AudiusTokenContract.methods.approve(
+      spender,
+      value
+    )
+    let tx
+    if (privateKey === null) {
+      tx = await this.ethWeb3Manager.sendTransaction(contractMethod)
+    } else {
+      tx = await this.ethWeb3Manager.sendTransaction(
+        contractMethod,
+        this.contractAddress,
+        privateKey
+      )
+    }
+    return { txReceipt: tx }
+  }
+
+  async approveProxyTokens(
+    owner: string,
+    spender: string,
+    value: BN,
+    relayer: string
+  ) {
+    const method = this.AudiusTokenContract.methods.approve(spender, value)
+    const tx = await this.ethWeb3Manager.relayTransaction(
+      method,
+      this.contractAddress,
+      owner,
+      relayer,
+      /* retries */ 0
+    )
+    return { txReceipt: tx }
+  }
+}

package/src/services/ethContracts/ClaimDistributionClient.ts

@@ -0,0 +1,45 @@
+import type BN from 'bn.js'
+import { ContractClient } from '../contracts/ContractClient'
+import type { EthWeb3Manager } from '../ethWeb3Manager'
+
+export class ClaimDistributionClient extends ContractClient {
+  // ===================== Contract Methods =====================
+  /**
+   * Calls the contract method to check if the claim index has been claimed
+   */
+  async isClaimed(index: number) {
+    const method = await this.getMethod('isClaimed', index)
+    const isClaimed = await method.call()
+    return isClaimed
+  }
+
+  /**
+   * Proxies the calls the contract method to make a claim
+   * @param index
+   * @param account
+   * @param amount
+   * @param merkleProof
+   * @returns transaction
+   */
+  async claim(
+    index: number,
+    account: string,
+    amount: BN,
+    merkleProof: string[]
+  ) {
+    const method = await this.getMethod(
+      'claim',
+      index,
+      account,
+      amount,
+      merkleProof
+    )
+    const contractAddress = await this.getAddress()
+    const tx = await (this.web3Manager as EthWeb3Manager).relayTransaction(
+      method,
+      contractAddress,
+      account
+    )
+    return tx
+  }
+}

package/src/services/ethContracts/ClaimsManagerClient.ts

@@ -0,0 +1,102 @@
+import { Utils } from '../../utils'
+import { ContractClient } from '../contracts/ContractClient'
+import type { EthWeb3Manager } from '../ethWeb3Manager'
+
+export class ClaimsManagerClient extends ContractClient {
+  // @ts-expect-error defined in ContractClient
+  override web3Manager: EthWeb3Manager
+  /* ------- GETTERS ------- */
+
+  // Get the duration of a funding round in blocks
+  async getFundingRoundBlockDiff() {
+    const method = await this.getMethod('getFundingRoundBlockDiff')
+    const info = await method.call()
+    return parseInt(info)
+  }
+
+  // Get the last block where a funding round was initiated
+  async getLastFundedBlock() {
+    const method = await this.getMethod('getLastFundedBlock')
+    const info = await method.call()
+    return parseInt(info)
+  }
+
+  // Get the amount funded per round in wei
+  async getFundsPerRound() {
+    const method = await this.getMethod('getFundsPerRound')
+    const info = await method.call()
+    return Utils.toBN(info)
+  }
+
+  // Get the total amount claimed in the current round
+  async getTotalClaimedInRound() {
+    const method = await this.getMethod('getTotalClaimedInRound')
+    const info = await method.call()
+    return Utils.toBN(info)
+  }
+
+  // Get the Governance address
+  async getGovernanceAddress() {
+    const method = await this.getMethod('getGovernanceAddress')
+    const info = await method.call()
+    return info
+  }
+
+  // Get the ServiceProviderFactory address
+  async getServiceProviderFactoryAddress() {
+    const method = await this.getMethod('getServiceProviderFactoryAddress')
+    const info = await method.call()
+    return info
+  }
+
+  // Get the DelegateManager address
+  async getDelegateManagerAddress() {
+    const method = await this.getMethod('getDelegateManagerAddress')
+    const info = await method.call()
+    return info
+  }
+
+  // Get the Staking address
+  async getStakingAddress() {
+    const method = await this.getMethod('getStakingAddress')
+    const info = await method.call()
+    return info
+  }
+
+  // Returns boolean indicating whether a claim is considered pending
+  async claimPending(address: string) {
+    const method = await this.getMethod('claimPending', address)
+    const info = await method.call()
+    return info
+  }
+
+  // Returns boolean indicating whether a claim is considered pending
+  async initiateRound(txRetries = 5) {
+    const method = await this.getMethod('initiateRound')
+    return await this.web3Manager.sendTransaction(method, null, null, txRetries)
+  }
+
+  // Fetches the claim processed events
+  async getClaimProcessedEvents({
+    claimer,
+    queryStartBlock = 0
+  }: {
+    claimer: string
+    queryStartBlock: number
+  }) {
+    const contract = await this.getContract()
+    const events = await contract.getPastEvents('ClaimProcessed', {
+      fromBlock: queryStartBlock,
+      filter: {
+        _claimer: claimer
+      }
+    })
+    return events.map((event) => ({
+      blockNumber: parseInt(event.blockNumber as unknown as string),
+      claimer: event.returnValues['_claimer'],
+      rewards: Utils.toBN(event.returnValues['_rewards']),
+      oldTotal: Utils.toBN(event.returnValues['_oldTotal']),
+      newTotal: Utils.toBN(event.returnValues['_newTotal'])
+    }))
+  }
+}