@audius/sdk 0.0.0

package/src/services/solanaWeb3Manager/transfer.js

@@ -0,0 +1,272 @@
+const {
+  SystemProgram,
+  PublicKey,
+  Secp256k1Program,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  SYSVAR_RENT_PUBKEY,
+  TransactionInstruction
+} = require('@solana/web3.js')
+const borsh = require('borsh')
+const SolanaUtils = require('./utils')
+const secp256k1 = require('secp256k1')
+const { ClaimableProgramError } = require('./errors')
+
+const encoder = new TextEncoder()
+
+const TRANSFER_NONCE_PREFIX = 'N_'
+
+/**
+ * Derives the 'transfer nonce account' - the account which contains the nonce for transfers
+ * and is used to prevent replay attacks
+ *
+ * @param {string} ethAddress
+ * @param {PublicKey} rewardProgramId
+ * @param {PublicKey} rewardManager
+ * @returns {Promise<PublicKey>}
+ */
+const deriveTransferNonceAccount = async ({
+  ethAddress,
+  mintKey,
+  claimableTokenProgramKey
+}) => {
+  const ethAddressArr = SolanaUtils.ethAddressToArray(ethAddress)
+  const seed = Uint8Array.from([
+    ...encoder.encode(TRANSFER_NONCE_PREFIX),
+    ...ethAddressArr
+  ])
+
+  const res = await SolanaUtils.findProgramAddressWithAuthority(
+    claimableTokenProgramKey,
+    mintKey,
+    seed
+  )
+  return res[1]
+}
+
+class NonceAccount {
+  constructor ({
+    version,
+    nonce
+  }) {
+    this.version = version
+    this.nonce = nonce
+  }
+}
+
+const NonceAccountSchema = new Map([
+  [
+    NonceAccount,
+    {
+      kind: 'struct',
+      fields: [
+        ['version', 'u8'],
+        ['nonce', 'u64']
+      ]
+    }
+  ]
+])
+
+/**
+ * Retrieves the nonce account for transfers, if non-existant it returns 0
+ * @param {object} params
+ * @param {object} params.connection Solana web3 connection
+ * @param {string} params.ethAddress Eth Address
+ * @param {PublicKey} params.mintKey Public key of the minted spl token
+ * @param {PublicKey} params.claimableTokenProgramKey Program public key
+ */
+async function getAccountNonce ({
+  connection,
+  ethAddress,
+  mintKey,
+  claimableTokenProgramKey
+}) {
+  let nonce = 0
+  const transferNonceAccount = await deriveTransferNonceAccount({
+    ethAddress,
+    mintKey,
+    claimableTokenProgramKey
+  })
+  const accInfo = await connection.getAccountInfoAndContext(transferNonceAccount)
+  if (accInfo.value) {
+    const nonceAccount = borsh.deserialize(NonceAccountSchema, NonceAccount, accInfo.value.data)
+    nonce = nonceAccount.nonce
+  }
+  return {
+    accountNonce: transferNonceAccount,
+    nonce
+  }
+}
+
+/**
+ * Transfer wAUDIO between wallets on solana
+ */
+class TransferInstructionData {
+  constructor ({
+    targetPubKey,
+    amount,
+    nonce
+  }) {
+    this.target_pubkey = targetPubKey
+    this.amount = amount
+    this.nonce = nonce
+  }
+}
+
+const transferInstructionDataSchema = new Map([
+  [
+    TransferInstructionData,
+    {
+      kind: 'struct',
+      fields: [
+        ['target_pubkey', [32]], // type pubkey of length 32 bytes
+        ['amount', 'u64'],
+        ['nonce', 'u64']
+      ]
+    }
+  ]
+])
+
+/**
+ * transferWAudioBalance transfers wrapped Audio from one generated solana account to another.
+ * For it to work, you have to have the eth private key belonging to the eth public key
+ * that generated the solana account
+ *
+ * @param {BN} amount amount to send
+ * @param {string} senderEthAddress sender's eth address (e.g. you)
+ * @param {string} senderEthPrivateKey sender's eth private key
+ * @param {string} senderSolanaAddress sender's solana address
+ * @param {string} recipientSolanaAddress recipient's solana address
+ * @param {string} claimableTokenPDA
+ * @param {PublicKey} solanaTokenProgramKey spl token key
+ * @param {Connection} connection
+ * @returns
+ */
+async function transferWAudioBalance ({
+  amount,
+  senderEthAddress,
+  senderEthPrivateKey,
+  senderSolanaAddress,
+  recipientSolanaAddress,
+  claimableTokenPDA,
+  solanaTokenProgramKey,
+  feePayerKey,
+  claimableTokenProgramKey,
+  connection,
+  mintKey,
+  transactionHandler
+}) {
+  const senderSolanaPubkey = new PublicKey(senderSolanaAddress)
+  const recipientPubkey = new PublicKey(recipientSolanaAddress)
+
+  const {
+    accountNonce,
+    nonce
+  } = await getAccountNonce({
+    connection,
+    mintKey,
+    ethAddress: senderEthAddress,
+    claimableTokenProgramKey
+  })
+
+  const accounts = [
+    // 0. `[sw]` Fee payer
+    {
+      pubkey: feePayerKey,
+      isSigner: true,
+      isWritable: false
+    },
+    // 1. `[w]` Token acc from which tokens will be send (bank account)
+    {
+      pubkey: senderSolanaPubkey,
+      isSigner: false,
+      isWritable: true
+    },
+    // 2. `[w]` Receiver token acc
+    {
+      pubkey: recipientPubkey,
+      isSigner: false,
+      isWritable: true
+    },
+    // 3. `[w]` Nonce Account
+    {
+      pubkey: accountNonce,
+      isSigner: false,
+      isWritable: true
+    },
+    // 4. `[r]` Banks token account authority
+    {
+      pubkey: claimableTokenPDA,
+      isSigner: false,
+      isWritable: false
+    },
+    // 5. `[r]` Sysvar Rent id
+    {
+      pubkey: SYSVAR_RENT_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    },
+    // 6. `[r]` Sysvar instruction id
+    {
+      pubkey: SYSVAR_INSTRUCTIONS_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    },
+    // 7. `[r]` System program id
+    {
+      pubkey: SystemProgram.programId,
+      isSigner: false,
+      isWritable: false
+    },
+    // 8. `[r]` SPL token account id
+    {
+      pubkey: solanaTokenProgramKey,
+      isSigner: false,
+      isWritable: false
+    }
+  ]
+
+  // eth pubkey is different from the ethAddress - addresses are len 20, pub keys are len 64
+  const ethPrivateKeyArr = Buffer.from(senderEthPrivateKey, 'hex')
+  const ethPubkey = secp256k1.publicKeyCreate(ethPrivateKeyArr, false).slice(1)
+
+  const instructionData = new TransferInstructionData({
+    targetPubKey: recipientPubkey.toBuffer(),
+    amount,
+    nonce
+  })
+
+  const serializedInstructionData = borsh.serialize(
+    transferInstructionDataSchema,
+    instructionData
+  )
+
+  const { signature, recoveryId } = SolanaUtils.signBytes(Buffer.from(serializedInstructionData), senderEthPrivateKey)
+
+  const secpTransactionInstruction = Secp256k1Program.createInstructionWithPublicKey({
+    publicKey: Buffer.from(ethPubkey),
+    message: Buffer.from(serializedInstructionData),
+    signature,
+    recoveryId
+  })
+
+  const ethAddressArr = SolanaUtils.ethAddressToArray(senderEthAddress)
+  const transferDataInstr = Uint8Array.of(
+    1,
+    ...ethAddressArr
+  )
+
+  const instructions = [
+    secpTransactionInstruction,
+    new TransactionInstruction({
+      keys: accounts,
+      programId: claimableTokenProgramKey.toString(),
+      data: Buffer.from(transferDataInstr)
+    })
+  ]
+  return transactionHandler.handleTransaction({ instructions, errorMapping: ClaimableProgramError, feePayerOverride: feePayerKey })
+}
+
+module.exports = {
+  deriveTransferNonceAccount,
+  transferWAudioBalance
+}

