@exodus/solana-lib 1.2.21 → 1.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.2.21",
+  "version": "1.2.23",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -23,5 +23,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "dac1d4d133b92c18334de5a37332cfad769e1459"
+  "gitHead": "7073b51b6cf558547ca05ae25eaac44cf28a022b"
 }

package/src/encode.js

@@ -1,4 +1,5 @@
 // @flow
+import assert from 'assert'
 import { PublicKey, StakeProgram } from './vendor'
 import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID, SEED } from './constants'
 import { getPublicKey, getKeyPairFromPrivateKey } from './keypair'
@@ -35,6 +36,12 @@ export function getEncodedSecretKey(privateKey): string {
   return bs58.encode(secretKey)
 }
 
+export function getPrivateKeyFromSecretKey(secretKey: string): string {
+  const privateKey = bs58.decode(secretKey).slice(0, 32) // Buffer
+  assert(privateKey.length >= 32, 'privateKey has unexpected length')
+  return privateKey
+}
+
 // doc: https://spl.solana.com/associated-token-account (HACK: refactored to sync)
 export function findAssociatedTokenAddress(
   walletAddress: string,

package/src/keypair.js

@@ -12,6 +12,15 @@ export function getKeyPairFromPrivateKey(privateKey: string | Buffer): Object {
   }
 }
 
+export function generateKeyPair() {
+  const { publicKey, secretKey } = nacl.sign.keyPair()
+
+  return {
+    secretKey: Buffer.from(secretKey, 'hex'), // secretKey
+    publicKey: Buffer.from(publicKey, 'hex'),
+  }
+}
+
 export function getPublicKey(privateKey: string | Buffer): Buffer {
   return getKeyPairFromPrivateKey(privateKey).publicKey
 }

package/src/magiceden/__tests__/escrow.test.js

@@ -0,0 +1,64 @@
+import test from 'tape'
+import { BN } from 'bn.js'
+import { PublicKey } from '../../vendor'
+
+import { MagicEdenEscrowProgram } from '../escrow-program'
+
+import fixtures from './fixtures'
+
+const serializeTx = (tx) => {
+  return tx.instructions.map((instruction) => ({
+    instructions: instruction.keys.map((k) => ({ ...k, pubkey: k.pubkey.toBase58() })),
+    programId: instruction.programId.toBase58(),
+    data: instruction.data.toString('hex'),
+  }))
+}
+
+test('MagicEden: initializeEscrow', (t) => {
+  const tx = MagicEdenEscrowProgram.initializeEscrow({
+    initializerPubkey: new PublicKey('EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC'),
+    initializerDepositTokenPubkey: new PublicKey('38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB'),
+    escrowPubkey: new PublicKey('AicHKDZR5jLfozYcek5ZHw5mJfxBNFbUwHF2nM4qF8oN'),
+    lamports: 500,
+    takerAmount: new BN(1e10),
+  })
+
+  t.deepEqual(serializeTx(tx), fixtures.initializeEscrow)
+
+  t.end()
+})
+
+test('MagicEden: cancelEscrow', (t) => {
+  const tx = MagicEdenEscrowProgram.cancelEscrow({
+    initializerPubkey: new PublicKey('EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC'),
+    initializerDepositTokenPubkey: new PublicKey('38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB'),
+    pdaPubkey: new PublicKey('GUfCR9mK6azb9vcpsxgXyj7XRPAKJd4KMHTTVvtncGgp'),
+    escrowPubkey: new PublicKey('AicHKDZR5jLfozYcek5ZHw5mJfxBNFbUwHF2nM4qF8oN'),
+  })
+
+  t.deepEqual(serializeTx(tx), fixtures.cancelEscrow)
+
+  t.end()
+})
+
+test('MagicEden: exchange', (t) => {
+  const tx = MagicEdenEscrowProgram.exchange({
+    takerPubkey: new PublicKey('FuDxYSDtRAG4P65wxAmUZShBSGtn79o2yJpPF13LQB87'),
+    initializerDepositTokenPubkey: new PublicKey('38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB'),
+    initializerPubkey: new PublicKey('EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC'),
+    escrowPubkey: new PublicKey('DvijtTLQGCmmFMPpthitkpP35hGHxdJRxAERjtN13mPg'),
+    pdaPubkey: new PublicKey('GUfCR9mK6azb9vcpsxgXyj7XRPAKJd4KMHTTVvtncGgp'),
+    metadataPubkey: new PublicKey('4ysTyhoHDAv28dGUD2ASS9zmAHi3QZyXVQW25f6QwWN'),
+    creators: [
+      {
+        address: 'D6ZQMLTJAa14XhzCFBJ2uuPjYDbYfewrVDVSyFZSuBYe',
+        verified: 1,
+        share: 100,
+      },
+    ],
+  })
+
+  t.deepEqual(serializeTx(tx), fixtures.exchange)
+
+  t.end()
+})

