@exodus/solana-lib 1.3.14 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.3.14",
+  "version": "1.4.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -13,7 +13,7 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@exodus/asset-lib": "^3.6.0",
+    "@exodus/asset-lib": "^3.6.2",
     "@exodus/assets": "^8.0.68",
     "@exodus/assets-base": "^8.0.139",
     "@exodus/buffer-layout": "^1.2.0-exodus1",
@@ -29,5 +29,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "f8668de32398cd2f583d9bc90ddbd4b5a7425e26"
+  "gitHead": "6ffded97383f994c21ccaebb2703c32d48aa70c5"
 }

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 MEMO_PROGRAM_ID = new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr')
+
 export const MAGIC_EDEN_ESCROW_PROGRAM_ID = new PublicKey(
   'MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8'
 )

package/src/helpers/tokenTransfer.js

@@ -1,4 +1,4 @@
-import { Token } from './spl-token'
+import { Token } from '@exodus/solana-spl-token'
 import { PublicKey, TransactionInstruction, SystemProgram, SYSVAR_RENT_PUBKEY } from '../vendor'
 import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants'
 import { findAssociatedTokenAddress } from '../encode'
@@ -70,3 +70,17 @@ export const createTokenTransferInstruction = (owner, fromTokenAddress, to, amou
 
   return transferIx
 }
+
+export const createCloseAccountInstruction = ({
+  programId = TOKEN_PROGRAM_ID,
+  tokenPublicKey,
+  walletPublicKey,
+}) => {
+  return Token.createCloseAccountInstruction(
+    programId,
+    tokenPublicKey,
+    walletPublicKey,
+    walletPublicKey,
+    []
+  )
+}

package/src/index.js