package/src/services/solanaWeb3Manager/userBank.js

@@ -0,0 +1,160 @@
+const {
+  PublicKey,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  TransactionInstruction
+} = require('@solana/web3.js')
+const borsh = require('borsh')
+const bs58 = require('bs58')
+const { ethAddressToArray } = require('./utils')
+
+class CreateTokenAccountInstructionData {
+  constructor ({
+    ethAddress
+  }) {
+    this.hashed_eth_pk = ethAddress
+  }
+}
+
+const createTokenAccountInstructionSchema = new Map([
+  [
+    CreateTokenAccountInstructionData,
+    {
+      kind: 'struct',
+      fields: [
+        ['hashed_eth_pk', [20]]
+      ]
+    }
+  ]
+])
+
+/**
+ * Gets the back account address for a user given their ethAddress
+ * @param {string} ethAddress
+ * @param {PublicKey} claimableTokenPDA
+ * @param {PublicKey} solanaTokenProgramKey
+ * @returns
+ */
+const getBankAccountAddress = async (
+  ethAddress,
+  claimableTokenPDA,
+  solanaTokenProgramKey
+) => {
+  const ethAddressArr = ethAddressToArray(ethAddress)
+
+  // We b58 encode our eth address to use as seed later on
+  const b58EthAddress = bs58.encode(ethAddressArr)
+
+  const accountToGenerate = await PublicKey.createWithSeed(
+    /* from pubkey / base */ claimableTokenPDA,
+    /* seed */ b58EthAddress,
+    /* programId / owner */ solanaTokenProgramKey
+  )
+  return accountToGenerate
+}
+
+/**
+ * createUserBank deterministically creates a Solana wAudio token account
+ * from a provided ethAddress
+ * @param {string} ethAddress
+ * @param {PublicKey} claimableTokenPDAKey
+ * @param {PublicKey} feePayerKey
+ * @param {PublicKey} mintKey
+ * @param {PublicKey} solanaTokenProgramKey
+ * @param {PublicKey} claimableTokenProgramKey
+ * @param {*} transactionHandler
+ * @param {string?} recentBlockhash
+ * @returns
+ */
+const createUserBankFrom = async ({
+  ethAddress,
+  claimableTokenPDAKey,
+  feePayerKey,
+  mintKey,
+  solanaTokenProgramKey,
+  claimableTokenProgramKey,
+  transactionHandler,
+  recentBlockhash
+}) => {
+  // Create instruction data
+  const ethAddressArr = ethAddressToArray(ethAddress)
+
+  const instructionData = new CreateTokenAccountInstructionData({
+    ethAddress: ethAddressArr
+  })
+  const serializedInstructionData = borsh.serialize(
+    createTokenAccountInstructionSchema,
+    instructionData
+  )
+
+  // 0th index in the Rust instruction enum
+  const serializedInstructionEnum = Uint8Array.of(
+    0,
+    ...serializedInstructionData
+  )
+
+  // Create the account we aim to generate
+  const accountToGenerate = await getBankAccountAddress(
+    ethAddress,
+    claimableTokenPDAKey,
+    solanaTokenProgramKey
+  )
+
+  const accounts = [
+    // 0. `[sw]` Account to pay for creating token acc
+    {
+      pubkey: feePayerKey,
+      isSigner: true,
+      isWritable: true
+    },
+    // 1. `[r]` Mint account
+    {
+      pubkey: mintKey,
+      isSigner: false,
+      isWritable: false
+    },
+    // 2. `[r]` Base acc used in PDA token acc (need because of create_with_seed instruction)
+    {
+      pubkey: claimableTokenPDAKey,
+      isSigner: false,
+      isWritable: false
+    },
+    // 3. `[w]` PDA token account to create
+    {
+      pubkey: accountToGenerate,
+      isSigner: false,
+      isWritable: true
+    },
+    // `[r]` Rent id
+    {
+      pubkey: SYSVAR_RENT_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    },
+    // 5. `[r]` SPL token account id
+    {
+      pubkey: solanaTokenProgramKey,
+      isSigner: false,
+      isWritable: false
+    },
+    // 6. `[r]` System program id
+    {
+      pubkey: SystemProgram.programId,
+      isSigner: false,
+      isWritable: false
+    }
+  ]
+
+  const instructions = [new TransactionInstruction({
+    keys: accounts,
+    programId: claimableTokenProgramKey.toString(),
+    data: Buffer.from(serializedInstructionEnum)
+  })]
+
+  return transactionHandler.handleTransaction({ instructions, recentBlockhash, feePayerOverride: feePayerKey })
+}
+
+module.exports = {
+  getBankAccountAddress,
+  createUserBankFrom
+}