package/src/magiceden/__tests__/fixtures.js

@@ -0,0 +1,134 @@
+export default {
+  initializeEscrow: [
+    {
+      instructions: [
+        {
+          pubkey: 'EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC',
+          isSigner: true,
+          isWritable: true,
+        },
+        {
+          pubkey: 'AicHKDZR5jLfozYcek5ZHw5mJfxBNFbUwHF2nM4qF8oN',
+          isSigner: true,
+          isWritable: true,
+        },
+      ],
+      programId: '11111111111111111111111111111111',
+      data:
+        '00000000f4010000000000005000000000000000052f21a9fe604e569e956f29223106fa26ce0a21520247a93a07a1489239c8ff',
+    },
+    {
+      instructions: [
+        {
+          pubkey: 'EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC',
+          isWritable: false,
+          isSigner: true,
+        },
+        {
+          pubkey: '38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'AicHKDZR5jLfozYcek5ZHw5mJfxBNFbUwHF2nM4qF8oN',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+          isWritable: false,
+          isSigner: false,
+        },
+      ],
+      programId: 'MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8',
+      data: 'f3a04d990b5c30d100e40b5402000000',
+    },
+  ],
+  cancelEscrow: [
+    {
+      instructions: [
+        {
+          pubkey: 'EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC',
+          isWritable: false,
+          isSigner: false,
+        },
+        {
+          pubkey: '38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'GUfCR9mK6azb9vcpsxgXyj7XRPAKJd4KMHTTVvtncGgp',
+          isWritable: false,
+          isSigner: false,
+        },
+        {
+          pubkey: 'AicHKDZR5jLfozYcek5ZHw5mJfxBNFbUwHF2nM4qF8oN',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+          isWritable: false,
+          isSigner: false,
+        },
+      ],
+      programId: 'MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8',
+      data: '9ccb36b326482115',
+    },
+  ],
+  exchange: [
+    {
+      instructions: [
+        {
+          pubkey: 'FuDxYSDtRAG4P65wxAmUZShBSGtn79o2yJpPF13LQB87',
+          isWritable: false,
+          isSigner: true,
+        },
+        {
+          pubkey: '38y2gagfKoVVmLXxqESXWkBLHarzEq6f6cmA1DoAqRnB',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'EpGkR4PcMYHLwZJn7rnxmmLihaZkaAeQLsw4ao3nUUmC',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'DvijtTLQGCmmFMPpthitkpP35hGHxdJRxAERjtN13mPg',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: 'GUfCR9mK6azb9vcpsxgXyj7XRPAKJd4KMHTTVvtncGgp',
+          isWritable: false,
+          isSigner: false,
+        },
+        { pubkey: '11111111111111111111111111111111', isWritable: false, isSigner: false },
+        {
+          pubkey: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+          isWritable: false,
+          isSigner: false,
+        },
+        {
+          pubkey: '2NZukH2TXpcuZP4htiuT8CFxcaQSWzkkR6kepSWnZ24Q',
+          isWritable: true,
+          isSigner: false,
+        },
+        {
+          pubkey: '4ysTyhoHDAv28dGUD2ASS9zmAHi3QZyXVQW25f6QwWN',
+          isWritable: false,
+          isSigner: false,
+        },
+        {
+          pubkey: 'D6ZQMLTJAa14XhzCFBJ2uuPjYDbYfewrVDVSyFZSuBYe',
+          isWritable: true,
+          isSigner: false,
+        },
+      ],
+      programId: 'MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8',
+      data: '2f031b61d7ecdb90',
+    },
+  ],
+}

package/src/magiceden/coders.js

@@ -0,0 +1,41 @@
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { snakeCase } from 'lodash'
+import createHash from 'create-hash'
+
+import { bnAmountU64 } from '../vendor/utils/layout'
+
+const idl = {
+  initializeEscrow: {
+    name: 'initializeEscrow',
+    layout: BufferLayout.struct([bnAmountU64('takerAmount')]),
+  },
+  cancelEscrow: {
+    name: 'cancelEscrow',
+    layout: BufferLayout.struct([]),
+  },
+  exchange: {
+    name: 'exchange',
+    layout: BufferLayout.struct([]),
+  },
+}
+
+export function sighash(nameSpace, ixName) {
+  let name = snakeCase(ixName)
+  let preimage = `${nameSpace}:${name}`
+
+  return Buffer.from(
+    createHash('sha256')
+      .update(preimage)
+      .digest()
+  ).slice(0, 8)
+}
+
+export function encodeData(name, args = {}) {
+  const idlInstruction = idl[name]
+
+  const buffer = Buffer.alloc(idlInstruction.layout.span)
+  const len = idlInstruction.layout.encode(args, buffer)
+
+  return Buffer.concat([sighash('global', idlInstruction.name), buffer.slice(0, len)])
+}

