@exodus/solana-lib 1.3.6 → 1.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -18,6 +18,10 @@
     "@exodus/assets": "^8.0.53",
     "@exodus/buffer-layout": "^1.2.0-exodus1",
     "@exodus/models": "^8.4.0",
+    "@exodus/solana-spl-token": "0.1.8-exodus.1",
+    "@exodus/web3-solana-utils": "^0.11.0",
+    "@project-serum/serum": "0.13.64",
+    "@solana/web3.js": "1.31.0",
     "bn.js": "^4.11.0",
     "borsh": "^0.7.0",
     "bs58": "^4.0.1",
@@ -25,5 +29,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "90859f94717cf2b928cb93b030ecfba523b8179e"
+  "gitHead": "a0fdfde1511f31373bc94c8cd12c8bee22757876"
 }

package/src/index.js

@@ -1,5 +1,6 @@
 // @flow
 
+export { buildRawTransaction } from '@exodus/web3-solana-utils'
 export * from './constants'
 export * from './encode'
 export * from './keypair'

package/src/tx/decode-tx-instructions.js

@@ -0,0 +1,218 @@
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
+import { MARKETS, TokenInstructions } from '@project-serum/serum'
+import {
+  Message,
+  SystemInstruction,
+  SystemProgram,
+  TransactionInstruction,
+  PublicKey,
+} from '@solana/web3.js'
+import bs58 from 'bs58'
+
+type DecodedInstruction = {
+  type: string,
+  title: string,
+  data: {
+    programId: PublicKey,
+    rawData?: Buffer,
+  },
+}
+
+export const INSTRUCTION_TITLE_BY_TYPE = {
+  approve: 'Approve',
+  cancelOrder: 'Cancel Order',
+  cancelOrderV2: 'Cancel Order',
+  closeAccount: 'Close Account',
+  createAssociatedTokenAccount: 'Create Token Account',
+  createSyncNativeInstruction: 'Create Sync Native Account',
+  initializeAccount: 'Initialize Account',
+  initializeMint: 'Initialize Mint',
+  matchOrders: 'Match Orders',
+  mintTo: 'Mint To',
+  newOrder: 'Place Order',
+  newOrderV3: 'Place Order',
+  settleFunds: 'Settle Funds',
+  signMessage: 'Sign Message',
+  systemAssign: 'Assign',
+  systemAllocate: 'Allocate',
+  systemCreate: 'Create Account',
+  systemCreateWithSeed: 'Create Account With Seed',
+  systemTransfer: 'Transfer SOL',
+  systemInitializeNonceAccount: 'Initialize Nonce Account',
+  systemAdvanceNonceAccount: 'Advance Nonce Account',
+  systemAuthorizeNonceAccount: 'Authorize Nonce Account',
+  systemWithdrawNonceAccount: 'Withdraw Nonce Account',
+  transfer: 'Transfer Token',
+  unknown: 'Unknown',
+}
+
+class InstructionKeys {
+  constructor(keys) {
+    this.keys = keys
+  }
+
+  getAddress(index: number) {
+    return this.keys[index] ? this.keys[index].pubkey : undefined
+  }
+}
+
+function getTransactionInstructionsFromMessage(message: Message): TransactionInstruction[] {
+  const { accountKeys, instructions } = message
+  return instructions.map((instruction) => {
+    const { accounts, data, programIdIndex } = instruction
+    return {
+      programId: accountKeys[programIdIndex],
+      keys: accounts.map((account, index) => ({
+        pubkey: accountKeys[account],
+        isSigner: message.isAccountSigner(index),
+        isWritable: message.isAccountWritable(index),
+      })),
+      data: bs58.decode(data),
+    }
+  })
+}
+
+function decodeSystemInstruction(instruction: TransactionInstruction): DecodedInstruction {
+  const instructionType = SystemInstruction.decodeInstructionType(instruction)
+
+  let data
+  if (instructionType === 'Create') {
+    data = SystemInstruction.decodeCreateAccount(instruction)
+  } else if (instructionType.includes('Nonce')) {
+    data = SystemInstruction[`decodeNonce${instructionType.split('Nonce')[0]}`](instruction)
+  } else {
+    data = SystemInstruction[`decode${instructionType}`](instruction)
+  }
+
+  const type = `system${instructionType}`
+  return {
+    type,
+    title: INSTRUCTION_TITLE_BY_TYPE[type],
+    data,
+  }
+}
+
+function decodeTokenInstructionData(data: Buffer) {
+  if (data.length === 1) {
+    switch (data[0]) {
+      case 1:
+        return {
+          initializeAccount: {},
+        }
+      case 9:
+        return {
+          closeAccount: {},
+        }
+      case 17:
+        return {
+          createSyncNativeInstruction: {},
+        }
+    }
+  }
+
+  return TokenInstructions.decodeTokenInstructionData(data)
+}
+
+function decodeTokenProgramInstruction(instruction: TransactionInstruction): DecodedInstruction {
+  const decodedInstructionData = decodeTokenInstructionData(instruction.data)
+
+  if (!decodedInstructionData || Object.keys(decodedInstructionData).length > 1) {
+    throw new Error('Unexpected Token Program instruction')
+  }
+
+  const keys = new InstructionKeys(instruction.keys)
+
+  const type = Object.keys(decodedInstructionData)[0]
+
+  let data = decodedInstructionData[type]
+
+  if (type === 'initializeAccount') {
+    data = {
+      accountPubkey: keys.getAddress(TokenInstructions.INITIALIZE_ACCOUNT_ACCOUNT_INDEX),
+      mintPubKey: keys.getAddress(TokenInstructions.INITIALIZE_ACCOUNT_MINT_INDEX),
+      ownerPubKey: keys.getAddress(TokenInstructions.INITIALIZE_ACCOUNT_OWNER_INDEX),
+    }
+  } else if (type === 'closeAccount' || type === 'transfer') {
+    data = {
+      ...data,
+      sourcePubkey: keys.getAddress(TokenInstructions.TRANSFER_SOURCE_INDEX),
+      destinationPubKey: keys.getAddress(TokenInstructions.TRANSFER_DESTINATION_INDEX),
+      ownerPubKey: keys.getAddress(TokenInstructions.TRANSFER_OWNER_INDEX),
+    }
+  } else if (type === 'createSyncNativeInstruction') {
+    data = {
+      pubkey: keys.getAddress(0),
+    }
+  }
+
+  return {
+    type,
+    title: INSTRUCTION_TITLE_BY_TYPE[type],
+    data,
+  }
+}
+
+function decodeAssociatedTokenProgramInstruction(
+  instruction: TransactionInstruction
+): DecodedInstruction {
+  const { programId } = instruction
+  const type = 'createAssociatedTokenAccount'
+  return {
+    type,
+    title: INSTRUCTION_TITLE_BY_TYPE[type],
+    data: { programId },
+  }
+}
+
+function decodeMarketProgramInstruction(instruction: TransactionInstruction): DecodedInstruction {
+  throw new Error('Not yet implemented')
+}
+
+function decodeTokenInstruction(instruction: TransactionInstruction): DecodedInstruction {
+  const { programId } = instruction
+
+  try {
+    if (programId.equals(TOKEN_PROGRAM_ID)) {
+      return decodeTokenProgramInstruction(instruction)
+    }
+
+    if (programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      return decodeAssociatedTokenProgramInstruction(instruction)
+    }
+
+    if (MARKETS.some((market) => programId.equals(market.programId))) {
+      return decodeMarketProgramInstruction(instruction)
+    }
+  } catch (err) {
+    console.warn(err)
+  }
+
+  const type = 'unknown'
+  return {
+    type,
+    title: INSTRUCTION_TITLE_BY_TYPE[type],
+    data: {
+      programId,
+      rawData: instruction.data,
+    },
+  }
+}
+
+export function decodeTransactionInstructions(
+  transactionMessages: Message[]
+): DecodedInstruction[] {
+  const transactionInstructions = transactionMessages.reduce(
+    (prevInstructions: TransactionInstruction[], message: Message) => [
+      ...prevInstructions,
+      ...getTransactionInstructionsFromMessage(message),
+    ],
+    []
+  )
+  return transactionInstructions.map((instruction) => {
+    if (instruction.programId.equals(SystemProgram.programId)) {
+      return decodeSystemInstruction(instruction)
+    }
+
+    return decodeTokenInstruction(instruction)
+  })
+}

