@exodus/solana-lib 1.3.15 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.3.15",
+  "version": "1.4.1",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -29,5 +29,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "3c0551a25d29f31be43d522e742d5754cd7deb5f"
+  "gitHead": "cafda9efb741487bae7db4c3187c8b69d3553151"
 }

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/decode-tx-instructions.js

@@ -1,5 +1,7 @@
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
 import { MARKETS, TokenInstructions } from '@project-serum/serum'
+import * as BufferLayout from '@exodus/buffer-layout'
+
 import {
   Message,
   SystemInstruction,
@@ -18,6 +20,13 @@ type DecodedInstruction = {
   },
 }
 
+const INSTRUCTION_LAYOUT = BufferLayout.union(BufferLayout.u8('instruction'))
+INSTRUCTION_LAYOUT.addVariant(
+  12,
+  BufferLayout.struct([BufferLayout.nu64('amount'), BufferLayout.u8('decimals')]),
+  'transferChecked'
+)
+
 export const INSTRUCTION_TITLE_BY_TYPE = {
   approve: 'Approve',
   cancelOrder: 'Cancel Order',
@@ -43,6 +52,7 @@ export const INSTRUCTION_TITLE_BY_TYPE = {
   systemAuthorizeNonceAccount: 'Authorize Nonce Account',
   systemWithdrawNonceAccount: 'Withdraw Nonce Account',
   transfer: 'Transfer Token',
+  transferChecked: 'Transfer Token Checked',
   unknown: 'Unknown',
 }
 
@@ -56,7 +66,7 @@ class InstructionKeys {
   }
 }
 
-function getTransactionInstructionsFromMessage(message: Message): TransactionInstruction[] {
+export function getTransactionInstructionsFromMessage(message: Message): TransactionInstruction[] {
   const { accountKeys, instructions } = message
   return instructions.map((instruction) => {
     const { accounts, data, programIdIndex } = instruction
@@ -110,10 +120,17 @@ function decodeTokenInstructionData(data: Buffer) {
     }
   }
 
+  // Type TransferChecked
+  if (data.length > 1 && data[0] === 12) {
+    return INSTRUCTION_LAYOUT.decode(data)
+  }
+
   return TokenInstructions.decodeTokenInstructionData(data)
 }
 
-function decodeTokenProgramInstruction(instruction: TransactionInstruction): DecodedInstruction {
+export function decodeTokenProgramInstruction(
+  instruction: TransactionInstruction
+): DecodedInstruction {
   const decodedInstructionData = decodeTokenInstructionData(instruction.data)
 
   if (!decodedInstructionData || Object.keys(decodedInstructionData).length > 1) {
@@ -202,10 +219,18 @@ export function decodeTransactionInstructions(
   transactionMessages: Message[]
 ): DecodedInstruction[] {
   const transactionInstructions = transactionMessages.reduce(
-    (prevInstructions: TransactionInstruction[], message: Message) => [
-      ...prevInstructions,
-      ...getTransactionInstructionsFromMessage(message),
-    ],
+    (prevInstructions: TransactionInstruction[], message: Message) => {
+      let instructions
+      const isTransactionMessage =
+        message.instructions.length > 0 && message.instructions[0].programId !== undefined
+      if (isTransactionMessage) {
+        instructions = message.instructions
+      } else {
+        instructions = getTransactionInstructionsFromMessage(message)
+      }
+
+      return [...prevInstructions, ...instructions]
+    },
     []
   )
   return transactionInstructions.map((instruction) => {

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

@@ -1,16 +1,20 @@
 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 { amount: unitAmount, from, method } = 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
 
@@ -19,39 +23,51 @@ export function signUnsignedTx(
     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 = createDelegateTransaction(args)
+      tx = createDelegateTransaction(txData)
       break
     case 'undelegate':
-      tx = createUndelegateTransaction(args)
+      tx = createUndelegateTransaction(txData)
       break
     case 'withdraw':
-      tx = createWithdrawTransaction(args)
+      tx = createWithdrawTransaction(txData)
+      break
+    case 'closeAccount':
+      tx = createCloseAccountTransaction(txData)
       break
     case 'initializeEscrow': {
-      tx = createMagicEdenInitializeEscrowTransaction(args)
+      tx = createMagicEdenInitializeEscrowTransaction(txData)
       break
     }
     case 'cancelEscrow':
-      tx = createMagicEdenCancelEscrowTransaction(args)
+      tx = createMagicEdenCancelEscrowTransaction(txData)
       break
     case 'exchange':
-      tx = createMagicEdenExchangeTransaction(args)
+      tx = createMagicEdenExchangeTransaction(txData)
       break
     default:
       // SOL and Token tx
-      tx = createTokenTransaction(args)
+      tx = createTokenTransaction(txData)
       break
   }
-
-  // sign plain tx
-  Transaction.sign(tx, privateKey)
-  const rawTx = Transaction.serialize(tx)
-  const txId = Transaction.getTxId(tx)
-
-  return { txId, rawTx }
+  return tx
 }
 
 const createDelegateTransaction = ({ address, amount, pool, recentBlockhash, seed }) =>
@@ -146,6 +162,8 @@ const createTokenTransaction = ({
   recentBlockhash,
   to,
   tokenMintAddress,
+  memo,
+  reference,
 }) =>
   new Transaction({
     amount,
@@ -158,4 +176,14 @@ const createTokenTransaction = ({
     recentBlockhash,
     to,
     tokenMintAddress,
+    memo,
+    reference,
+  })
+
+const createCloseAccountTransaction = ({ account, programId, recentBlockhash, walletPublicKey }) =>
+  Transaction.createCloseAccount({
+    account,
+    programId,
+    recentBlockhash,
+    walletPublicKey,
   })