package/src/magiceden/escrow-program.js

@@ -0,0 +1,171 @@
+import { PublicKey, Transaction, SystemProgram } from '../vendor'
+import { SYSTEM_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants'
+import { encodeData } from './coders'
+
+const PLATFORM_FEES_PROGRAM_ID = new PublicKey('2NZukH2TXpcuZP4htiuT8CFxcaQSWzkkR6kepSWnZ24Q')
+
+export class MagicEdenEscrowProgram {
+  static get programId() {
+    return new PublicKey('MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8')
+  }
+
+  static get space() {
+    return 80
+  }
+
+  static initializeEscrow(params) {
+    const {
+      initializerPubkey,
+      initializerDepositTokenPubkey,
+      escrowPubkey,
+      lamports,
+      takerAmount,
+    } = params
+
+    const transaction = new Transaction()
+
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: initializerPubkey,
+        newAccountPubkey: escrowPubkey,
+        lamports: lamports,
+        space: this.space,
+        programId: this.programId,
+      })
+    )
+
+    return transaction.add({
+      keys: [
+        {
+          pubkey: initializerPubkey,
+          isSigner: true,
+          isWritable: false,
+        },
+        {
+          pubkey: initializerDepositTokenPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: escrowPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: TOKEN_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false,
+        },
+      ],
+      programId: this.programId,
+      data: encodeData('initializeEscrow', { takerAmount }),
+    })
+  }
+
+  static cancelEscrow(params) {
+    const { initializerPubkey, initializerDepositTokenPubkey, pdaPubkey, escrowPubkey } = params
+
+    return new Transaction().add({
+      keys: [
+        {
+          pubkey: initializerPubkey,
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: initializerDepositTokenPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: pdaPubkey,
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: escrowPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: TOKEN_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false,
+        },
+      ],
+      programId: this.programId,
+      data: encodeData('cancelEscrow'),
+    })
+  }
+
+  static exchange(params) {
+    const {
+      takerPubkey,
+      initializerDepositTokenPubkey,
+      initializerPubkey,
+      escrowPubkey,
+      pdaPubkey,
+      metadataPubkey,
+      creators,
+    } = params
+
+    const remainingAccounts = creators.map((c) => ({
+      pubkey: new PublicKey(c.address),
+      isWritable: true,
+      isSigner: false,
+    }))
+
+    return new Transaction().add({
+      keys: [
+        {
+          pubkey: takerPubkey,
+          isSigner: true,
+          isWritable: false,
+        },
+        {
+          pubkey: initializerDepositTokenPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: initializerPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: escrowPubkey,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: pdaPubkey,
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: SYSTEM_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: TOKEN_PROGRAM_ID,
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: PLATFORM_FEES_PROGRAM_ID,
+          isSigner: false,
+          isWritable: true,
+        },
+        {
+          pubkey: metadataPubkey,
+          isSigner: false,
+          isWritable: false,
+        },
+        ...remainingAccounts,
+      ],
+      programId: this.programId,
+      data: encodeData('exchange'),
+    })
+  }
+}

package/src/transaction.js

@@ -2,6 +2,7 @@
 import assert from 'assert'
 import bs58 from 'bs58'
 import { get } from 'lodash'
+import assets from '@exodus/assets'
 
 import { getKeyPairFromPrivateKey } from './keypair'
 import { findAssociatedTokenAddress, createStakeAddress } from './encode'
@@ -19,6 +20,7 @@ import {
   Authorized,
   Lockup,
 } from './vendor'
+import { MagicEdenEscrowProgram } from './magiceden/escrow-program'
 import { SEED, STAKE_PROGRAM_ID } from './constants'
 import TOKENS from './tokens'
 
