@exodus/solana-lib 1.6.10 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.6.10",
+  "version": "1.7.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -27,5 +27,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "1210a44d1b6a8fc0375589f7e2439aa3fd0f6b01"
+  "gitHead": "d0aa3d128fe488e0d4849923e5b134b80b6fef97"
 }

package/src/index.js

@@ -12,6 +12,4 @@ export {
 } from './vendor'
 export { default as Transaction } from './transaction'
 export { U64 } from './helpers/spl-token'
-export { default as createGetKeyIdentifier } from './key-identifier'
-export { default as getTransactionStrategy } from './helpers/transaction-strategy'
-export { default as VersionedTransaction } from './versioned-transaction'
+export { createGetKeyIdentifier, getSupportedPurposes } from './key-identifier'

package/src/key-identifier.js

@@ -1,36 +1,57 @@
 import assert from 'minimalistic-assert'
-import { createGetKeyIdentifier, unhardenDerivationIndex } from '@exodus/key-utils'
+import {
+  createGetKeyIdentifier as _createGetKeyIdentifier,
+  unhardenDerivationIndex,
+} from '@exodus/key-utils'
 
-export default ({ bip44, assetName, keyType } = {}) => (params = {}) => {
+export const getSupportedPurposes = () => [44]
+
+export const createGetKeyIdentifier = ({ bip44 } = {}) => (partialParams = {}) => {
   assert(typeof bip44 === 'number', 'bip44 must be a number')
 
-  const { compatibilityMode, purpose, accountIndex = 0, addressIndex = 0 } = 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(
+      ', '
+    )}`
+  )
 
   switch (compatibilityMode) {
     case 'phantom':
       // Phantom doesn't use chainIndex (normal vs change address)
       return {
-        assetName,
         derivationAlgorithm: 'SLIP10',
         derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}'`,
-        keyType,
+        keyType: 'nacl',
+      }
+    case 'ledger':
+      return {
+        derivationAlgorithm: 'SLIP10',
+        derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'`,
+        keyType: 'nacl',
       }
     case 'trust':
       return {
-        assetName,
         derivationAlgorithm: 'SLIP10',
         derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'`,
-        keyType,
+        keyType: 'nacl',
       }
     case 'mathwallet':
       return {
-        assetName,
         derivationAlgorithm: 'BIP32',
         derivationPath: `m/${purpose}'/${unhardenedBip44}'/${accountIndex}'/${addressIndex}`,
-        keyType,
+        keyType: 'nacl',
       }
     default:
-      return createGetKeyIdentifier({ bip44, assetName, keyType })(params)
+      return _createGetKeyIdentifier({ bip44, keyType: 'nacl' })(params)
   }
 }

package/src/tx/common.js

@@ -0,0 +1,47 @@
+import base58 from 'bs58'
+
+export function isVersionedTransaction(tx) {
+  return Number.isInteger(tx.version)
+}
+
+export function isLegacyTransaction(tx) {
+  return !isVersionedTransaction(tx)
+}
+
+export function getTxId(tx) {
+  const signature = getFirstSignature(tx)
+  if (signature === null) {
+    throw new Error('Cannot get transaction ID of unsigned transaction')
+  }
+  return base58.encode(signature)
+}
+
+function getFirstSignature(tx) {
+  if (isVersionedTransaction(tx)) {
+    // Versioned
+    if (tx.signatures.length > 0) {
+      return tx.signatures[0]
+    }
+  } else {
+    // Legacy
+    if (tx.signatures.length > 0) {
+      return tx.signatures[0].signature
+    }
+  }
+
+  return null
+}
+
+export const extractTransaction = ({ tx }) => {
+  const serializedTransaction = tx.serialize({
+    // Override the default, we don't require all signatures
+    // when interacting with dApps. Only affects legacy transactions,
+    // because versioned transactions won't be doing this check anymore.
+    requireAllSignatures: false,
+    verifySignatures: true,
+  })
+  const rawTx = Buffer.from(serializedTransaction).toString('base64')
+  const txId = getTxId(tx)
+
+  return { txId, rawTx }
+}

package/src/tx/index.js

@@ -5,4 +5,5 @@ export * from './create-and-sign-tx'
 export * from './simulate-and-sign-tx'
 export * from './decode-tx-instructions'
 export * from './build-raw-transaction'
+export * from './sign-hardware'
 export { default as signMessage } from './sign-message'

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

