@exodus/solana-lib 3.4.2 → 3.5.1

package/src/tx/prepare-for-signing.js

@@ -1,10 +1,10 @@
 import { isNumberUnit } from '@exodus/currency'
-import BN from 'bn.js'
 import { VersionedTransaction } from '@exodus/solana-web3.js'
+import BN from 'bn.js'
 
-import { ComputeBudgetProgram, PublicKey } from '../vendor'
-import Transaction from '../transaction'
 import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
+import Transaction from '../transaction'
+import { ComputeBudgetProgram, PublicKey } from '../vendor'
 
 const addPriorityFeeToTransaction = ({ transaction, priorityFee }) => {
   const priorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
@@ -20,10 +20,14 @@ const addComputeBudgetToTransaction = ({ transaction, computeUnits }) => {
   transaction.add(computeBudgetInstruction)
 }
 
+const deserializeTransactionBytes = (wireTransactionBuffer) => {
+  return VersionedTransaction.deserialize(Uint8Array.from(wireTransactionBuffer))
+}
+
 /**
  * Prepares the transaction to be signed (exodus & ledger).
  * @param {UnsignedTx} unsignedTx
- * @returns a Solana Web3.js Transaction object
+ * @returns a Solana Web3.js VersionedTransaction object (supports both Legacy & Versioned transactions)
  */
 export function prepareForSigning(unsignedTx) {
   const {
@@ -37,7 +41,7 @@ export function prepareForSigning(unsignedTx) {
 
   // Recreate a Web3.js Transaction instance if the buffer provided.
   if (transactionBuffer) {
-    return VersionedTransaction.deserialize(transactionBuffer)
+    return deserializeTransactionBytes(transactionBuffer)
   }
 
   if (!transaction) {
@@ -54,31 +58,19 @@ export function prepareForSigning(unsignedTx) {
 
     const txData = { ...unsignedTx.txData, address, amount, fee }
 
-    const transaction = createTx({ txData, method })
-
-    if (txData.priorityFee) {
-      addPriorityFeeToTransaction({
-        transaction,
-        priorityFee: txData.priorityFee,
-      })
-    }
-
-    if (txData.computeUnits) {
-      addComputeBudgetToTransaction({ transaction, computeUnits: txData.computeUnits })
-    }
-
-    if (!transaction.feePayer) {
-      transaction.feePayer = new PublicKey(from)
-    }
-
-    return transaction
+    const legacyTransaction = createTx({ txData, method, from })
+    return VersionedTransaction.deserialize(
+      legacyTransaction.serialize({ requireAllSignatures: false, verifySignatures: false })
+    )
   }
 
   // unsignedTx contained a transaction in web3.js format
-  return transaction
+  return VersionedTransaction.deserialize(
+    transaction.serialize({ requireAllSignatures: false, verifySignatures: false })
+  )
 }
 
-const createTx = ({ txData, method }) => {
+const createTx = ({ txData, method, from }) => {
   let tx
   switch (method) {
     case 'delegate':
@@ -113,6 +105,31 @@ const createTx = ({ txData, method }) => {
       break
   }
 
+  if (txData.priorityFee) {
+    addPriorityFeeToTransaction({
+      transaction: tx,
+      priorityFee: txData.priorityFee,
+    })
+  }
+
+  if (txData.computeUnits) {
+    addComputeBudgetToTransaction({ transaction: tx, computeUnits: txData.computeUnits })
+  }
+
+  const publicKey = new PublicKey(from)
+  if (!tx.feePayer) {
+    tx.feePayer = publicKey
+  }
+
+  if (tx.signatures.length !== tx.compileMessage().header.numRequiredSignatures) {
+    // Some transactions that we construct internally are technically not complete.
+    // They don't contain the empty signature slot for the public key.
+    tx.signatures.push({
+      publicKey,
+      signature: null,
+    })
+  }
+
   return tx
 }
 

package/src/tx/sign-hardware.js

@@ -1,8 +1,8 @@
 import assert from 'minimalistic-assert'
 
-import { prepareForSigning } from './prepare-for-signing'
 import { PublicKey } from '../vendor'
-import { isVersionedTransaction, isLegacyTransaction, extractTransaction } from './common'
+import { extractTransaction } from './common'
+import { prepareForSigning } from './prepare-for-signing'
 
 export async function signHardware({ unsignedTx, hardwareDevice, accountIndex }) {
   assert(hardwareDevice, 'expected hardwareDevice to be defined')
@@ -19,9 +19,7 @@ const signWithHardwareWallet = async ({ tx, hardwareDevice, accountIndex }) => {
   assert(hardwareDevice, `hardwareDevice required`)
   assert(Number.isInteger(accountIndex), `accountIndex required`)
 
-  const messageToSign = isVersionedTransaction(tx)
-    ? tx.message.serialize()
-    : tx.compileMessage().serialize()
+  const messageToSign = tx.message.serialize()
 
   return hardwareDevice.signTransaction({
     assetName: 'solana',
@@ -31,24 +29,6 @@ const signWithHardwareWallet = async ({ tx, hardwareDevice, accountIndex }) => {
 }
 
 const applySignatures = ({ tx, signatures }) => {
-  if (isLegacyTransaction(tx)) {
-    signatures.forEach(({ publicKey: publicKeyBuffer }) => {
-      const publicKey = new PublicKey(publicKeyBuffer)
-      // 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: pubKey }) =>
-        pubKey.equals(publicKey)
-      )
-      if (!foundEmptySignatureSlot) {
-        // We could use `setSigners` but maybe this is more robust?
-        tx.signatures.push({
-          publicKey,
-          signature: null,
-        })
-      }
-    })
-  }
-
   signatures.forEach(({ publicKey, signature }) => {
     tx.addSignature(new PublicKey(publicKey), signature)
   })

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

@@ -1,11 +1,11 @@
+import bs58 from 'bs58'
 import assert from 'minimalistic-assert'
 import * as nacl from 'tweetnacl'
-import bs58 from 'bs58'
 
-import { prepareForSigning } from './prepare-for-signing'
 import { getKeyPairFromPrivateKey } from '../keypair'
 import { PublicKey } from '../vendor'
-import { extractTransaction, isVersionedTransaction } from './common'
+import { extractTransaction } from './common'
+import { prepareForSigning } from './prepare-for-signing'
 
 /**
  *
@@ -38,44 +38,10 @@ export async function signUnsignedTx(unsignedTx, privateKey) {
   return extractTransaction({ tx })
 }
 
-// Some transactions that we construct internally are technically not complete.
-// They don't contain the empty signature slot for the public key.
-export const fillTransactionWithEmptySignatureSlot = ({ transaction, publicKey }) => {
-  const foundEmptySignatureSlot = transaction.signatures.find(({ publicKey: _publicKey }) =>
-    _publicKey.equals(publicKey)
-  )
-  if (!foundEmptySignatureSlot) {
-    // We could use `setSigners` but maybe this is more robust?
-    transaction.signatures.push({
-      publicKey,
-      signature: null,
-    })
-  }
-}
-
 // Signs plain tx.
 const _signTx = async ({ tx, signer }) => {
   const publicKey = new PublicKey(bs58.encode(Buffer.from(await signer.getPublicKey())))
-
-  if (isVersionedTransaction(tx)) {
-    // VersionedTransaction
-    return _signVersionedTransaction({ tx, signer, publicKey })
-  }
-
-  // Legacy Transactions
-  fillTransactionWithEmptySignatureSlot({ transaction: tx, publicKey })
-
-  return _signLegacyTransaction({ tx, signer, publicKey })
-}
-
-const _signVersionedTransaction = async ({ tx, signer, publicKey }) => {
   const messageData = tx.message.serialize()
   const signature = await signer.sign({ data: messageData, signatureType: 'ed25519' })
   tx.addSignature(publicKey, signature)
 }
-
-const _signLegacyTransaction = async ({ tx, signer, publicKey }) => {
-  const messageData = tx.compileMessage().serialize()
-  const signature = await signer.sign({ data: messageData, signatureType: 'ed25519' })
-  tx.addSignature(publicKey, signature)
-}

package/src/tx/token-instructions.js

@@ -0,0 +1,197 @@
+// internalized from https://github.com/ExodusMovement/serum-ts/blob/0bb5a69176266cbf2c0c06847d01eb4f9d5de4a4/packages/serum/src/token-instructions.js
+import * as BufferLayout from '@exodus/buffer-layout'
+import { PublicKey, SYSVAR_RENT_PUBKEY, TransactionInstruction } from '@exodus/solana-web3.js'
+
+import { publicKeyLayout } from './layout'
+
+// NOTE: Update these if the position of arguments for the initializeAccount instruction changes
+export const INITIALIZE_ACCOUNT_ACCOUNT_INDEX = 0
+export const INITIALIZE_ACCOUNT_MINT_INDEX = 1
+export const INITIALIZE_ACCOUNT_OWNER_INDEX = 2
+
+// NOTE: Update these if the position of arguments for the transfer instruction changes
+export const TRANSFER_SOURCE_INDEX = 0
+export const TRANSFER_DESTINATION_INDEX = 1
+export const TRANSFER_OWNER_INDEX = 2
+
+// NOTE: Update these if the position of arguments for the closeAccount instruction changes
+export const CLOSE_ACCOUNT_SOURCE_INDEX = 0
+export const CLOSE_ACCOUNT_DESTINATION_INDEX = 1
+export const CLOSE_ACCOUNT_OWNER_INDEX = 2
+
+export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')
+
+export const WRAPPED_SOL_MINT = new PublicKey('So11111111111111111111111111111111111111112')
+
+export const MSRM_MINT = new PublicKey('MSRMcoVyrFxnSgo5uXwone5SKcGhT1KEJMFEkMEWf9L')
+export const MSRM_DECIMALS = 0
+
+export const SRM_MINT = new PublicKey('SRMuApVNdxXokk5GT7XD5cUUgXMBCoAz2LHeuAoKWRt')
+export const SRM_DECIMALS = 6
+
+const LAYOUT = BufferLayout.union(BufferLayout.u8('instruction'))
+LAYOUT.addVariant(
+  0,
+  BufferLayout.struct([
+    BufferLayout.u8('decimals'),
+    publicKeyLayout('mintAuthority'),
+    BufferLayout.u8('freezeAuthorityOption'),
+    publicKeyLayout('freezeAuthority'),
+  ]),
+  'initializeMint'
+)
+LAYOUT.addVariant(1, BufferLayout.struct([]), 'initializeAccount')
+LAYOUT.addVariant(3, BufferLayout.struct([BufferLayout.nu64('amount')]), 'transfer')
+LAYOUT.addVariant(4, BufferLayout.struct([BufferLayout.nu64('amount')]), 'approve')
+LAYOUT.addVariant(5, BufferLayout.struct([]), 'revoke')
+LAYOUT.addVariant(
+  6,
+  BufferLayout.struct([
+    BufferLayout.u8('authorityType'),
+    BufferLayout.u8('newAuthorityOption'),
+    publicKeyLayout('newAuthority'),
+  ]),
+  'setAuthority'
+)
+LAYOUT.addVariant(7, BufferLayout.struct([BufferLayout.nu64('amount')]), 'mintTo')
+LAYOUT.addVariant(8, BufferLayout.struct([BufferLayout.nu64('amount')]), 'burn')
+LAYOUT.addVariant(9, BufferLayout.struct([]), 'closeAccount')
+
+const instructionMaxSpan = Math.max(...Object.values(LAYOUT.registry).map((r) => r.span))
+
+function encodeTokenInstructionData(instruction) {
+  const b = Buffer.alloc(instructionMaxSpan)
+  const span = LAYOUT.encode(instruction, b)
+  return b.slice(0, span)
+}
+
+export function decodeTokenInstructionData(instruction) {
+  return LAYOUT.decode(instruction)
+}
+
+export function initializeMint({ mint, decimals, mintAuthority, freezeAuthority = null }) {
+  const keys = [
+    { pubkey: mint, isSigner: false, isWritable: true },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      initializeMint: {
+        decimals,
+        mintAuthority,
+        freezeAuthorityOption: !!freezeAuthority,
+        freezeAuthority: freezeAuthority || new PublicKey(0),
+      },
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function initializeAccount({ account, mint, owner }) {
+  const keys = [
+    { pubkey: account, isSigner: false, isWritable: true },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      initializeAccount: {},
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function transfer({ source, destination, amount, owner }) {
+  const keys = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      transfer: { amount },
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function approve({ source, delegate, amount, owner }) {
+  const keys = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: delegate, isSigner: false, isWritable: false },
+    { pubkey: owner, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      approve: { amount },
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function revoke({ source, owner }) {
+  const keys = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      revoke: {},
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function setAuthority({ target, currentAuthority, newAuthority, authorityType }) {
+  const keys = [
+    { pubkey: target, isSigner: false, isWritable: true },
+    { pubkey: currentAuthority, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      setAuthority: {
+        authorityType,
+        newAuthorityOption: !!newAuthority,
+        newAuthority,
+      },
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function mintTo({ mint, destination, amount, mintAuthority }) {
+  const keys = [
+    { pubkey: mint, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: mintAuthority, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      mintTo: { amount },
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}
+
+export function closeAccount({ source, destination, owner }) {
+  const keys = [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: true, isWritable: false },
+  ]
+  return new TransactionInstruction({
+    keys,
+    data: encodeTokenInstructionData({
+      closeAccount: {},
+    }),
+    programId: TOKEN_PROGRAM_ID,
+  })
+}

package/src/tx/tokens-and-markets.js

@@ -0,0 +1,12 @@
+import { PublicKey } from '@exodus/solana-web3.js'
+
+import Markets from './markets.json'
+
+export const MARKETS = Markets.map((market) => {
+  return {
+    address: new PublicKey(market.address),
+    name: market.name,
+    programId: new PublicKey(market.programId),
+    deprecated: market.deprecated,
+  }
+})

package/src/vendor/account.js

@@ -1,5 +1,5 @@
-import { PublicKey } from './publickey'
 import { getKeyPairFromPrivateKey } from '../keypair'
+import { PublicKey } from './publickey'
 
 /**
  * An account key pair (public and secret keys).

package/src/vendor/compute-budget-program.js

@@ -1,6 +1,6 @@
 import * as BufferLayout from '@exodus/buffer-layout'
 
-import { encodeData, decodeData } from './instruction'
+import { decodeData, encodeData } from './instruction'
 import { PublicKey } from './publickey'
 import { TransactionInstruction } from './transaction'
 

package/src/vendor/message.js

@@ -1,12 +1,11 @@
-import bs58 from 'bs58'
 import * as BufferLayout from '@exodus/buffer-layout'
+import bs58 from 'bs58'
 
+import { PACKET_DATA_SIZE } from './constants'
 import { PublicKey } from './publickey'
-
+import { guardedShift, guardedSplice } from './utils/guarded-array-utils.js'
 import * as Layout from './utils/layout'
-import { PACKET_DATA_SIZE } from './constants'
 import * as shortvec from './utils/shortvec-encoding'
-import { guardedShift, guardedSplice } from './utils/guarded-array-utils.js'
 
 /**
  * The message header, identifying signed and read-only account

package/src/vendor/nonce-account.js

@@ -1,10 +1,8 @@
 import * as BufferLayout from '@exodus/buffer-layout'
 
 import { PublicKey } from './publickey'
-
-import * as Layout from './utils/layout'
-
 import { FeeCalculatorLayout } from './utils/fee-calculator'
+import * as Layout from './utils/layout'
 import { toBuffer } from './utils/to-buffer'
 
 /**
@@ -34,7 +32,7 @@ export class NonceAccount {
    * Deserialize NonceAccount from the account data.
    *
    * @param buffer account data
-   * @return NonceAccount
+   * @returns NonceAccount
    */
   static fromAccountData(buffer) {
     const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0)

package/src/vendor/publickey.js

@@ -1,7 +1,7 @@
 import BN from 'bn.js'
 import bs58 from 'bs58'
-import nacl from 'tweetnacl'
 import createHash from 'create-hash'
+import nacl from 'tweetnacl'
 
 // $FlowFixMe
 const naclLowLevel = nacl.lowlevel

package/src/vendor/stake-program.js

@@ -1,11 +1,11 @@
 import * as BufferLayout from '@exodus/buffer-layout'
 
-import { encodeData, decodeData } from './instruction'
-import * as Layout from './utils/layout'
+import { decodeData, encodeData } from './instruction'
 import { PublicKey } from './publickey'
 import { SystemProgram } from './system-program'
 import { SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY } from './sysvar'
 import { Transaction, TransactionInstruction } from './transaction'
+import * as Layout from './utils/layout'
 
 export const STAKE_CONFIG_ID = new PublicKey('StakeConfig11111111111111111111111111111111')
 

package/src/vendor/system-program.js

@@ -1,11 +1,11 @@
 import * as BufferLayout from '@exodus/buffer-layout'
 
-import { encodeData, decodeData } from './instruction'
-import * as Layout from './utils/layout'
+import { decodeData, encodeData } from './instruction'
 import { NONCE_ACCOUNT_LENGTH } from './nonce-account'
 import { PublicKey } from './publickey'
 import { SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY } from './sysvar'
 import { Transaction, TransactionInstruction } from './transaction'
+import * as Layout from './utils/layout'
 
 /**
  * Create account system transaction params

package/src/vendor/transaction.js

@@ -1,14 +1,14 @@
 // https://github.com/solana-labs/solana-web3.js/blob/master/src/transaction.js
 
 import invariant from 'assert'
-import nacl from 'tweetnacl'
 import bs58 from 'bs58'
+import nacl from 'tweetnacl'
 
+import { PACKET_DATA_SIZE } from './constants'
 import { Message } from './message'
 import { PublicKey } from './publickey'
-import { PACKET_DATA_SIZE } from './constants'
-import * as shortvec from './utils/shortvec-encoding'
 import { guardedSplice } from './utils/guarded-array-utils.js'
+import * as shortvec from './utils/shortvec-encoding'
 
 /**
  * @typedef {string} TransactionSignature

package/src/vendor/utils/layout.js

@@ -1,5 +1,5 @@
-import BN from 'bn.js'
 import * as BufferLayout from '@exodus/buffer-layout'
+import BN from 'bn.js'
 
 /**
  * Layout for a public key