@@ -56,7 +58,8 @@ class Tx {
 
     if (tokenName && !tokenMintAddress) {
       const token = TOKENS.find(({ name }) => name === tokenName)
-      tokenMintAddress = token && token.mintAddress
+      assert(token, `token with tokenName ${tokenName} not found in tokens list`)
+      tokenMintAddress = token.mintAddress
     }
 
     this.txObj = {
@@ -107,7 +110,7 @@ class Tx {
     })
     // const isUnknown = destinationAddressType === null
     // if (isUnknown) throw new Error('Destination SOL balance cannot be zero (address not active)') // cannot initialize without knowing the owner
-    const isSOLaddress = destinationAddressType === 'solana'
+    const isSOLaddress = ['solana', null].includes(destinationAddressType)
     // crete account instruction
     if (isSOLaddress && !isAssociatedTokenAccountActive)
       this.transaction.add(createAssociatedTokenAccount(from, tokenMintAddress, to))
@@ -203,10 +206,90 @@ class Tx {
     return transaction
   }
 
-  static sign(tx, privateKey: Buffer | string) {
+  static magicEdenInitializeEscrow({
+    initializerAddress,
+    initializerDepositTokenAddress,
+    lamports,
+    takerAmount,
+    escrowAccount,
+    recentBlockhash,
+  }) {
+    const initializerPubkey = new PublicKey(initializerAddress)
+    const initializerDepositTokenPubkey = new PublicKey(initializerDepositTokenAddress)
+
+    const transaction = MagicEdenEscrowProgram.initializeEscrow({
+      initializerPubkey,
+      initializerDepositTokenPubkey,
+      escrowPubkey: escrowAccount.publicKey,
+      lamports,
+      takerAmount: assets.solana.currency.baseUnit(takerAmount)._number,
+    })
+
+    transaction.recentBlockhash = recentBlockhash
+
+    return transaction
+  }
+
+  static magicEdenCancelEscrow({
+    initializerAddress,
+    initializerDepositTokenAddress,
+    escrowAddress,
+    pdaAddress,
+    recentBlockhash,
+  }) {
+    const initializerPubkey = new PublicKey(initializerAddress)
+    const initializerDepositTokenPubkey = new PublicKey(initializerDepositTokenAddress)
+    const escrowPubkey = new PublicKey(escrowAddress)
+    const pdaPubkey = new PublicKey(pdaAddress)
+
+    const transaction = MagicEdenEscrowProgram.cancelEscrow({
+      initializerPubkey,
+      initializerDepositTokenPubkey,
+      escrowPubkey,
+      pdaPubkey,
+    })
+
+    transaction.recentBlockhash = recentBlockhash
+
+    return transaction
+  }
+
+  static magicEdenExchange({
+    takerAddress,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    escrowAddress,
+    pdaAddress,
+    metadataAddress,
+    creators,
+    recentBlockhash,
+  }) {
+    const takerPubkey = new PublicKey(takerAddress)
+    const initializerPubkey = new PublicKey(initializerAddress)
+    const initializerDepositTokenPubkey = new PublicKey(initializerDepositTokenAddress)
+    const escrowPubkey = new PublicKey(escrowAddress)
+    const pdaPubkey = new PublicKey(pdaAddress)
+    const metadataPubkey = new PublicKey(metadataAddress)
+
+    const transaction = MagicEdenEscrowProgram.exchange({
+      takerPubkey,
+      initializerPubkey,
+      initializerDepositTokenPubkey,
+      escrowPubkey,
+      pdaPubkey,
+      metadataPubkey,
+      creators,
+    })
+
+    transaction.recentBlockhash = recentBlockhash
+
+    return transaction
+  }
+
+  static sign(tx, privateKey: Buffer | string, extraSigners: Account[] = []) {
     if (!privateKey) throw new Error('Please provide a secretKey')
     const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-    const signers = [new Account(secretKey)]
+    const signers = [new Account(secretKey), ...extraSigners]
 
     let transaction = tx
     if (tx instanceof Tx) transaction = tx.transaction

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

@@ -13,11 +13,22 @@ export function createUnsignedTx({
   destinationAddressType,
   isAssociatedTokenAccountActive, // true when recipient balance !== 0
   fromTokenAddresses, // sender token addresses
-  // Staking related:
+  // Program interactions:
   method,
+  // Staking related:
   stakeAddresses,
   seed,
   pool,
+  // MagicEden escrow/related:
+  initializerAddress,
+  initializerDepositTokenAddress,
+  lamports,
+  takerAmount,
+  escrowAddress,
+  pdaAddress,
+  takerAddress,
+  metadataAddress,
+  creators,
 }: ParsedTransaction): UnsignedTransaction {
   return {
     txData: {
@@ -37,6 +48,16 @@ export function createUnsignedTx({
       stakeAddresses,
       seed,
       pool,
+      // MagicEden escrow/related:
+      initializerAddress,
+      initializerDepositTokenAddress,
+      lamports,
+      takerAmount: takerAmount ? takerAmount.toBaseString() : null,
+      escrowAddress,
+      pdaAddress,
+      takerAddress,
+      metadataAddress,
+      creators,
     },
     txMeta: {
       assetName: asset.name,

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

@@ -16,6 +16,15 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
     stakeAddresses,
     seed,
     pool,
+    initializerAddress,
+    initializerDepositTokenAddress,
+    lamports,
+    takerAmount,
+    escrowAddress,
+    pdaAddress,
+    takerAddress,
+    metadataAddress,
+    creators,
     ...txData
   } = unsignedTx.txData
 
@@ -39,5 +48,15 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
     stakeAddresses,
     seed,
     pool,
+    // MagicEden escrow/related:
+    initializerAddress,
+    initializerDepositTokenAddress,
+    lamports,
+    takerAmount: asset.currency.baseUnit(txData.takerAmount),
+    escrowAddress,
+    pdaAddress,
+    takerAddress,
+    metadataAddress,
+    creators,
   }
 }

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

@@ -1,6 +1,7 @@
 import assets from '@exodus/assets'
 import type { UnsignedTransaction, SignedTransaction } from '@exodus/models/lib/types'
-import { Transaction } from '../'
+import { Account } from '../vendor'
+import { Transaction, generateKeyPair } from '../'
 
 export function signUnsignedTx(
   unsignedTx: UnsignedTransaction,
@@ -22,6 +23,16 @@ export function signUnsignedTx(
     method,
     seed,
     pool,
+    // MagicEden escrow/related:
+    initializerAddress,
+    initializerDepositTokenAddress,
+    lamports,
+    takerAmount,
+    escrowAddress,
+    pdaAddress,
+    takerAddress,
+    metadataAddress,
+    creators,
   } = unsignedTx.txData
 
   const asset = assets.solana
@@ -30,6 +41,7 @@ export function signUnsignedTx(
   const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
 
   let tx
+  const extraSigners = []
   switch (method) {
     case 'delegate':
       tx = Transaction.createStakeAccountTransaction({
@@ -55,6 +67,42 @@ export function signUnsignedTx(
         recentBlockhash,
       })
       break
+    case 'initializeEscrow': {
+      const escrowAccount = new Account(generateKeyPair().secretKey)
+
+      tx = Transaction.magicEdenInitializeEscrow({
+        initializerAddress,
+        initializerDepositTokenAddress,
+        lamports,
+        takerAmount,
+        escrowAccount,
+        recentBlockhash,
+      })
+
+      extraSigners.push(escrowAccount)
+      break
+    }
+    case 'cancelEscrow':
+      tx = Transaction.magicEdenCancelEscrow({
+        initializerAddress,
+        initializerDepositTokenAddress,
+        escrowAddress,
+        pdaAddress,
+        recentBlockhash,
+      })
+      break
+    case 'exchange':
+      tx = Transaction.magicEdenExchange({
+        takerAddress,
+        initializerAddress,
+        initializerDepositTokenAddress,
+        escrowAddress,
+        pdaAddress,
+        metadataAddress,
+        creators,
+        recentBlockhash,
+      })
+      break
     default:
       // SOL and Token tx
       tx = new Transaction({
@@ -72,7 +120,7 @@ export function signUnsignedTx(
   }
 
   // sign plain tx
-  Transaction.sign(tx, privateKey)
+  Transaction.sign(tx, privateKey, extraSigners)
   const rawTx = Transaction.serialize(tx)
   const txId = Transaction.getTxId(tx)
 

package/src/vendor/utils/layout.js

@@ -1,5 +1,5 @@
 // @flow
-
+import BN from 'bn.js'
 import * as BufferLayout from '@exodus/buffer-layout'
 
 /**
@@ -67,6 +67,23 @@ export const lockup = (property: string = 'lockup') => {
   )
 }
 
+export const bnAmountU64 = (property: string) => {
+  const rsl = BufferLayout.blob(8, property)
+
+  const _decode = rsl.decode.bind(rsl)
+  const _encode = rsl.encode.bind(rsl)
+
+  rsl.decode = (b, offset = 0) => {
+    return new BN(_decode(b, offset), 10, 'le')
+  }
+
+  rsl.encode = (src, b, offset = 0) => {
+    return _encode(src.toArrayLike(Buffer, 'le', 8), b, offset)
+  }
+
+  return rsl
+}
+
 export function getAlloc(type: Object, fields: Object): number {
   let alloc = 0
   type.layout.fields.forEach((item) => {