@@ -0,0 +1,185 @@
+import { asset } from '@exodus/solana-meta'
+
+import { Transaction, PublicKey } from '../'
+import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
+
+/**
+ * Prepares the transaction to be signed (exodus & ledger).
+ * @param {UnsignedTx} unsignedTx
+ * @returns a Solana Web3.js Transaction object
+ */
+export function prepareForSigning(unsignedTx) {
+  const { amount: unitAmount, from, method, transaction } = unsignedTx.txData
+
+  if (transaction) {
+    // unsignedTx contained a transaction in web3.js format
+    return transaction
+  } else {
+    // Create
+    const address = from
+    const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
+
+    const txData = { ...unsignedTx.txData, address, amount }
+
+    const { transaction } = createTx({ txData, method })
+
+    if (!transaction.feePayer) {
+      transaction.feePayer = new PublicKey(from)
+    }
+    return transaction
+  }
+}
+
+const createTx = ({ txData, method }) => {
+  let tx
+  switch (method) {
+    case 'delegate':
+      tx = createDelegateTransaction(txData)
+      break
+    case 'undelegate':
+      tx = createUndelegateTransaction(txData)
+      break
+    case 'withdraw':
+      tx = createWithdrawTransaction(txData)
+      break
+    case 'closeAccount':
+      tx = createCloseAccountTransaction(txData)
+      break
+    case 'initializeEscrow': {
+      tx = createMagicEdenInitializeEscrowTransaction(txData)
+      break
+    }
+    case 'cancelEscrow':
+      tx = createMagicEdenCancelEscrowTransaction(txData)
+      break
+    case 'exchange':
+      tx = createMagicEdenExchangeTransaction(txData)
+      break
+    case 'metaplexTransfer':
+      tx = createMetaplexTransferTransaction(txData)
+      break
+    default:
+      // SOL and Token tx
+      tx = createTokenTransaction(txData)
+      break
+  }
+  return tx
+}
+
+const createDelegateTransaction = ({ address, amount, pool, recentBlockhash, seed }) =>
+  Transaction.createStakeAccountTransaction({
+    address,
+    amount,
+    recentBlockhash,
+    seed,
+    pool,
+  })
+
+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,
+  })

package/src/tx/sign-hardware.js

@@ -0,0 +1,44 @@
+import assert from 'minimalistic-assert'
+
+import { prepareForSigning } from './prepare-for-signing'
+import { PublicKey } from '../vendor'
+import { isVersionedTransaction, isLegacyTransaction, extractTransaction } from './common'
+
+export async function signHardware({ unsignedTx, hardwareDevice, accountIndex }) {
+  assert(hardwareDevice, 'expected hardwareDevice to be defined')
+  assert(Number.isInteger(accountIndex) && accountIndex >= 0, 'expected accountIndex to be integer')
+
+  const tx = prepareForSigning(unsignedTx)
+  const signatures = await signWithHardwareWallet({ tx, hardwareDevice, accountIndex })
+  applySignatures({ tx, signatures })
+
+  return extractTransaction({ tx })
+}
+
+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 signatures = await hardwareDevice.signTransaction({
+    assetName: 'solana',
+    signableTransaction: Buffer.from(messageToSign),
+    derivationPaths: [`m/44'/501'/${accountIndex}'`],
+  })
+
+  return signatures
+}
+
+const applySignatures = ({ tx, signatures }) => {
+  if (isLegacyTransaction(tx)) {
+    const publicKeys = signatures.map(({ publicKey }) => new PublicKey(publicKey))
+    tx.setSigners(...publicKeys)
+  }
+
+  signatures.forEach(({ publicKey, signature }) => {
+    tx.addSignature(new PublicKey(publicKey), signature)
+  })
+}

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

@@ -1,185 +1,29 @@
-import { asset } from '@exodus/solana-meta'
+import assert from 'minimalistic-assert'
 
