@exodus/solana-lib 1.7.5 → 1.8.0

package/src/key-identifier.js

@@ -6,52 +6,49 @@ import {
 
 export const getSupportedPurposes = () => [44]
 
-export const createGetKeyIdentifier = ({ bip44 } = {}) => (partialParams = {}) => {
-  assert(typeof bip44 === 'number', 'bip44 must be a number')
+export const createGetKeyIdentifier =
+  ({ bip44 } = {}) =>
+  (partialParams = {}) => {
+    assert(typeof bip44 === 'number', 'bip44 must be a number')
 
-  const params = {
-    chainIndex: 0,
-    addressIndex: 0,
-    ...partialParams,
-  }
-  const unhardenedBip44 = unhardenDerivationIndex(bip44)
-  const { compatibilityMode, purpose, accountIndex, addressIndex } = params
+    const params = {
+      chainIndex: 0,
+      addressIndex: 0,
+      ...partialParams,
+    }
+    const unhardenedBip44 = unhardenDerivationIndex(bip44)
+    const { compatibilityMode, purpose, accountIndex, addressIndex } = params
 
-  const allowedPurposes = getSupportedPurposes()
-  assert(
-    allowedPurposes.includes(purpose),
-    `purpose was ${purpose}, which is not allowed. Can be one of the following: ${allowedPurposes.join(
-      ', '
-    )}`
-  )
+    const allowedPurposes = getSupportedPurposes()
+    assert(
+      allowedPurposes.includes(purpose),
+      `purpose was ${purpose}, which is not allowed. Can be one of the following: ${allowedPurposes.join(
+        ', '
+      )}`
+    )
 
-  switch (compatibilityMode) {
-    case 'phantom':
-      // Phantom doesn't use chainIndex (normal vs change address)
-      return {
-        derivationAlgorithm: 'SLIP10',
-        derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}'`,
-        keyType: 'nacl',
-      }
-    case 'ledger':
-      return {
-        derivationAlgorithm: 'SLIP10',
-        derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'`,
-        keyType: 'nacl',
-      }
-    case 'trust':
-      return {
-        derivationAlgorithm: 'SLIP10',
-        derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'`,
-        keyType: 'nacl',
-      }
-    case 'mathwallet':
-      return {
-        derivationAlgorithm: 'BIP32',
-        derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}`,
-        keyType: 'nacl',
-      }
-    default:
-      return _createGetKeyIdentifier({ bip44, keyType: 'nacl' })(params)
+    switch (compatibilityMode) {
+      case 'phantom':
+        // Phantom doesn't use chainIndex (normal vs change address)
+        return {
+          derivationAlgorithm: 'SLIP10',
+          derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}'`,
+          keyType: 'nacl',
+        }
+      case 'ledger':
+      case 'trust':
+        return {
+          derivationAlgorithm: 'SLIP10',
+          derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'`,
+          keyType: 'nacl',
+        }
+      case 'mathwallet':
+        return {
+          derivationAlgorithm: 'BIP32',
+          derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}`,
+          keyType: 'nacl',
+        }
+      default:
+        return _createGetKeyIdentifier({ bip44, keyType: 'nacl' })(params)
+    }
   }
-}

package/src/keypair.js

@@ -1,5 +1,5 @@
 import nacl from 'tweetnacl'
-import { PublicKey } from './vendor'
+import { PublicKey } from './vendor/publickey'
 
 export function getKeyPairFromPrivateKey(privateKey) {
   const { publicKey, secretKey } = nacl.sign.keyPair.fromSeed(

package/src/magiceden/coders.js

@@ -19,13 +19,9 @@ const idl = {
 }
 
 export function sighash(nameSpace, ixName) {
-  let preimage = `${nameSpace}:${ixName}`
+  const preimage = `${nameSpace}:${ixName}`
 
-  return Buffer.from(
-    createHash('sha256')
-      .update(preimage)
-      .digest()
-  ).slice(0, 8)
+  return Buffer.from(createHash('sha256').update(preimage).digest()).slice(0, 8)
 }
 
 export function encodeData(name, args = {}) {

package/src/magiceden/escrow-program.js

@@ -4,16 +4,16 @@ import { encodeData } from './coders'
 
 const PLATFORM_FEES_PROGRAM_ID = new PublicKey('2NZukH2TXpcuZP4htiuT8CFxcaQSWzkkR6kepSWnZ24Q')
 
-export class MagicEdenEscrowProgram {
-  static get programId() {
+export const MagicEdenEscrowProgram = {
+  get programId() {
     return MAGIC_EDEN_ESCROW_PROGRAM_ID
-  }
+  },
 
-  static get space() {
+  get space() {
     return 80
-  }
+  },
 
-  static initializeEscrow(params) {
+  initializeEscrow(params) {
     const {
       initializerPubkey,
       initializerDepositTokenPubkey,
@@ -55,9 +55,9 @@ export class MagicEdenEscrowProgram {
       programId: this.programId,
       data: encodeData('initializeEscrow', { takerAmount, escrowBump }),
     })
-  }
+  },
 
-  static cancelEscrow(params) {
+  cancelEscrow(params) {
     const { initializerPubkey, initializerDepositTokenPubkey, pdaPubkey, escrowPubkey } = params
 
     return new Transaction().add({
@@ -91,9 +91,9 @@ export class MagicEdenEscrowProgram {
       programId: this.programId,
       data: encodeData('cancelEscrow'),
     })
-  }
+  },
 
-  static exchange(params) {
+  exchange(params) {
     const {
       expectedTakerAmount,
       expectedMintPubkey,
@@ -167,5 +167,5 @@ export class MagicEdenEscrowProgram {
         expectedMint: expectedMintPubkey.toBuffer(),
       }),
     })
-  }
+  },
 }

package/src/transaction.js

@@ -2,6 +2,7 @@ import assert from 'assert'
 import BN from 'bn.js'
 import bs58 from 'bs58'
 import { get } from 'lodash'
+import feeData from './fee-data/solana'
 
 import { getKeyPairFromPrivateKey } from './keypair'
 import { findAssociatedTokenAddress, createStakeAddress } from './encode'
@@ -20,6 +21,7 @@ import {
   Authorized,
   Lockup,
   TransactionInstruction,
+  ComputeBudgetProgram,
 } from './vendor'
 import { MagicEdenEscrowProgram } from './magiceden/escrow-program'
 import { MEMO_PROGRAM_ID, SEED, STAKE_PROGRAM_ID } from './constants'
@@ -30,7 +32,7 @@ class Tx {
     to,
     amount,
     recentBlockhash,
-    // fee, // (Fee per Signature: 5000 lamports)
+    fee, // (Fee per Signature: 5000 lamports)
     // Tokens related:
     // pass either name or mintAddress, if both, mintAddress has priority
     tokenMintAddress,
@@ -48,14 +50,15 @@ class Tx {
       assert(amount, 'amount is required')
       assert(typeof amount === 'number', 'amount must be a number')
     }
+
     assert(recentBlockhash, 'recentBlockhash is required')
     if (tokenMintAddress) {
       assert(
-        typeof destinationAddressType !== 'undefined',
+        destinationAddressType !== undefined,
         'destinationAddressType is required when sending tokens'
       )
       assert(
-        typeof isAssociatedTokenAccountActive !== 'undefined',
+        isAssociatedTokenAccountActive !== undefined,
         'isAssociatedTokenAccountActive is required when sending tokens'
       ) // needed to create the recipient account
       assert(Array.isArray(fromTokenAddresses), 'fromTokenAddresses Array is required')
@@ -95,6 +98,17 @@ class Tx {
         })
       )
     }
+
+    // if fee greater than base fee. Add prioritization fee:
+    if (fee > feeData.fee.toBaseNumber()) {
+      const ratio = fee - feeData.fee.toBaseNumber()
+      if (ratio > 1_000_000) throw new Error('Prioritization fee is too high')
+
+      const priorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: ratio || 100,
+      }) // 1 microLamport = 0.000001 lamports
+      this.transaction.add(priorityFeeInstruction)
+    }
   }
 
   buildSOLtransaction({ from, to, amount, recentBlockhash, feePayer, reference }) {
@@ -229,8 +243,7 @@ class Tx {
       votePubkey: poolKey, // pool vote key
     })
 
-    const transaction = new Transaction({ recentBlockhash }).add(programTx).add(delegateTx)
-    return transaction
+    return new Transaction({ recentBlockhash }).add(programTx).add(delegateTx)
   }
 
   static undelegate({ address, stakeAddresses, recentBlockhash }) {
@@ -388,7 +401,7 @@ class Tx {
     const stakingInstructions = tx.instructions.filter(
       (ix) => ix.programId.toString() === STAKE_PROGRAM_ID.toString()
     )
-    const isStakingTx = !!stakingInstructions.length
+    const isStakingTx = stakingInstructions.length > 0
 
     if (!isStakingTx) return null // normal transfer tx
 
@@ -396,7 +409,7 @@ class Tx {
       txId,
       owner: tx.getFeePayer().toString(), // SOL sender
     }
-    const txDetails = stakingInstructions.reduce((info, ix) => {
+    return stakingInstructions.reduce((info, ix) => {
       const type = StakeInstruction.decodeInstructionType(ix)
       switch (type) {
         case 'Delegate':
@@ -424,14 +437,13 @@ class Tx {
           return info
       }
     }, info)
-
-    return txDetails
   }
 
   getTxId() {
     if (!this.transaction.signature) {
       throw new Error('Cannot get txId, tx is not signed')
     }
+
     return bs58.encode(this.transaction.signature)
   }
 
@@ -441,6 +453,7 @@ class Tx {
     if (!transaction.signature) {
       throw new Error('Cannot get txId, tx is not signed')
     }
+
     return bs58.encode(transaction.signature)
   }
 

package/src/tx/build-raw-transaction.js

@@ -34,11 +34,11 @@ export function buildRawTransaction(signData, signatures) {
   const rawTransactionLength = signData.length + signaturesLength
 
   if (signatures.length > MAX_SIGNATURES) {
-    throw Error(`Too many signatures: ${signatures.length} > ${MAX_SIGNATURES}`)
+    throw new Error(`Too many signatures: ${signatures.length} > ${MAX_SIGNATURES}`)
   }
 
   if (rawTransactionLength > PACKET_DATA_SIZE) {
-    throw Error(`Transaction too large: ${rawTransactionLength} > ${PACKET_DATA_SIZE}`)
+    throw new Error(`Transaction too large: ${rawTransactionLength} > ${PACKET_DATA_SIZE}`)
   }
 
   const rawTransaction = Buffer.alloc(rawTransactionLength)
@@ -50,7 +50,7 @@ export function buildRawTransaction(signData, signatures) {
     }
 
     if (signature.length !== SIGNATURE_LENGTH) {
-      throw Error('Invalid signature length')
+      throw new Error('Invalid signature length')
     }
 
     Buffer.from(signature).copy(rawTransaction, signatureCount.length + index * SIGNATURE_LENGTH)

package/src/tx/common.js

@@ -13,6 +13,7 @@ export function getTxId(tx) {
   if (signature === null) {
     throw new Error('Cannot get transaction ID of unsigned transaction')
   }
+
   return base58.encode(signature)
 }
 

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

@@ -1,4 +1,4 @@
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../helpers/spl-token'
 import { MARKETS, TokenInstructions } from '@project-serum/serum'
 import * as BufferLayout from '@exodus/buffer-layout'
 
@@ -126,23 +126,37 @@ export function decodeTokenProgramInstruction(instruction) {
 
   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),
+  switch (type) {
+    case '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),
+      }
+
+      break
     }
-  } 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),
+
+    case 'closeAccount':
+    case 'transfer': {
+      data = {
+        ...data,
+        sourcePubkey: keys.getAddress(TokenInstructions.TRANSFER_SOURCE_INDEX),
+        destinationPubKey: keys.getAddress(TokenInstructions.TRANSFER_DESTINATION_INDEX),
+        ownerPubKey: keys.getAddress(TokenInstructions.TRANSFER_OWNER_INDEX),
+      }
+
+      break
     }
-  } else if (type === 'createSyncNativeInstruction') {
-    data = {
-      pubkey: keys.getAddress(0),
+
+    case 'createSyncNativeInstruction': {
+      data = {
+        pubkey: keys.getAddress(0),
+      }
+
+      break
     }
+    // No default
   }
 
   return {

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

@@ -1,6 +1,7 @@
 import { asset } from '@exodus/solana-meta'
 
-import { Transaction, PublicKey } from '../'
+import { PublicKey } from '../vendor'
+import Transaction from '../transaction'
 import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
 
 /**
@@ -9,25 +10,27 @@ import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
  * @returns a Solana Web3.js Transaction object
  */
 export function prepareForSigning(unsignedTx) {
-  const { amount: unitAmount, from, method, transaction } = unsignedTx.txData
+  const { amount: unitAmount, fee: feeAmount, from, method, transaction } = unsignedTx.txData
 
-  if (transaction) {
-    // unsignedTx contained a transaction in web3.js format
-    return transaction
-  } else {
-    // Create
+  if (!transaction) {
+    // Create a transaction in web3.js format
     const address = from
     const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
+    const fee = feeAmount ? asset.currency.baseUnit(feeAmount).toNumber() : feeAmount
 
-    const txData = { ...unsignedTx.txData, address, amount }
+    const txData = { ...unsignedTx.txData, address, amount, fee }
 
     const transaction = createTx({ txData, method })
 
     if (!transaction.feePayer) {
       transaction.feePayer = new PublicKey(from)
     }
+
     return transaction
   }
+
+  // unsignedTx contained a transaction in web3.js format
+  return transaction
 }
 
 const createTx = ({ txData, method }) => {
@@ -49,6 +52,7 @@ const createTx = ({ txData, method }) => {
       tx = createMagicEdenInitializeEscrowTransaction(txData)
       break
     }
+
     case 'cancelEscrow':
       tx = createMagicEdenCancelEscrowTransaction(txData)
       break
@@ -63,6 +67,7 @@ const createTx = ({ txData, method }) => {
       tx = createTokenTransaction(txData)
       break
   }
+
   return tx
 }
 
@@ -150,6 +155,7 @@ const createMagicEdenExchangeTransaction = ({
 const createTokenTransaction = ({
   amount,
   destinationAddressType,
+  fee,
   feePayer,
   from,
   fromTokenAddresses,
@@ -164,6 +170,7 @@ const createTokenTransaction = ({
   new Transaction({
     amount,
     destinationAddressType,
+    fee,
     feePayer,
     from,
     fromTokenAddresses,

package/src/tx/sign-hardware.js

@@ -23,13 +23,11 @@ const signWithHardwareWallet = async ({ tx, hardwareDevice, accountIndex }) => {
     ? tx.message.serialize()
     : tx.compileMessage().serialize()
 
-  const signatures = await hardwareDevice.signTransaction({
+  return hardwareDevice.signTransaction({
     assetName: 'solana',
     signableTransaction: Buffer.from(messageToSign),
     derivationPaths: [`m/44'/501'/${accountIndex}'`],
   })
