@exodus/solana-lib 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -33,8 +33,11 @@
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
-    "@exodus/solana-meta": "^1.0.7",
-    "@solana/web3.js": "^1.90.0"
+    "@exodus/key-identifier": "1.0.0",
+    "@exodus/keychain": "^6.2.0",
+    "@exodus/solana-meta": "^1.1.0",
+    "@solana/web3.js": "^1.90.0",
+    "bip39": "^2.6.0"
   },
-  "gitHead": "1f9f097ac7c8d4c657ef1a4786af7781bcfd7660"
+  "gitHead": "85fd61e1f2f77aff4c32b5684eb5f4845f06794a"
 }

package/src/constants.js

@@ -9,6 +9,8 @@ export const STAKE_PROGRAM_ID = StakeProgram.programId
 
 export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')
 
+export const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb')
+
 export const MEMO_PROGRAM_ID = new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr')
 
 export const MAGIC_EDEN_ESCROW_PROGRAM_ID = new PublicKey(

package/src/encode.js

@@ -47,11 +47,17 @@ export function getPrivateKeyFromSecretKey(secretKey) {
 }
 
 // doc: https://spl.solana.com/associated-token-account (HACK: refactored to sync)
-export function findAssociatedTokenAddress(walletAddress, tokenMintAddress) {
+export function findAssociatedTokenAddress(
+  walletAddress,
+  tokenMintAddress,
+  programId = TOKEN_PROGRAM_ID.toBase58() // or TOKEN_2022_PROGRAM_ID
+) {
   walletAddress = new PublicKey(walletAddress)
   tokenMintAddress = new PublicKey(tokenMintAddress)
+  programId = programId instanceof PublicKey ? programId : new PublicKey(programId)
+
   return PublicKey.findProgramAddress(
-    [walletAddress.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), tokenMintAddress.toBuffer()],
+    [walletAddress.toBuffer(), programId.toBuffer(), tokenMintAddress.toBuffer()],
     SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID
   )[0].toBase58() // returns encoded PublicKey
 }

package/src/helpers/metaplex-transfer.js

@@ -52,6 +52,7 @@ export const prepareMetaplexTransferTx = ({
   amount,
   authorityType,
   programId = MPL_TOKEN_METADATA_PROGRAM_ID,
+  tokenProgram,
 }) => {
   const transaction = new Transaction()
   const data = encodeData({ amount, authorityType })
@@ -122,7 +123,7 @@ export const prepareMetaplexTransferTx = ({
       isSigner: false,
     },
     {
-      pubkey: TOKEN_PROGRAM_ID,
+      pubkey: tokenProgram,
       isWritable: false,
       isSigner: false,
     },
@@ -161,10 +162,11 @@ export function createMetaplexTransferTransaction({
   tokenStandard,
   recentBlockhash,
   amount = 1,
+  tokenProgram = TOKEN_PROGRAM_ID,
 }) {
-  const fromAccount = findAssociatedTokenAddress(from, tokenMintAddress)
+  const fromAccount = findAssociatedTokenAddress(from, tokenMintAddress, tokenProgram.toBase58())
 
-  const toAccount = findAssociatedTokenAddress(to, tokenMintAddress)
+  const toAccount = findAssociatedTokenAddress(to, tokenMintAddress, tokenProgram.toBase58())
 
   const metadata = getMetadataAccount(tokenMintAddress)
   const edition = getMasterEditionPDA(tokenMintAddress)
@@ -186,6 +188,7 @@ export function createMetaplexTransferTransaction({
     payer: new PublicKey(from),
     authorizationRulesProgram: TOKEN_AUTH_RULES_ID,
     amount,
+    tokenProgram,
   })
 
   transaction.recentBlockhash = recentBlockhash

package/src/helpers/spl-token-2022.js

@@ -0,0 +1,204 @@
+import { PublicKey, TransactionInstruction } from '../vendor'
+import { struct, u8 } from '@exodus/buffer-layout'
+import * as BufferLayout from '@exodus/buffer-layout'
+import { U64 } from './spl-token'
+
+/**
+ * Layout for a 64bit unsigned value
+ */
+const u64 = (property = 'uint64') => {
+  return BufferLayout.blob(8, property)
+}
+
+// Extracted from https://github.com/solana-labs/solana-program-library/blob/token-js-v0.4.1/token/js/src/extensions/transferFee/instructions.ts
+
+export const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb')
+
+export const TransferFeeInstruction = {
+  InitializeTransferFeeConfig: 0,
+  TransferCheckedWithFee: 1,
+  WithdrawWithheldTokensFromMint: 2,
+  WithdrawWithheldTokensFromAccounts: 3,
+  HarvestWithheldTokensToMint: 4,
+  SetTransferFee: 5,
+}
+
+// https://github.com/solana-labs/solana-program-library/blob/token-js-v0.4.1/token/js/src/instructions/types.ts
+export const TokenInstruction = {
+  TransferFeeExtension: 26,
+}
+
+/*
+// TransferCheckedWithFee
+export interface TransferCheckedWithFeeInstructionData {
+    instruction: TokenInstruction.TransferFeeExtension;
+    transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee;
+    amount: bigint;
+    decimals: number;
+    fee: bigint;
+}
+*/
+
+export const transferCheckedWithFeeInstructionData = struct([
+  u8('instruction'),
+  u8('transferFeeInstruction'),
+  u64('amount'),
+  u8('decimals'),
+  u64('fee'),
+])
+
+/**
+ * Construct an TransferCheckedWithFee instruction
+ *
+ * @param source          The source account
+ * @param mint            The token mint
+ * @param destination     The destination account
+ * @param authority       The source account's owner/delegate
+ * @param signers         The signer account(s)
+ * @param amount          The amount of tokens to transfer
+ * @param decimals        The expected number of base 10 digits to the right of the decimal place
+ * @param fee             The expected fee assesed on this transfer, calculated off-chain based on the transferFeeBasisPoints and maximumFee of the mint.
+ * @param programId       SPL Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+export function createTransferCheckedWithFeeInstruction(
+  source, // PublicKey
+  mint, // PublicKey
+  destination, // PublicKey
+  authority, // PublicKey
+  amount, // bigint
+  decimals, // number
+  fee, // bigint
+  multiSigners = [], // (Signer | PublicKey)[]
+  programId = TOKEN_2022_PROGRAM_ID
+) {
+  source = new PublicKey(source)
+  mint = new PublicKey(mint)
+  destination = new PublicKey(destination)
+  authority = new PublicKey(authority)
+
+  if (programId !== TOKEN_2022_PROGRAM_ID) {
+    throw new Error('TokenUnsupportedInstructionError')
+  }
+
+  const data = Buffer.alloc(transferCheckedWithFeeInstructionData.span)
+  transferCheckedWithFeeInstructionData.encode(
+    {
+      instruction: TokenInstruction.TransferFeeExtension,
+      transferFeeInstruction: TransferFeeInstruction.TransferCheckedWithFee,
+      amount: new U64(amount).toBuffer(),
+      decimals,
+      fee: new U64(fee).toBuffer(),
+    },
+    data
+  )
+  const keys = addSigners(
+    [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: destination, isSigner: false, isWritable: true },
+    ],
+    authority,
+    multiSigners
+  )
+  return new TransactionInstruction({ keys, programId, data })
+}
+
+/**
+ * Decode a TransferCheckedWithFee instruction and validate it
+ *
+ * @param instruction Transaction instruction to decode
+ * @param programId   SPL Token program account
+ *
+ * @return Decoded, valid instruction
+ */
+export function decodeTransferCheckedWithFeeInstruction(
+  instruction, // TransactionInstruction
+  programId // PublicKey
+) {
+  if (!instruction.programId.equals(programId))
+    throw new Error('TokenInvalidInstructionProgramError')
+  if (instruction.data.length !== transferCheckedWithFeeInstructionData.span)
+    throw new Error('TokenInvalidInstructionDataError')
+
+  const {
+    keys: { source, mint, destination, authority, signers },
+    data,
+  } = decodeTransferCheckedWithFeeInstructionUnchecked(instruction)
+  if (
+    data.instruction !== TokenInstruction.TransferFeeExtension ||
+    data.transferFeeInstruction !== TransferFeeInstruction.TransferCheckedWithFee
+  )
+    throw new Error('TokenInvalidInstructionTypeError')
+  if (!mint) throw new Error('TokenInvalidInstructionKeysError')
+
+  return {
+    programId,
+    keys: {
+      source,
+      mint,
+      destination,
+      authority,
+      signers: signers || null,
+    },
+    data,
+  }
+}
+
+/**
+ * Decode a TransferCheckedWithFees instruction without validating it
+ *
+ * @param instruction Transaction instruction to decode
+ *
+ * @return Decoded, non-validated instruction
+ */
+export function decodeTransferCheckedWithFeeInstructionUnchecked({
+  programId,
+  keys: [source, mint, destination, authority, ...signers],
+  data,
+}) {
+  const { instruction, transferFeeInstruction, amount, decimals, fee } =
+    transferCheckedWithFeeInstructionData.decode(data)
+
+  return {
+    programId,
+    keys: {
+      source,
+      mint,
+      destination,
+      authority,
+      signers,
+    },
+    data: {
+      instruction,
+      transferFeeInstruction,
+      amount,
+      decimals,
+      fee,
+    },
+  }
+}
+
+// utils
+
+export function addSigners(
+  keys, // AccountMeta[],
+  ownerOrAuthority, // PublicKey,
+  multiSigners // (Signer | PublicKey)[]
+) {
+  if (multiSigners.length > 0) {
+    keys.push({ pubkey: ownerOrAuthority, isSigner: false, isWritable: false })
+    for (const signer of multiSigners) {
+      keys.push({
+        pubkey: signer instanceof PublicKey ? signer : signer.publicKey,
+        isSigner: true,
+        isWritable: false,
+      })
+    }
+  } else {
+    keys.push({ pubkey: ownerOrAuthority, isSigner: true, isWritable: false })
+  }
+
+  return keys
+}

package/src/helpers/tokenTransfer.js

@@ -7,21 +7,24 @@ import { findAssociatedTokenAddress } from '../encode'
 export const createAssociatedTokenAccount = (
   senderAddress,
   tokenMintAddress,
-  ownerAddress // destination SOL address
+  ownerAddress, // destination SOL address
+  tokenProgram
 ) => {
   const associatedTokenAccountPublicKey = new PublicKey(
-    findAssociatedTokenAddress(ownerAddress, tokenMintAddress)
+    findAssociatedTokenAddress(ownerAddress, tokenMintAddress, tokenProgram)
   )
 
   const feePayerPublicKey = new PublicKey(senderAddress)
   const ownerPublicKey = new PublicKey(ownerAddress)
   const tokenMintPublicKey = new PublicKey(tokenMintAddress)
+  const tokenProgramPublicKey = new PublicKey(tokenProgram)
 
   return createIx(
     feePayerPublicKey, // feePayer
     associatedTokenAccountPublicKey,
     ownerPublicKey,
-    tokenMintPublicKey
+    tokenMintPublicKey,
+    tokenProgramPublicKey
   ) // returns the instruction
 }
 
@@ -29,7 +32,8 @@ function createIx(
   funderPubkey,
   associatedTokenAccountPublicKey,
   ownerPublicKey,
-  tokenMintPublicKey
+  tokenMintPublicKey,
+  tokenProgramPublicKey
 ) {
   return new TransactionInstruction({
     programId: SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID,
@@ -44,7 +48,7 @@ function createIx(
       { pubkey: ownerPublicKey, isSigner: false, isWritable: false },
       { pubkey: tokenMintPublicKey, isSigner: false, isWritable: false },
       { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramPublicKey || TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
       { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
     ],
   })

package/src/transaction.js

@@ -10,6 +10,7 @@ import {
   createTokenTransferInstruction,
   createCloseAccountInstruction,
 } from './helpers/tokenTransfer'
+import { createTransferCheckedWithFeeInstruction } from './helpers/spl-token-2022'
 import {
   PublicKey,
   Account,
@@ -22,7 +23,7 @@ import {
   TransactionInstruction,
 } from './vendor'
 import { MagicEdenEscrowProgram } from './magiceden/escrow-program'
-import { MEMO_PROGRAM_ID, SEED, STAKE_PROGRAM_ID } from './constants'
+import { MEMO_PROGRAM_ID, SEED, STAKE_PROGRAM_ID, TOKEN_2022_PROGRAM_ID } from './constants'
 
 class Tx {
   constructor({
@@ -60,6 +61,7 @@ class Tx {
         'isAssociatedTokenAccountActive is required when sending tokens'
       ) // needed to create the recipient account
       assert(Array.isArray(fromTokenAddresses), 'fromTokenAddresses Array is required')
+      assert(fromTokenAddresses.length > 0, 'fromTokenAddresses is empty')
     }
 
     this.txObj = {
@@ -157,13 +159,23 @@ class Tx {
     // const isUnknown = destinationAddressType === null
     // if (isUnknown) throw new Error('Destination SOL balance cannot be zero (address not active)') // cannot initialize without knowing the owner
     const isSOLaddress = ['solana', null].includes(destinationAddressType)
+    const rawTokenProgram = fromTokenAddresses[0]?.tokenProgram
+    if (!rawTokenProgram) throw new Error('Cannot detect token program')
+    const tokenProgram = new PublicKey(rawTokenProgram).toBase58()
     // crete account instruction
     if (isSOLaddress && !isAssociatedTokenAccountActive)
-      this.transaction.add(createAssociatedTokenAccount(from, tokenMintAddress, to))
+      this.transaction.add(createAssociatedTokenAccount(from, tokenMintAddress, to, tokenProgram))
 
     let amountLeft = amount
     let amountToSend
-    for (let { mintAddress, tokenAccountAddress, balance } of fromTokenAddresses) {
+    for (let {
+      mintAddress,
+      tokenAccountAddress,
+      balance,
+      decimals,
+      feeBasisPoints,
+      maximumFee,
+    } of fromTokenAddresses) {
       // need to add more of this instruction until we reach the desired balance (amount) to send
       assert(mintAddress === tokenMintAddress, `Got unexpected mintAddress ${mintAddress}`)
       if (amountLeft === 0) break
@@ -177,13 +189,32 @@ class Tx {
         amountLeft -= amountToSend
       }
 
-      const dest = isSOLaddress ? findAssociatedTokenAddress(to, tokenMintAddress) : to
-      const tokenTransferInstruction = createTokenTransferInstruction(
-        from,
-        tokenAccountAddress,
-        dest,
-        amountToSend
-      )
+      const dest = isSOLaddress
+        ? findAssociatedTokenAddress(to, tokenMintAddress, tokenProgram)
+        : to
+      let tokenTransferInstruction
+      if (tokenProgram === TOKEN_2022_PROGRAM_ID.toBase58()) {
+        // token transfer fee
+        const fee = Math.ceil((amountToSend * feeBasisPoints) / 10_000)
+        const feeCharged = fee > maximumFee ? maximumFee : fee
+
+        tokenTransferInstruction = createTransferCheckedWithFeeInstruction(
+          tokenAccountAddress,
+          tokenMintAddress,
+          dest,
+          from,
+          amountToSend,
+          decimals, // token decimals
+          feeCharged // token fee (not SOL fee)
+        )
+      } else {
+        tokenTransferInstruction = createTokenTransferInstruction(
+          from,
+          tokenAccountAddress,
+          dest,
+          amountToSend
+        )
+      }
 
       // If reference accounts are provided, add them to the transfer instruction
       if (reference) {

package/src/tx/async-account.js

@@ -0,0 +1,38 @@
+import { PublicKey } from '../vendor/publickey'
+
+export class AsyncSignerAccount {
+  #publicKey
+  #asyncSigner
+
+  /**
+   * Create a new AsyncSignerAccount object
+   *
+   * @param asyncSigner A signer object: `{ sign, getPublicKey }`
+   */
+  constructor(asyncSigner) {
+    if (!asyncSigner) throw new Error('please provide a signer object to async signer')
+
+    this.#asyncSigner = asyncSigner
+    this.updatePublicKey().catch((err) =>
+      console.error('error getting public key from signer', err)
+    )
+  }
+
+  get publicKey() {
+    if (!this.#publicKey) throw new Error('public key not yet available in async signer')
+    return this.#publicKey
+  }
+
+  get secretKey() {
+    throw new Error('secret key not available from async signer')
+  }
+
+  sign = async (signData) => this.#asyncSigner.sign({ data: signData })
+
+  updatePublicKey = async () => {
+    if (!this.#publicKey) {
+      const publicKey = await this.#asyncSigner.getPublicKey()
+      this.#publicKey = new PublicKey(publicKey)
+    }
+  }
+}

package/src/tx/create-unsigned-tx.js

@@ -12,6 +12,7 @@ export function createUnsignedTx({
   isAssociatedTokenAccountActive, // true when recipient balance !== 0
   fromTokenAddresses, // sender token addresses
   tokenStandard,
+  tokenProgram,
   // Program interactions:
   method,
   // Staking related:
@@ -48,6 +49,7 @@ export function createUnsignedTx({
       isAssociatedTokenAccountActive,
       fromTokenAddresses,
       tokenStandard,
+      tokenProgram,
       // Staking related:
       method,
       stakeAddresses,

package/src/tx/sign-unsigned-tx.js

@@ -3,44 +3,63 @@ import assert from 'minimalistic-assert'
 import { prepareForSigning } from './prepare-for-signing'
 import { getKeyPairFromPrivateKey } from '../keypair'
 import { Account } from '../vendor'
+import { AsyncSignerAccount } from './async-account'
 import { extractTransaction, isVersionedTransaction } from './common'
 
+/**
+ *
+ * @param {*} unsignedTx
+ * @param {Object} asyncSigner object: `{ sign: async (buffer) => Promise<>, getPublicKey: async () => Promise<any>}`
+ * @returns
+ */
+export async function signUnsignedTxWithSigner(unsignedTx, signer) {
+  assert(signer, 'Please provide a signer')
+
+  const tx = prepareForSigning(unsignedTx)
+
+  const account = new AsyncSignerAccount(signer)
+  await account.updatePublicKey()
+  await _signTx({ tx, account })
+
+  return extractTransaction({ tx })
+}
+
 export function signUnsignedTx(unsignedTx, privateKey) {
   assert(privateKey, 'Please provide a secretKey')
 
   const tx = prepareForSigning(unsignedTx)
 
-  _signTx({ tx, privateKey })
+  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
+  const account = new Account(secretKey)
+  _signTx({ tx, account })
 
   return extractTransaction({ tx })
 }
 
 // Signs plain tx.
-const _signTx = ({ tx, privateKey }) => {
-  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-  const account = new Account(secretKey)
+const _signTx = ({ tx, account }) => {
   if (isVersionedTransaction(tx)) {
     // VersionedTransaction
-    tx.sign([account])
-  } else {
-    // Legacy Transactions
-
-    // Some transactions that we construct internally are technically not complete.
-    // They don't contain the empty signature slot for the public key.
-    const foundEmptySignatureSlot = tx.signatures.find(({ publicKey }) =>
-      publicKey.equals(account.publicKey)
-    )
-    if (!foundEmptySignatureSlot) {
-      // We could use `setSigners` but maybe this is more robust?
-      tx.signatures.push({
-        publicKey: account.publicKey,
-        signature: null,
-      })
-    }
-
-    // We need to use `partialSign()` here because legacy `sign()` will
-    // delete all existing signatures which isn't great if we're
-    // signing a transaction that already has signatures.
-    tx.partialSign(account)
+    return tx.sign([account])
   }
+
+  // Legacy Transactions
+
+  // Some transactions that we construct internally are technically not complete.
+  // They don't contain the empty signature slot for the public key.
+  const foundEmptySignatureSlot = tx.signatures.find(({ publicKey }) =>
+    publicKey.equals(account.publicKey)
+  )
+  if (!foundEmptySignatureSlot) {
+    // We could use `setSigners` but maybe this is more robust?
+    tx.signatures.push({
+      publicKey: account.publicKey,
+      signature: null,
+    })
+  }
+
+  // We need to use `partialSign()` here because legacy `sign()` will
+  // delete all existing signatures which isn't great if we're
+  // signing a transaction that already has signatures.
+  return tx.partialSign(account)
 }

package/src/vendor/transaction.js

@@ -21,6 +21,8 @@ import * as shortvec from './utils/shortvec-encoding'
 const DEFAULT_SIGNATURE = Buffer.alloc(64).fill(0)
 const SIGNATURE_LENGTH = 64
 
+const isAsyncAccount = (signer) => signer.sign && signer.publicKey && signer.updatePublicKey
+
 /**
  * Account metadata used to define instructions
  *
@@ -412,7 +414,7 @@ export class Transaction {
         publicKey: signer.publicKey,
       }))
 
-    this.partialSign(...signers)
+    return this.partialSign(...signers)
   }
 
   /**
@@ -434,6 +436,21 @@ export class Transaction {
     })
 
     const signData = message.serialize()
+
+    const isAsyncSign = signers.some(isAsyncAccount)
+    if (isAsyncSign) {
+      return Promise.all(
+        signers.map(async (signer) => ({
+          signature: isAsyncAccount(signer)
+            ? await signer.sign(signData) // Promise
+            : nacl.sign.detached(signData, signer.secretKey),
+          publicKey: signer.publicKey,
+        }))
+      ).then((signatures) =>
+        signatures.forEach(({ publicKey, signature }) => this.addSignature(publicKey, signature))
+      )
+    }
+
     signers.forEach((signer) => {
       const signature = nacl.sign.detached(signData, signer.secretKey)
       this.addSignature(signer.publicKey, signature)