@@ -6,6 +6,7 @@ export * from './encode'
 export * from './keypair'
 export * from './tx'
 export {
+  TransactionInstruction,
   StakeInstruction,
   PublicKey,
   Transaction as SolanaWeb3Transaction,

package/src/transaction.js

@@ -9,6 +9,7 @@ import { findAssociatedTokenAddress, createStakeAddress } from './encode'
 import {
   createAssociatedTokenAccount,
   createTokenTransferInstruction,
+  createCloseAccountInstruction,
 } from './helpers/tokenTransfer'
 import {
   PublicKey,
@@ -19,9 +20,10 @@ import {
   StakeInstruction,
   Authorized,
   Lockup,
+  TransactionInstruction,
 } from './vendor'
 import { MagicEdenEscrowProgram } from './magiceden/escrow-program'
-import { SEED, STAKE_PROGRAM_ID } from './constants'
+import { MEMO_PROGRAM_ID, SEED, STAKE_PROGRAM_ID } from './constants'
 
 class Tx {
   constructor({
@@ -38,6 +40,8 @@ class Tx {
     fromTokenAddresses, // sender token addresses
     instructions,
     feePayer,
+    memo,
+    reference,
   } = {}) {
     if (!instructions) {
       assert(from, 'from is required')
@@ -69,6 +73,7 @@ class Tx {
       fromTokenAddresses,
       instructions,
       feePayer,
+      reference,
     }
 
     if (tokenMintAddress) {
@@ -80,18 +85,41 @@ class Tx {
       // SOL tx
       this.buildSOLtransaction(this.txObj)
     }
+
+    // If a memo is provided, add it to the transaction before adding the transfer instruction
+    if (memo) {
+      this.transaction.add(
+        new TransactionInstruction({
+          programId: MEMO_PROGRAM_ID,
+          keys: [],
+          data: Buffer.from(memo, 'utf8'),
+        })
+      )
+    }
   }
 
-  buildSOLtransaction({ from, to, amount, recentBlockhash }) {
+  buildSOLtransaction({ from, to, amount, recentBlockhash, feePayer, reference }) {
     const txInstruction = SystemProgram.transfer({
       fromPubkey: new PublicKey(from),
       toPubkey: new PublicKey(to),
       lamports: amount,
     })
 
+    // If reference accounts are provided, add them to the transfer instruction
+    if (reference) {
+      if (!Array.isArray(reference)) {
+        reference = [reference]
+      }
+
+      for (const pubkey of reference) {
+        txInstruction.keys.push({ pubkey, isWritable: false, isSigner: false })
+      }
+    }
+
     this.transaction = new Transaction({
       instructions: [txInstruction],
       recentBlockhash,
+      feePayer: feePayer ? new PublicKey(feePayer) : undefined,
     })
   }
 
@@ -119,9 +147,12 @@ class Tx {
     destinationAddressType,
     isAssociatedTokenAccountActive,
     fromTokenAddresses,
+    feePayer,
+    reference,
   }) {
     this.transaction = new Transaction({
       recentBlockhash,
+      feePayer: feePayer ? new PublicKey(feePayer) : undefined,
     })
     // const isUnknown = destinationAddressType === null
     // if (isUnknown) throw new Error('Destination SOL balance cannot be zero (address not active)') // cannot initialize without knowing the owner
@@ -147,10 +178,26 @@ class Tx {
       }
 
       const dest = isSOLaddress ? findAssociatedTokenAddress(to, tokenMintAddress) : to
-      // add transfer token instruction
-      this.transaction.add(
-        createTokenTransferInstruction(from, tokenAccountAddress, dest, amountToSend)
+      const tokenTransferInstruction = createTokenTransferInstruction(
+        from,
+        tokenAccountAddress,
+        dest,
+        amountToSend
       )
+
+      // If reference accounts are provided, add them to the transfer instruction
+      if (reference) {
+        if (!Array.isArray(reference)) {
+          reference = [reference]
+        }
+
+        for (const pubkey of reference) {
+          tokenTransferInstruction.keys.push({ pubkey, isWritable: false, isSigner: false })
+        }
+      }
+
+      // add transfer token instruction
+      this.transaction.add(tokenTransferInstruction)
     }
 
     assert(amountLeft === 0, `Not enough balance to send ${amount} ${tokenMintAddress}`)
@@ -397,6 +444,15 @@ class Tx {
     }
     return bs58.encode(transaction.signature)
   }
+
+  static createCloseAccount({ programId, tokenPublicKey, walletPublicKey, recentBlockhash }) {
+    const tx = new Transaction()
+    tx.add(createCloseAccountInstruction({ programId, tokenPublicKey, walletPublicKey }))
+    tx.feePayer = walletPublicKey
+    tx.recentBlockhash = recentBlockhash
+
+    return tx
+  }
 }
 
 export default Tx

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

@@ -1,130 +1,189 @@
+import { merge } from 'lodash'
 import assets from '@exodus/assets'
 import type { UnsignedTransaction, SignedTransaction } from '@exodus/models/lib/types'
+
 import { Transaction } from '../'
 
 export function signUnsignedTx(
   unsignedTx: UnsignedTransaction,
   privateKey: Buffer
 ): SignedTransaction {
-  const {
-    from,
-    to,
-    amount: unitAmount,
-    recentBlockhash,
-    // tokens related
-    tokenMintAddress,
-    destinationAddressType,
-    isAssociatedTokenAccountActive,
-    fromTokenAddresses,
-    // staking related
-    stakeAddresses,
-    method,
-    seed,
-    pool,
-    // MagicEden escrow/related:
-    initializerAddress,
-    initializerDepositTokenAddress,
-    takerAmount,
-    escrowAddress,
-    escrowBump,
-    pdaAddress,
-    takerAddress,
-    expectedTakerAmount,
-    expectedMintAddress,
-    metadataAddress,
-    creators,
-    // Wallet Connect
-    instructions,
-    feePayer,
-  } = unsignedTx.txData
+  const { amount: unitAmount, from, method, transaction } = unsignedTx.txData
 
-  const asset = assets.solana
+  if (transaction) {
+    return _signTx({ tx: transaction, privateKey })
+  }
 
+  const asset = assets.solana
   const address = from
   const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
 
+  const args = merge(unsignedTx.txData, {
+    asset,
+    address,
+    amount,
+  })
+
+  const tx = createTx({ txData: args, method })
+  return _signTx({ tx, privateKey })
+}
+
+// Signs plain tx.
+const _signTx = ({ tx, privateKey }) => {
+  Transaction.sign(tx, privateKey)
+  const rawTx = Transaction.serialize(tx)
+  const txId = Transaction.getTxId(tx)
+
+  return { txId, rawTx }
+}
+
+const createTx = ({ txData, method }) => {
   let tx
   switch (method) {
     case 'delegate':
-      tx = Transaction.createStakeAccountTransaction({
-        address,
-        amount,
-        recentBlockhash,
-        seed,
-        pool,
-      })
+      tx = createDelegateTransaction(txData)
       break
     case 'undelegate':
-      tx = Transaction.undelegate({
-        address,
-        stakeAddresses,
-        recentBlockhash,
-      })
+      tx = createUndelegateTransaction(txData)
       break
     case 'withdraw':
-      tx = Transaction.withdraw({
-        address,
-        stakeAddresses,
-        amount,
-        recentBlockhash,
-      })
+      tx = createWithdrawTransaction(txData)
+      break
+    case 'closeAccount':
+      tx = createCloseAccountTransaction(txData)
       break
     case 'initializeEscrow': {
-      tx = Transaction.magicEdenInitializeEscrow({
-        initializerAddress,
-        initializerDepositTokenAddress,
-        escrowBump,
-        escrowAddress,
-        takerAmount,
-        recentBlockhash,
-      })
-
+      tx = createMagicEdenInitializeEscrowTransaction(txData)
       break
     }
     case 'cancelEscrow':
-      tx = Transaction.magicEdenCancelEscrow({
-        initializerAddress,
-        initializerDepositTokenAddress,
-        escrowAddress,
-        pdaAddress,
-        recentBlockhash,
-      })
+      tx = createMagicEdenCancelEscrowTransaction(txData)
       break
     case 'exchange':
-      tx = Transaction.magicEdenExchange({
-        expectedTakerAmount,
-        expectedMintAddress,
-        takerAddress,
-        initializerAddress,
-        initializerDepositTokenAddress,
-        escrowAddress,
-        pdaAddress,
-        metadataAddress,
-        creators,
-        recentBlockhash,
-      })
+      tx = createMagicEdenExchangeTransaction(txData)
       break
     default:
       // SOL and Token tx
-      tx = new Transaction({
-        from,
-        to,
-        amount,
-        recentBlockhash,
-        tokenMintAddress,
-        destinationAddressType,
-        isAssociatedTokenAccountActive,
-        fromTokenAddresses,
-        instructions,
-        feePayer,
-      })
+      tx = createTokenTransaction(txData)
       break
   }
+  return tx
+}
 
-  // sign plain tx
-  Transaction.sign(tx, privateKey)
-  const rawTx = Transaction.serialize(tx)
-  const txId = Transaction.getTxId(tx)
+const createDelegateTransaction = ({ address, amount, pool, recentBlockhash, seed }) =>
+  Transaction.createStakeAccountTransaction({
+    address,
+    amount,
+    recentBlockhash,
+    seed,
+    pool,
+  })
 
-  return { txId, rawTx }
-}
+const createUndelegateTransaction = ({ address, recentBlockhash, stakeAddresses }) =>
+  Transaction.undelegate({
+    address,
+    recentBlockhash,
+    stakeAddresses,
+  })
+
+const createWithdrawTransaction = ({ address, amount, recentBlockhash, stakeAddresses }) =>
+  Transaction.withdraw({
+    address,
+    amount,
+    recentBlockhash,
+    stakeAddresses,
+  })
+
+const createMagicEdenInitializeEscrowTransaction = ({
+  escrowAddress,
+  escrowBump,
+  initializerDepositTokenAddress,
+  recentBlockhash,
+  takerAmount,
+  initializerAddress,
+}) =>
+  Transaction.magicEdenInitializeEscrow({
+    escrowAddress,
+    escrowBump,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    recentBlockhash,
+    takerAmount,
+  })
+
+const createMagicEdenCancelEscrowTransaction = ({
+  escrowAddress,
+  initializerAddress,
+  initializerDepositTokenAddress,
+  pdaAddress,
+  recentBlockhash,
+}) =>
+  Transaction.magicEdenCancelEscrow({
+    escrowAddress,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    pdaAddress,
+    recentBlockhash,
+  })
+
+const createMagicEdenExchangeTransaction = ({
+  creators,
+  escrowAddress,
+  expectedMintAddress,
+  expectedTakerAmount,
+  initializerAddress,
+  initializerDepositTokenAddress,
+  metadataAddress,
+  pdaAddress,
+  recentBlockhash,
+  takerAddress,
+}) =>
+  Transaction.magicEdenExchange({
+    creators,
+    escrowAddress,
+    expectedMintAddress,
+    expectedTakerAmount,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    metadataAddress,
+    pdaAddress,
+    recentBlockhash,
+    takerAddress,
+  })
+
+const createTokenTransaction = ({
+  amount,
+  destinationAddressType,
+  feePayer,
+  from,
+  fromTokenAddresses,
+  instructions,
+  isAssociatedTokenAccountActive,
+  recentBlockhash,
+  to,
+  tokenMintAddress,
+  memo,
+  reference,
+}) =>
+  new Transaction({
+    amount,
+    destinationAddressType,
+    feePayer,
+    from,
+    fromTokenAddresses,
+    instructions,
+    isAssociatedTokenAccountActive,
+    recentBlockhash,
+    to,
+    tokenMintAddress,
+    memo,
+    reference,
+  })
+
+const createCloseAccountTransaction = ({ account, programId, recentBlockhash, walletPublicKey }) =>
+  Transaction.createCloseAccount({
+    account,
+    programId,
+    recentBlockhash,
+    walletPublicKey,
+  })