package/src/services/solanaWeb3Manager/utils.d.ts

@@ -0,0 +1,31 @@
+export default class SolanaUtils {
+  static signBytes: (bytes: any, ethPrivateKey: any) => any
+  static prepareInstructionForRelay: (instruction: any) => any
+  static constructTransferId: (challengeId: any, specifier: any) => string
+
+  static constructAttestation: (
+    recipientEthAddress: any,
+    tokenAmount: any,
+    transferId: any,
+    oracleAddress: any
+  ) => any
+
+  static uiAudioToBNWaudio: (amount: any) => any
+
+  static findProgramAddressFromPubkey: (
+    programId: any,
+    pubkey: any,
+    seed: any
+  ) => Promise<any>
+
+  static findProgramAddressWithAuthority: (
+    programId: any,
+    address: any,
+    seed: any
+  ) => Promise<any>
+
+  static ethAddressToArray: (ethAddress: any) => any
+
+  // Safely create pubkey from nullable val
+  static newPublicKeyNullable: (val: any) => any
+}

package/src/services/solanaWeb3Manager/utils.js

@@ -0,0 +1,163 @@
+const { padBNToUint8Array } = require('./padBNToUint8Array')
+const { PublicKey } = require('@solana/web3.js')
+const BN = require('bn.js')
+const keccak256 = require('keccak256')
+const secp256k1 = require('secp256k1')
+const { WAUDIO_DECMIALS } = require('../../constants')
+class SolanaUtils {
+  /**
+   * Signs arbitrary bytes
+   *
+   * @param {*} bytes
+   * @param {string} ethPrivateKey
+   */
+  static signBytes (bytes, ethPrivateKey) {
+    const msgHash = keccak256(bytes)
+    const ethPrivateKeyArr = Buffer.from(ethPrivateKey, 'hex')
+    const signatureObj = secp256k1.ecdsaSign(
+      Uint8Array.from(msgHash),
+      ethPrivateKeyArr
+    )
+    const signature = Buffer.from(signatureObj.signature)
+    return {
+      signature,
+      recoveryId: signatureObj.recid
+    }
+  }
+
+  /**
+   * Puts an instruction in a serializable form that our relay can understand.
+   *
+   * @param {TransactionInstruction} instruction
+   */
+  static prepareInstructionForRelay (instruction) {
+    return {
+      programId: instruction.programId.toString(),
+      data: instruction.data,
+      keys: instruction.keys.map(({ isSigner, pubkey, isWritable }) => ({
+        pubkey: pubkey.toString(),
+        isSigner,
+        isWritable
+      }))
+    }
+  }
+
+  /**
+   * Constructs a transfer ID
+   * @param {string} challengeId
+   * @param {string} specifier
+   * @returns {string}
+   */
+  static constructTransferId (challengeId, specifier) {
+    return `${challengeId}:${specifier}`
+  }
+
+  /**
+   * Constructs an attestation from inputs.
+   *
+   * @param {string} recipientEthAddress
+   * @param {BN} tokenAmount
+   * @param {string} transferId
+   * @param {string} [oracleAddress] optional oracle address, only used for DN attestations
+   * @returns {Uint8Array}
+   */
+  static constructAttestation (
+    recipientEthAddress,
+    tokenAmount,
+    transferId,
+    oracleAddress
+  ) {
+    const encoder = new TextEncoder()
+    const userBytes = SolanaUtils.ethAddressToArray(recipientEthAddress)
+    const transferIdBytes = encoder.encode(transferId)
+    const amountBytes = padBNToUint8Array(tokenAmount)
+    const items = oracleAddress
+      ? [
+          userBytes,
+          amountBytes,
+          transferIdBytes,
+          SolanaUtils.ethAddressToArray(oracleAddress)
+        ]
+      : [userBytes, amountBytes, transferIdBytes]
+    const sep = encoder.encode('_')
+    const res = items.slice(1).reduce((prev, cur, i) => {
+      return Uint8Array.of(...prev, ...sep, ...cur)
+    }, Uint8Array.from(items[0]))
+    return res
+  }
+
+  /**
+   * Converts "UI" wAudio (i.e. 5) into properly denominated BN representation - (i.e. 5 * 10 ^ 8)
+   *
+   * @param {number} amount
+   * @returns BN
+   * @memberof SolanaWeb3Manager
+   */
+  static uiAudioToBNWaudio (amount) {
+    return new BN(amount * 10 ** WAUDIO_DECMIALS)
+  }
+
+  /**
+   * Derives a program address from a program ID and pubkey as seed.
+   * Optionally takes in seeds.
+   * Returns the new pubkey and bump seeds.
+   *
+   * @param {PublicKey} programId
+   * @param {PublicKey} pubkey
+   * @param {Uint8Array} [seed] optionally include a seed
+   * @returns {Promise<[PublicKey, number]>}
+   */
+  static async findProgramAddressFromPubkey (programId, pubkey, seed) {
+    const seedsArr = [pubkey.toBytes().slice(0, 32)]
+    if (seed) {
+      seedsArr.push(seed)
+    }
+    return PublicKey.findProgramAddress(seedsArr, programId)
+  }
+
+  /**
+   * Finds a program address, using both seeds, pubkey, and the derived authority.
+   * Return [authority, derivedAddress, and bumpSeeds]
+   *
+   * @param {PublicKey} programId
+   * @param {PublicKey} address
+   * @param {Uint8Array} seed
+   * @returns {Promise<[PublicKey, PublicKey, number]>}
+   */
+  static async findProgramAddressWithAuthority (programId, address, seed) {
+    // Finds the authority account by generating a PDA with the address as a seed
+    const [authority] = await SolanaUtils.findProgramAddressFromPubkey(
+      programId,
+      address
+    )
+
+    const [derivedAddress, bumpSeed] =
+      await SolanaUtils.findProgramAddressFromPubkey(
+        programId,
+        authority,
+        seed
+      )
+    return [authority, derivedAddress, bumpSeed]
+  }
+
+  /**
+   * Converts an eth address hex represenatation to an array of Uint8s in big endian notation
+   * @param {string} ethAddress
+   * @returns {Uint8Array}
+   */
+  static ethAddressToArray (ethAddress) {
+    const strippedEthAddress = ethAddress.replace('0x', '')
+    // Need to pad the array to length 20 - otherwise, hex eth keys starting with '0' would
+    // result in truncated arrays, while eth spec is always 20 bytes
+    return Uint8Array.of(
+      ...new BN(strippedEthAddress, 'hex').toArray('be', 20)
+    )
+  }
+
+  // Safely create pubkey from nullable val
+  static newPublicKeyNullable (val) {
+    return val ? new PublicKey(val) : null
+  }
+}
+
+module.exports = SolanaUtils

