@audius/sdk 0.0.0

package/src/services/solanaWeb3Manager/index.js

@@ -0,0 +1,655 @@
+const solanaWeb3 = require('@solana/web3.js')
+const splToken = require('@solana/spl-token')
+const anchor = require('@project-serum/anchor')
+const { idl } = require('@audius/anchor-audius-data')
+
+const { transferWAudioBalance } = require('./transfer')
+const { getBankAccountAddress, createUserBankFrom } = require('./userBank')
+const {
+  createAssociatedTokenAccount,
+  getAssociatedTokenAccountInfo,
+  findAssociatedTokenAddress
+} = require('./tokenAccount')
+const { wAudioFromWeiAudio } = require('./wAudio')
+const { Utils } = require('../../utils')
+const SolanaUtils = require('./utils')
+const { TransactionHandler } = require('./transactionHandler')
+const {
+  submitAttestations,
+  evaluateAttestations,
+  createSender,
+  deriveSolanaSenderFromEthAddress
+} = require('./rewards')
+const { AUDIO_DECMIALS, WAUDIO_DECMIALS } = require('../../constants')
+
+const { PublicKey } = solanaWeb3
+
+// Somewhat arbitrary close-to-zero number of Sol. For context, creating a UserBank costs ~0.002 SOL.
+// Without this padding, we could reach some low non-zero number of SOL where transactions would fail
+// despite a remaining balance.
+const ZERO_SOL_EPSILON = 0.005
+const SOL_PER_LAMPORT = 0.000000001
+
+// Generous default connection confirmation timeout to better cope with RPC congestion
+const DEFAULT_CONNECTION_CONFIRMATION_TIMEOUT_MS = 180 * 1000
+
+/**
+ * @typedef {import("./rewards.js").AttestationMeta} AttestationMeta
+ */
+
+/**
+ * SolanaWeb3Manager acts as the interface to solana contracts from a client.
+ * It wraps methods to create and lookup user banks, transfer balances, and
+ * interact with the @solana/web3 library.
+ *
+ * Note: Callers of this class should specify all $AUDIO amounts in units of wei.
+ * The internals of this class should handle the conversion from wei AUDIO to wormhole
+ * $AUDIO amounts.
+ */
+class SolanaWeb3Manager {
+  /**
+   * @param {Object} solanaWeb3Config
+   * @param {string} solanaWeb3Config.solanaClusterEndpoint
+   *  the solana cluster RPC endpoint
+   * @param {string} solanaWeb3Config.mintAddress
+   *  address for the wAudio mint - Audius (Wormhole) token
+   * @param {string} solanaWeb3Config.solanaTokenAddress
+   *  the SPL token program address
+   * @param {string} solanaWeb3Config.claimableTokenPDA
+   *  the program derived address for the claimable token program (using the mint)
+   * @param {string} solanaWeb3Config.feePayerAddress
+   *  the address for the specific fee payer to be used in relayed transactions
+   * @param {string} solanaWeb3Config.claimableTokenProgramAddress
+   *  the address for the claimable token program used to create banks and transfer wAudio
+   * @param {string} solanaWeb3Config.rewardsManagerProgramId
+   *  the ID of the rewards manager program
+   * @param {string} solanaWeb3Config.rewardsManagerProgramPDA
+   *  the manager account of the rewards manager program
+   * @param {string} solanaWeb3Config.rewardsManagerTokenPDA
+   *  the token holder account of the rewards manager program
+   * @param {boolean} solanaWeb3Config.useRelay
+   *  whether to submit transactions via a relay, or locally
+   * @param {KeyPair} solanaWeb3Config.feePayerKepairs
+   *  KeyPairs for feepayers
+   * @param {number} [solanaWeb3Config.confirmationTimeout] optional default confirmation timeout
+   * @param {PublicKey} [solanaWeb3Config.audiusDataProgramId]
+   *  Program ID for audius-data anchor program
+   * @param {PublicKey} [solanaWeb3Config.audiusDataAdminStorageKeypairPublicKey]
+   *  PK for audius-data admin storage keypair
+   * @param {anchor.Idl} [solanaWeb3Config.audiusDataIdl]
+   *  IDL for audius-data program
+   * @param {IdentityService} identityService
+   * @param {Web3Manager} web3Manager
+   */
+  constructor (solanaWeb3Config, identityService, web3Manager) {
+    this.solanaWeb3Config = solanaWeb3Config
+    this.identityService = identityService
+    this.web3Manager = web3Manager
+
+    this.solanaWeb3 = solanaWeb3
+    this.splToken = splToken
+  }
+
+  async init () {
+    const {
+      solanaClusterEndpoint,
+      mintAddress,
+      solanaTokenAddress,
+      claimableTokenPDA,
+      feePayerAddress,
+      claimableTokenProgramAddress,
+      rewardsManagerProgramId,
+      rewardsManagerProgramPDA,
+      rewardsManagerTokenPDA,
+      useRelay,
+      feePayerKeypairs,
+      confirmationTimeout,
+      audiusDataProgramId,
+      audiusDataAdminStorageKeypairPublicKey,
+      audiusDataIdl
+    } = this.solanaWeb3Config
+
+    this.solanaClusterEndpoint = solanaClusterEndpoint
+    this.connection = new solanaWeb3.Connection(this.solanaClusterEndpoint, {
+      confirmTransactionInitialTimeout:
+        confirmationTimeout || DEFAULT_CONNECTION_CONFIRMATION_TIMEOUT_MS
+    })
+
+    this.transactionHandler = new TransactionHandler({
+      connection: this.connection,
+      useRelay,
+      identityService: this.identityService,
+      feePayerKeypairs
+    })
+
+    this.mintAddress = mintAddress
+    this.mintKey = SolanaUtils.newPublicKeyNullable(mintAddress)
+
+    this.solanaTokenAddress = solanaTokenAddress
+    this.solanaTokenKey = SolanaUtils.newPublicKeyNullable(solanaTokenAddress)
+
+    if (feePayerAddress) {
+      this.feePayerAddress = feePayerAddress
+      this.feePayerKey = SolanaUtils.newPublicKeyNullable(feePayerAddress)
+    } else if (feePayerKeypairs && feePayerKeypairs.length) {
+      this.feePayerAddress = feePayerKeypairs[0].publicKey
+      this.feePayerKey = SolanaUtils.newPublicKeyNullable(
+        feePayerKeypairs[0].publicKey
+      )
+    }
+
+    this.claimableTokenProgramKey = SolanaUtils.newPublicKeyNullable(
+      claimableTokenProgramAddress
+    )
+    this.claimableTokenPDA =
+      claimableTokenPDA ||
+      (this.claimableTokenProgramKey
+        ? (
+            await SolanaUtils.findProgramAddressFromPubkey(
+              this.claimableTokenProgramKey,
+              this.mintKey
+            )
+          )[0].toString()
+        : null)
+    this.claimableTokenPDAKey = SolanaUtils.newPublicKeyNullable(
+      this.claimableTokenPDA
+    )
+    this.rewardManagerProgramId = SolanaUtils.newPublicKeyNullable(
+      rewardsManagerProgramId
+    )
+    this.rewardManagerProgramPDA = SolanaUtils.newPublicKeyNullable(
+      rewardsManagerProgramPDA
+    )
+    this.rewardManagerTokenPDA = SolanaUtils.newPublicKeyNullable(
+      rewardsManagerTokenPDA
+    )
+    this.audiusDataProgramId = audiusDataProgramId
+    this.audiusDataAdminStorageKeypairPublicKey =
+      audiusDataAdminStorageKeypairPublicKey
+
+    this.audiusDataIdl = audiusDataIdl || idl
+
+    if (
+      this.audiusDataProgramId &&
+      this.audiusDataAdminStorageKeypairPublicKey &&
+      this.audiusDataIdl
+    ) {
+      const connection = new solanaWeb3.Connection(
+        this.solanaClusterEndpoint,
+        anchor.AnchorProvider.defaultOptions()
+      )
+      const anchorProvider = new anchor.AnchorProvider(
+        connection,
+        solanaWeb3.Keypair.generate(),
+        anchor.AnchorProvider.defaultOptions()
+      )
+      this.anchorProgram = new anchor.Program(
+        this.audiusDataIdl,
+        audiusDataProgramId,
+        anchorProvider
+      )
+    }
+  }
+
+  /**
+   * Creates a solana bank account from the web3 provider's eth address
+   */
+  async createUserBank (feePayerOverride) {
+    if (!this.web3Manager) {
+      throw new Error(
+        'A web3Manager is required for this solanaWeb3Manager method'
+      )
+    }
+
+    const ethAddress = this.web3Manager.getWalletAddress()
+    return createUserBankFrom({
+      ethAddress,
+      claimableTokenPDAKey: this.claimableTokenPDAKey,
+      feePayerKey:
+        SolanaUtils.newPublicKeyNullable(feePayerOverride) || this.feePayerKey,
+      mintKey: this.mintKey,
+      solanaTokenProgramKey: this.solanaTokenKey,
+      claimableTokenProgramKey: this.claimableTokenProgramKey,
+      connection: this.connection,
+      transactionHandler: this.transactionHandler
+    })
+  }
+
+  /**
+   * Creates a token account for the provided solana address (a wallet)
+   * See https://spl.solana.com/associated-token-account
+   * @param {string} solanaAddress
+   */
+  async createAssociatedTokenAccount (solanaAddress) {
+    await createAssociatedTokenAccount({
+      feePayerKey: this.feePayerKey,
+      solanaWalletKey: new PublicKey(solanaAddress),
+      mintKey: this.mintKey,
+      solanaTokenProgramKey: this.solanaTokenKey,
+      connection: this.connection,
+      identityService: this.identityService
+    })
+  }
+
+  /**
+   * Finds the wAudio token account for a provided solana address (a wallet)
+   * See https://spl.solana.com/associated-token-account
+   * @param {string} solanaAddress
+   */
+  async findAssociatedTokenAddress (solanaAddress) {
+    return findAssociatedTokenAddress({
+      solanaWalletKey: new PublicKey(solanaAddress),
+      mintKey: this.mintKey,
+      solanaTokenProgramKey: this.solanaTokenKey
+    })
+  }
+
+  /**
+   * Gets a solana bank account from the current we3 provider's eth address
+   * @returns {PublicKey} UserBank
+   */
+  async getUserBank () {
+    if (!this.web3Manager) {
+      throw new Error(
+        'A web3Manager is required for this solanaWeb3Manager method'
+      )
+    }
+    const ethAddress = this.web3Manager.getWalletAddress()
+    const bank = await getBankAccountAddress(
+      ethAddress,
+      this.claimableTokenPDAKey,
+      this.solanaTokenKey
+    )
+    return bank
+  }
+
+  /**
+   * Gets the info for a user bank/wAudio token account given a solana address.
+   * If the solanaAddress is not a valid token account, returns `null`
+   * @returns {AccountInfo | null}
+   */
+  async getAssociatedTokenAccountInfo (solanaAddress) {
+    try {
+      const res = await getAssociatedTokenAccountInfo({
+        tokenAccountAddressKey: new PublicKey(solanaAddress),
+        mintKey: this.mintKey,
+        solanaTokenProgramKey: this.solanaTokenKey,
+        connection: this.connection
+      })
+      return res
+    } catch (e) {
+      return null
+    }
+  }
+
+  /**
+   * Gets the SPL waudio balance for a solana address in wei with 18 decimals
+   * @returns {BN | null}
+   */
+  async getWAudioBalance (solanaAddress) {
+    try {
+      let tokenAccount = await this.getAssociatedTokenAccountInfo(solanaAddress)
+
+      // If the token account doesn't exist, check if solanaAddress is a root account
+      // if so, derive the associated token account & check that balance
+      if (!tokenAccount) {
+        const associatedTokenAccount = await this.findAssociatedTokenAddress(
+          solanaAddress
+        )
+        tokenAccount = await this.getAssociatedTokenAccountInfo(
+          associatedTokenAccount.toString()
+        )
+        if (!tokenAccount) {
+          return null
+        }
+      }
+
+      // Multiply by 10^10 to maintain same decimals as eth $AUDIO
+      const decimals = AUDIO_DECMIALS - WAUDIO_DECMIALS
+      return tokenAccount.amount.mul(Utils.toBN('1'.padEnd(decimals + 1, '0')))
+    } catch (e) {
+      return null
+    }
+  }
+
+  /**
+   * Transfers audio from the web3 provider's eth address
+   * @param {string} recipientSolanaAddress
+   *  Recipient solana address which is either a user bank, wAudio token account,
+   *  or a solana account. In the last case, an associated token account is created
+   *  if one does not already exist for the solana account
+   * @param {BN} amount the amount of $AUDIO to send in wei units of $AUDIO.
+   * **IMPORTANT NOTE**
+   * wAudio (Solana) does not support 10^-18 (wei) units of $AUDIO. The smallest
+   * demarcation on that side is 10^-8, so the $AUDIO amount must be >= 10^8 and have no
+   * remainder after a division with 10^8 or this method will throw.
+   *
+   * Generally speaking, callers into the solanaWeb3Manager should use BN.js representation
+   * of wei $AUDIO for all method calls
+   */
+  async transferWAudio (recipientSolanaAddress, amount) {
+    if (!this.web3Manager) {
+      throw new Error(
+        'A web3Manager is required for this solanaWeb3Manager method'
+      )
+    }
+
+    // Check if the solana address is a token account
+    let tokenAccountInfo = await this.getAssociatedTokenAccountInfo(
+      recipientSolanaAddress
+    )
+    if (!tokenAccountInfo) {
+      console.info('Provided recipient solana address was not a token account')
+      // If not, check to see if it already has an associated token account.
+      const associatedTokenAccount = await this.findAssociatedTokenAddress(
+        recipientSolanaAddress
+      )
+      tokenAccountInfo = await this.getAssociatedTokenAccountInfo(
+        associatedTokenAccount.toString()
+      )
+
+      // If it's not a valid token account, we need to make one first
+      if (!tokenAccountInfo) {
+        console.info(
+          'Provided recipient solana address has no associated token account, creating'
+        )
+        await this.createAssociatedTokenAccount(recipientSolanaAddress)
+      }
+      recipientSolanaAddress = associatedTokenAccount.toString()
+    }
+
+    console.info(
+      `Transfering ${amount.toString()} wei $AUDIO to ${recipientSolanaAddress}`
+    )
+
+    const wAudioAmount = wAudioFromWeiAudio(amount)
+
+    const ethAddress = this.web3Manager.getWalletAddress()
+    const senderSolanaAddress = await getBankAccountAddress(
+      ethAddress,
+      this.claimableTokenPDAKey,
+      this.solanaTokenKey
+    )
+    return transferWAudioBalance({
+      amount: wAudioAmount,
+      senderEthAddress: ethAddress,
+      feePayerKey: this.feePayerKey,
+      senderEthPrivateKey: this.web3Manager.getOwnerWalletPrivateKey(),
+      senderSolanaAddress,
+      recipientSolanaAddress,
+      claimableTokenPDA: this.claimableTokenPDAKey,
+      solanaTokenProgramKey: this.solanaTokenKey,
+      claimableTokenProgramKey: this.claimableTokenProgramKey,
+      connection: this.connection,
+      mintKey: this.mintKey,
+      transactionHandler: this.transactionHandler
+    })
+  }
+
+  /**
+   * Submits attestations for challenge completion to the RewardsManager program on Solana.
+   *
+   * @param {{
+   *     attestations: AttestationMeta[],
+   *     oracleAttestation: AttestationMeta,
+   *     challengeId: string,
+   *     specifier: string,
+   *     recipientEthAddress: string,
+   *     tokenAmount: BN,
+   *     instructionsPerTransaction?: number,
+   *     logger: any
+   *     feePayerOverride: string | null
+   * }} {
+   *     attestations,
+   *     oracleAttestation,
+   *     challengeId,
+   *     specifier,
+   *     recipientEthAddress,
+   *     tokenAmount,
+   *     instructionsPerTransaction,
+   *     logger
+   *     feePayerOverride
+   *    }
+   * @memberof SolanaWeb3Manager
+   */
+  async submitChallengeAttestations ({
+    attestations,
+    oracleAttestation,
+    challengeId,
+    specifier,
+    recipientEthAddress,
+    tokenAmount,
+    instructionsPerTransaction,
+    logger = console,
+    feePayerOverride = null
+  }) {
+    return submitAttestations({
+      rewardManagerProgramId: this.rewardManagerProgramId,
+      rewardManagerAccount: this.rewardManagerProgramPDA,
+      attestations,
+      oracleAttestation,
+      challengeId,
+      specifier,
+      feePayer:
+        SolanaUtils.newPublicKeyNullable(feePayerOverride) || this.feePayerKey,
+      recipientEthAddress,
+      tokenAmount,
+      transactionHandler: this.transactionHandler,
+      instructionsPerTransaction,
+      logger
+    })
+  }
+
+  /**
+   * Evaluates existing submitted attestations, disbursing if successful.
+   *
+   * @param {{
+   *    challengeId: string,
+   *    specifier: string,
+   *    recipientEthAddress: string
+   *    oracleEthAddress: string
+   *    logger: any
+   *    feePayerOverride: string | null
+   * }} {
+   *     challengeId,
+   *     specifier,
+   *     recipientEthAddress,
+   *     oracleEthAddress,
+   *     tokenAmount,
+   *     logger
+   *     feePayerOverride
+   *   }
+   * @memberof SolanaWeb3Manager
+   */
+  async evaluateChallengeAttestations ({
+    challengeId,
+    specifier,
+    recipientEthAddress,
+    oracleEthAddress,
+    tokenAmount,
+    logger = console,
+    feePayerOverride = null
+  }) {
+    return evaluateAttestations({
+      rewardManagerProgramId: this.rewardManagerProgramId,
+      rewardManagerAccount: this.rewardManagerProgramPDA,
+      rewardManagerTokenSource: this.rewardManagerTokenPDA,
+      challengeId,
+      specifier,
+      recipientEthAddress,
+      userBankProgramAccount: this.claimableTokenPDAKey,
+      oracleEthAddress,
+      feePayer:
+        SolanaUtils.newPublicKeyNullable(feePayerOverride) || this.feePayerKey,
+      tokenAmount,
+      transactionHandler: this.transactionHandler,
+      logger
+    })
+  }
+
+  /**
+   * Creates a new rewards signer (one that can attest)
+   * @param {{
+   *   senderEthAddress: string,
+   *   operatorEthAddress: string,
+   *   attestations: AttestationMeta[],
+   *   feePayerOverride?: string
+   * }} {
+   * @memberof SolanaWeb3Manager
+   */
+  async createSender ({
+    senderEthAddress,
+    operatorEthAddress,
+    attestations,
+    feePayerOverride = null
+  }) {
+    return createSender({
+      rewardManagerProgramId: this.rewardManagerProgramId,
+      rewardManagerAccount: this.rewardManagerProgramPDA,
+      senderEthAddress,
+      feePayer:
+        SolanaUtils.newPublicKeyNullable(feePayerOverride) || this.feePayerKey,
+      operatorEthAddress,
+      attestations,
+      identityService: this.identityService,
+      connection: this.connection,
+      transactionHandler: this.transactionHandler
+    })
+  }
+
+  /**
+   * Gets the balance of a PublicKey, in SOL
+   *
+   * @param {{
+   *  publicKey: PublicKey
+   * }} { publicKey }
+   * @return {Promise<number>}
+   * @memberof SolanaWeb3Manager
+   */
+  async getBalance ({ publicKey }) {
+    const lamports = await this.connection.getBalance(publicKey)
+    return lamports * SOL_PER_LAMPORT
+  }
+
+  /**
+   * Gets whether a PublicKey has a usable balance
+   *
+   * @param {{
+   *  publicKey: PublicKey,
+   *  epsilon?: number
+   * }} { publicKey }
+   * @return {Promise<boolean>}
+   * @memberof SolanaWeb3Manager
+   */
+  async hasBalance ({ publicKey, epsilon = ZERO_SOL_EPSILON }) {
+    const balance = await this.getBalance({ publicKey })
+    return balance > epsilon
+  }
+
+  async getSlot () {
+    return this.connection.getSlot('processed')
+  }
+
+  async getRandomFeePayer () {
+    return this.identityService.getRandomFeePayer()
+  }
+
+  /**
+   * Gets whether a given node registered on eth with `senderEthAddress` is registered on Solana
+   *
+   * @param {string} senderEthAddress
+   * @return {Promise<boolean>}
+   * @memberof SolanaWeb3Manager
+   */
+  async getIsDiscoveryNodeRegistered (senderEthAddress) {
+    const derivedSenderSolanaAddress = await deriveSolanaSenderFromEthAddress(
+      senderEthAddress,
+      this.rewardManagerProgramId,
+      this.rewardManagerProgramPDA
+    )
+
+    const res = await this.connection.getAccountInfo(derivedSenderSolanaAddress)
+    return !!res
+  }
+
+  async findProgramAddress (programId, pubkey) {
+    return PublicKey.findProgramAddress(
+      [pubkey.toBytes().slice(0, 32)],
+      programId
+    )
+  }
+
+  /**
+   * Finds a 'derived' address by finding a programAddress with
+   * seeds array  as first 32 bytes of base + seeds
+   * Returns [derivedAddress, bumpSeed]
+   * @param {string} programId
+   * @param {string} base
+   * @param {Buffer | Uint8Array} seed
+   * @returns the program address
+   */
+  async findDerivedAddress (programId, base, seed) {
+    return PublicKey.findProgramAddress(
+      [base.toBytes().slice(0, 32), seed],
+      programId
+    )
+  }
+
+  /**
+   * Finds the target PDA with the base audius admin as the initial seed
+   * In conjunction with the secondary seed as the users id in bytes
+   * @param {PublicKey} programId
+   * @param {PublicKey} adminAccount
+   * @param {Buffer | Uint8Array} seed
+   */
+  async findDerivedPair (programId, adminAccount, seed) {
+    programId = SolanaUtils.newPublicKeyNullable(programId)
+    adminAccount = SolanaUtils.newPublicKeyNullable(adminAccount)
+
+    const [baseAuthorityAccount] = await this.findProgramAddress(
+      programId,
+      adminAccount
+    )
+    const derivedAddressInfo = await this.findDerivedAddress(
+      programId,
+      baseAuthorityAccount,
+      seed
+    )
+
+    const derivedAddress = derivedAddressInfo[0]
+    const bumpSeed = derivedAddressInfo[1]
+
+    return { baseAuthorityAccount, derivedAddress, bumpSeed }
+  }
+
+  /**
+   * Fetch account on Solana given the program derived address
+   * @param {PublicKey} pda the program derived address from findDerivedPair()
+   */
+  async fetchAccount (pda) {
+    let account
+    try {
+      account = await this.anchorProgram.account.user.fetch(pda)
+      return account
+    } catch (e) {
+      return null
+    }
+  }
+
+  /**
+   * Given the eth address buffer from the account, convert to hex
+   * @param {Buffer} accountEthAddress
+   * @returns hex string of input bytes
+   */
+  async deriveEthWalletFromAddress (accountEthAddress) {
+    let encodedEthAddress = Buffer.from(accountEthAddress).toString('hex')
+
+    if (!encodedEthAddress.startsWith('0x')) {
+      encodedEthAddress = '0x' + encodedEthAddress
+    }
+
+    return encodedEthAddress
+  }
+}
+
+module.exports = SolanaWeb3Manager

package/src/services/solanaWeb3Manager/padBNToUint8Array.ts

@@ -0,0 +1,7 @@
+import type BN from 'bn.js'
+/**
+ * Converts a BN to a Uint8Array of length 8, in little endian notation.
+ * Useful for when Rust wants a u64 (8 * 8) represented as a byte array.
+ * Ex: https://github.com/AudiusProject/audius-protocol/blob/master/solana-programs/reward-manager/program/src/processor.rs#L389
+ */
+export const padBNToUint8Array = (bn: BN): number[] => bn.toArray('le', 8)