package/src/tx/index.js

@@ -3,4 +3,5 @@ export * from './parse-unsigned-tx'
 export * from './create-unsigned-tx'
 export * from './create-and-sign-tx'
 export * from './simulate-and-sign-tx'
+export * from './decode-tx-instructions'
 export { default as signMessage } from './sign-message'

package/src/tx/simulate-and-sign-tx.js

@@ -1,28 +1,29 @@
 import { Token, U64 } from '../helpers/spl-token'
 import { PublicKey } from '../vendor/'
 
-/**
- * Maximum over-the-wire size of a Transaction
- *
- * 1280 is IPv6 minimum MTU
- * 40 bytes is the size of the IPv6 header
- * 8 bytes is the size of the fragment header
- */
-const PACKET_DATA_SIZE = 1280 - 40 - 8
-const SIGNATURE_LENGTH = 64
-
 export function computeBalance(futureAccountBalance: string, currentAccountBalance: string) {
   return new U64(futureAccountBalance).sub(new U64(currentAccountBalance))
 }
 
 export function getTransactionSimulationParams(transactionMessage) {
+  let indexToProgramIds = transactionMessage.indexToProgramIds
   const config = {
     encoding: 'base64',
     commitment: 'confirmed',
   }
 
+  if (!indexToProgramIds) {
+    indexToProgramIds = new Map()
+    transactionMessage.instructions.forEach((instruction) =>
+      indexToProgramIds.set(
+        instruction.programIdIndex,
+        transactionMessage.accountKeys[instruction.programIdIndex]
+      )
+    )
+  }
+
   const accountAddresses = transactionMessage.accountKeys
-    .filter((_, index) => !transactionMessage.indexToProgramIds.has(index))
+    .filter((_, index) => !indexToProgramIds.has(index))
     .map((account) => account.toString())
 
   config['accounts'] = {
@@ -86,19 +87,3 @@ export function filterAccountsByOwner(futureAccountsState, accountAddresses, pub
     tokenAccounts,
   }
 }
-
-export function buildRawTransaction(signData, requiredSignatureCount) {
-  const signatureCount = [requiredSignatureCount]
-  const signaturesLength = signatureCount.length + requiredSignatureCount * SIGNATURE_LENGTH
-  const rawTransactionLength = signData.length + signaturesLength
-
-  if (rawTransactionLength > PACKET_DATA_SIZE) {
-    throw Error(`Transaction too large: ${rawTransactionLength} > ${PACKET_DATA_SIZE}`)
-  }
-
-  const rawTransaction = Buffer.alloc(rawTransactionLength)
-  Buffer.from(signatureCount).copy(rawTransaction)
-  signData.copy(rawTransaction, signaturesLength)
-
-  return rawTransaction
-}