-
-  return signatures
 }
 
 const applySignatures = ({ tx, signatures }) => {

package/src/tx/sign-message.js

@@ -10,7 +10,7 @@ function isLegacyMessage(data) {
     const message = Message.from(data)
     message.serialize() // Invalid messages will throw on serialization.
     return true
-  } catch (err) {
+  } catch {
     return false
   }
 }
@@ -22,9 +22,9 @@ function isVersionedMessage(data) {
     // so we ban all bytes starting at 0x80 and ending at 0xFE
     // 0xFF is allowed because that is used for offchain messages
     return data[0] >= 0x80 && data[0] !== 0xff
-  } else {
-    return false
   }
+
+  return false
 }
 
 export function isTransactionMessage(data) {
@@ -40,6 +40,5 @@ export default function signMessage({ message, privateKey }) {
     'attempted to sign transaction using message signing'
   )
   const signature = nacl.sign.detached(messageBuffer, secretKey)
-  const bs58Signature = bs58.encode(signature)
-  return bs58Signature
+  return bs58.encode(signature)
 }

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

@@ -20,19 +20,7 @@ export function getTransactionSimulationParams(transactionMessage) {
     transactionMessage.staticAccountKeys.forEach((account) =>
       accountAddresses.add(account.toString())
     )
-  } else if (!transactionMessage.accountKeys) {
-    const programIds = new Set(
-      transactionMessage.instructions.map((instruction) => instruction.programId.toString())
-    )
-
-    transactionMessage.instructions.forEach((instruction) => {
-      instruction.keys.forEach((key) => {
-        if (!programIds.has(key.pubkey.toString())) {
-          accountAddresses.add(key.pubkey.toString())
-        }
-      })
-    })
-  } else {
+  } else if (transactionMessage.accountKeys) {
     if (!indexToProgramIds) {
       indexToProgramIds = new Map()
       transactionMessage.instructions.forEach((instruction) =>
@@ -46,16 +34,28 @@ export function getTransactionSimulationParams(transactionMessage) {
     transactionMessage.accountKeys
       .filter((_, index) => !indexToProgramIds.has(index))
       .forEach((account) => accountAddresses.add(account.toString()))
+  } else {
+    const programIds = new Set(
+      transactionMessage.instructions.map((instruction) => instruction.programId.toString())
+    )
+
+    transactionMessage.instructions.forEach((instruction) => {
+      instruction.keys.forEach((key) => {
+        if (!programIds.has(key.pubkey.toString())) {
+          accountAddresses.add(key.pubkey.toString())
+        }
+      })
+    })
   }
 
   config['accounts'] = {
     encoding: 'base64',
-    addresses: Array.from(accountAddresses),
+    addresses: [...accountAddresses],
   }
 
   return {
     config,
-    accountAddresses: Array.from(accountAddresses),
+    accountAddresses: [...accountAddresses],
   }
 }
 
@@ -67,7 +67,7 @@ export function filterAccountsByOwner(futureAccountsState, accountAddresses, pub
 
   // Shouldn't happen
   if (futureAccountsState.length !== accountAddresses.length) {
-    throw Error('Simulation returning wrong account length')
+    throw new Error('Simulation returning wrong account length')
   }
 
   futureAccountsState.forEach((futureAccount, index) => {
@@ -82,6 +82,7 @@ export function filterAccountsByOwner(futureAccountsState, accountAddresses, pub
             address: publicKey,
           })
         }
+
         return
       }
 
@@ -95,7 +96,7 @@ export function filterAccountsByOwner(futureAccountsState, accountAddresses, pub
         tokenAccounts.push({
           amount,
           mint: new PublicKey(token.mint).toString(),
-          owner: owner,
+          owner,
           address: accountAddress.toString(),
         })
       }