-import { Transaction, getTransactionStrategy } from '../'
-import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
+import { prepareForSigning } from './prepare-for-signing'
+import { getKeyPairFromPrivateKey } from '../keypair'
+import { Account } from '../vendor'
+import { extractTransaction, isVersionedTransaction } from './common'
 
 export function signUnsignedTx(unsignedTx, privateKey) {
-  const { amount: unitAmount, from, method, transaction } = unsignedTx.txData
+  assert(privateKey, 'Please provide a secretKey')
 
-  if (transaction) {
-    return _signTx({ tx: transaction, privateKey })
-  }
-
-  const address = from
-  const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
+  const tx = prepareForSigning(unsignedTx)
 
-  const txData = { ...unsignedTx.txData, address, amount }
+  _signTx({ tx, privateKey })
 
-  const tx = createTx({ txData, method })
-  return _signTx({ tx, privateKey })
+  return extractTransaction({ tx })
 }
 
 // Signs plain tx.
 const _signTx = ({ tx, privateKey }) => {
-  const _Transaction = getTransactionStrategy(tx)
-
-  _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(txData)
-      break
-    case 'undelegate':
-      tx = createUndelegateTransaction(txData)
-      break
-    case 'withdraw':
-      tx = createWithdrawTransaction(txData)
-      break
-    case 'closeAccount':
-      tx = createCloseAccountTransaction(txData)
-      break
-    case 'initializeEscrow': {
-      tx = createMagicEdenInitializeEscrowTransaction(txData)
-      break
-    }
-    case 'cancelEscrow':
-      tx = createMagicEdenCancelEscrowTransaction(txData)
-      break
-    case 'exchange':
-      tx = createMagicEdenExchangeTransaction(txData)
-      break
-    case 'metaplexTransfer':
-      tx = createMetaplexTransferTransaction(txData)
-      break
-    default:
-      // SOL and Token tx
-      tx = createTokenTransaction(txData)
-      break
+  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
+  const account = new Account(secretKey)
+  if (isVersionedTransaction(tx)) {
+    // VersionedTransaction
+    tx.sign([account])
+  } else {
+    // Legacy Transactions
+    tx.sign(account)
   }
-  return tx
 }
-
-const createDelegateTransaction = ({ address, amount, pool, recentBlockhash, seed }) =>
-  Transaction.createStakeAccountTransaction({
-    address,
-    amount,
-    recentBlockhash,
-    seed,
-    pool,
-  })
-
-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,
-  })

package/src/vendor/publickey.js

@@ -51,6 +51,14 @@ export class PublicKey {
     return bs58.encode(this.toBuffer())
   }
 
+  /**
+   * Return the byte array representation of the public key in big endian
+   */
+  toBytes() {
+    const buf = this.toBuffer()
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
+  }
+
   /**
    * Return the Buffer representation of the public key
    */

package/src/helpers/transaction-strategy.js

@@ -1,25 +0,0 @@
-import { Transaction, VersionedTransaction } from '..'
-import { SUPPORTED_TRANSACTION_VERSIONS } from '../constants'
-
-const isVersionedTransactionType = (transaction) => {
-  // new transaction types have a version field, either a string(legacy) or a number(>=0)
-  return transaction.version !== undefined
-}
-
-const isVersionedTransactionTypeSupported = (transaction) => {
-  return SUPPORTED_TRANSACTION_VERSIONS.has(transaction.version)
-}
-
-const getTransactionStrategy = (transaction) => {
-  if (isVersionedTransactionType(transaction)) {
-    if (isVersionedTransactionTypeSupported(transaction)) {
-      return VersionedTransaction
-    }
-
-    throw new Error(`unsupported transaction version: ${transaction.version}`)
-  }
-
-  return Transaction
-}
-
-export default getTransactionStrategy

package/src/versioned-transaction.js

@@ -1,45 +0,0 @@
-import base58 from 'bs58'
-import { getKeyPairFromPrivateKey } from './keypair'
-import { Account } from './vendor'
-
-function getFirstSignature(tx) {
-  if (tx.signatures.length > 0) {
-    return tx.signatures[0]
-  }
-
-  return null
-}
-
-class VersionedTx {
-  // tx is not supported from the vendored library (solana-lib/src/vendor).
-  // We also can't make any guarantees that Account from vendored lib with version X
-  // will be compatible with the tx built by an outside library with version Y.
-  static sign(tx, privateKey, extraSigners = []) {
-    if (!privateKey) {
-      throw new Error('Please provide a secretKey')
-    }
-    const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-    const signers = [new Account(secretKey), ...extraSigners]
-
-    tx.sign(signers)
-
-    if (!(tx.signatures && tx.signatures.length)) {
-      throw new Error('!Signature')
-    }
-  }
-
-  static serialize(tx) {
-    const serializedTx = tx.serialize()
-    return Buffer.from(serializedTx).toString('base64')
-  }
-
-  static getTxId(tx) {
-    const signature = getFirstSignature(tx)
-    if (signature === null) {
-      throw new Error('Cannot get transaction ID of unsigned transaction')
-    }
-    return base58.encode(signature)
-  }
-}
-
-export default VersionedTx