package/src/services/solanaWeb3Manager/wAudio.js

@@ -0,0 +1,28 @@
+const BN = require('bn.js')
+
+const MIN_WAUDIO_AMOUNT = new BN('10000000000') // 10^10
+
+/**
+ * Converts Wei Audio (BN) to wAudio (BN).
+ * wAudio has only 8 digits of precision vs. 18 in Wei Audio.
+ * The amount must be >= 10^10 and have no remainder when divided by 10^10.
+ * @param {BN} amount Wei Audio amount
+ */
+const wAudioFromWeiAudio = (amount) => {
+  if (amount.lt(MIN_WAUDIO_AMOUNT)) {
+    throw new Error(
+      `${amount.toString()} is below minimum bounds ${MIN_WAUDIO_AMOUNT.toString()}`
+    )
+  }
+  const { div, mod } = amount.divmod(MIN_WAUDIO_AMOUNT)
+  if (!mod.isZero()) {
+    throw new Error(
+      `${amount.toString()} is too precise for conversion to wAudio. Remainder: ${mod.toString()}`
+    )
+  }
+  return div
+}
+
+module.exports = {
+  wAudioFromWeiAudio
+}

package/src/services/solanaWeb3Manager/wAudio.test.js

@@ -0,0 +1,30 @@
+const BN = require('bn.js')
+const assert = require('assert')
+
+const { wAudioFromWeiAudio } = require('./wAudio')
+
+describe('wAudioFromWeiAudio', () => {
+  it('throws if the amount is below the minimum', () => {
+    const weiAudio = new BN('1')
+    assert.throws(() => wAudioFromWeiAudio(weiAudio))
+  })
+  it('throws if the amount too precise', () => {
+    const weiAudio = new BN('100000001')
+    assert.throws(() => wAudioFromWeiAudio(weiAudio))
+  })
+  it('converts if the amount equals the minimum', () => {
+    const weiAudio = new BN('10000000000')
+    const wAudio = wAudioFromWeiAudio(weiAudio)
+    assert.ok(wAudio.eq(new BN('1')))
+  })
+  it('converts if the amount is valid', () => {
+    const weiAudio = new BN('10240000000000') // 1024 * 10^-10 $AUDIO
+    const wAudio = wAudioFromWeiAudio(weiAudio)
+    assert.ok(wAudio.eq(new BN('1024')))
+  })
+  it('converts if the amount is large and valid', () => {
+    const weiAudio = new BN('49000000000000000000') // 49 $AUDIO
+    const wAudio = wAudioFromWeiAudio(weiAudio)
+    assert.ok(wAudio.eq(new BN('4900000000')))
+  })
+})

package/src/services/web3Manager/Web3Config.ts

@@ -0,0 +1,14 @@
+import type Web3 from 'web3'
+import type Wallet from 'ethereumjs-wallet'
+
+export type Web3Config = {
+  useExternalWeb3: boolean
+  internalWeb3Config: {
+    web3ProviderEndpoints: string[]
+    privateKey?: string
+  }
+  externalWeb3Config?: {
+    web3: Web3
+    ownerWallet: Wallet
+  }
+}