@exodus/solana-lib 1.6.3 → 1.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -26,5 +26,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "a7b27e4f299057c16dda446f006fa61a945a6cbf"
+  "gitHead": "44fca2a6ee944fb8e96c0a8918845b1dc7cc5242"
 }

package/src/constants.js

@@ -15,6 +15,14 @@ export const MAGIC_EDEN_ESCROW_PROGRAM_ID = new PublicKey(
   'MEisE1HzehtrDpAAT8PnLHjpSSkRYakotTuJRPjTpo8'
 )
 
+export const MPL_TOKEN_METADATA_PROGRAM_ID = new PublicKey(
+  'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s'
+)
+
+export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
+  'Sysvar1nstructions1111111111111111111111111'
+)
+
 export const SEED = 'stake:0'
 
 export const LAMPORTS_PER_SOL = 1000000000

package/src/encode.js

@@ -1,7 +1,12 @@
 // @flow
 import assert from 'assert'
 import { PublicKey, StakeProgram } from './vendor'
-import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID, SEED } from './constants'
+import {
+  SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  SEED,
+  MPL_TOKEN_METADATA_PROGRAM_ID,
+} from './constants'
 import { getPublicKey, getKeyPairFromPrivateKey } from './keypair'
 import bs58 from 'bs58'
 import BN from 'bn.js'
@@ -87,19 +92,45 @@ export function createStakeAddress(walletAddress: string, seed = SEED): string {
 
 // get Metaplex Metadata account
 export function getMetadataAccount(tokenMintAddress: string): string {
-  const METADATA_PROGRAM_ID = 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s'
   const METADATA_PREFIX = 'metadata'
 
   return PublicKey.findProgramAddress(
     [
       Buffer.from(METADATA_PREFIX),
-      new PublicKey(METADATA_PROGRAM_ID).toBuffer(),
+      MPL_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
       new PublicKey(tokenMintAddress).toBuffer(),
     ],
-    new PublicKey(METADATA_PROGRAM_ID)
+    MPL_TOKEN_METADATA_PROGRAM_ID
   )[0].toBase58() // returns encoded PublicKey
 }
 
+// metaplex NFT Master Edition PDA
+export function getMasterEditionPDA(tokenMintAddress: string): string {
+  return PublicKey.findProgramAddress(
+    [
+      Buffer.from('metadata', 'utf8'),
+      MPL_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      new PublicKey(tokenMintAddress).toBuffer(),
+      Buffer.from('edition', 'utf8'),
+    ],
+    MPL_TOKEN_METADATA_PROGRAM_ID
+  )[0].toBase58()
+}
+
+// metaplex TokenRecord PDA
+export function getTokenRecordPDA(tokenMintAddress: string, token: string): string {
+  return PublicKey.findProgramAddress(
+    [
+      Buffer.from('metadata', 'utf8'),
+      MPL_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      new PublicKey(tokenMintAddress).toBuffer(),
+      Buffer.from('token_record', 'utf8'),
+      new PublicKey(token).toBuffer(),
+    ],
+    MPL_TOKEN_METADATA_PROGRAM_ID
+  )[0].toBase58()
+}
+
 export function deserializeMetaplexMetadata(rawData: Buffer) {
   const metadata = deserializeUnchecked(METADATA_SCHEMA, Metadata, rawData)
 

package/src/helpers/metaplex-transfer.js

@@ -0,0 +1,222 @@
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { Transaction, PublicKey, TransactionInstruction } from '../vendor'
+import {
+  MPL_TOKEN_METADATA_PROGRAM_ID,
+  SYSTEM_PROGRAM_ID,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  TOKEN_PROGRAM_ID,
+} from '../constants'
+
+import { ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import {
+  findAssociatedTokenAddress,
+  getMasterEditionPDA,
+  getMetadataAccount,
+  getTokenRecordPDA,
+} from '../encode'
+
+const TRANSFER_INSTRUCTION_DISCRIMINATOR = 49
+const TOKEN_AUTH_RULES_ID = new PublicKey('auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg')
+
+export const TOKEN_STANDARD = {
+  NonFungible: 0,
+  FungibleAsset: 1,
+  Fungible: 2,
+  NonFungibleEdition: 3,
+  ProgrammableNonFungible: 4,
+}
+
+export const AUTHORITY_TYPE = {
+  None: 0,
+  Metadata: 1,
+  Holder: 2,
+  MetadataDelegate: 3,
+  TokenDelegate: 4,
+}
+
+export const prepareMetaplexTransferTx = ({
+  token,
+  tokenOwner,
+  destination,
+  destinationOwner,
+  mint,
+  metadata,
+  edition,
+  ownerTokenRecord,
+  destinationTokenRecord,
+  authority,
+  payer,
+  authorizationRulesProgram,
+  authorizationRules,
+  amount,
+  authorityType,
+  programId = MPL_TOKEN_METADATA_PROGRAM_ID,
+}) => {
+  const transaction = new Transaction()
+  const data = encodeData({ amount, authorityType })
+  const keys = [
+    {
+      pubkey: token,
+      isWritable: true,
+      isSigner: false,
+    },
+    {
+      pubkey: tokenOwner,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: destination,
+      isWritable: true,
+      isSigner: false,
+    },
+    {
+      pubkey: destinationOwner,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: mint,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: metadata,
+      isWritable: true,
+      isSigner: false,
+    },
+    {
+      pubkey: edition ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: ownerTokenRecord ?? programId,
+      isWritable: ownerTokenRecord != null,
+      isSigner: false,
+    },
+    {
+      pubkey: destinationTokenRecord ?? programId,
+      isWritable: destinationTokenRecord != null,
+      isSigner: false,
+    },
+    {
+      pubkey: authority,
+      isWritable: false,
+      isSigner: true,
+    },
+    {
+      pubkey: payer,
+      isWritable: true,
+      isSigner: true,
+    },
+    {
+      pubkey: SYSTEM_PROGRAM_ID,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: SYSVAR_INSTRUCTIONS_PUBKEY,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: TOKEN_PROGRAM_ID,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: authorizationRulesProgram ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+    {
+      pubkey: authorizationRules ?? programId,
+      isWritable: false,
+      isSigner: false,
+    },
+  ]
+
+  transaction.add(
+    new TransactionInstruction({
+      programId,
+      keys,
+      data,
+    })
+  )
+
+  return transaction
+}
+
+export function createMetaplexTransferTransaction({
+  from,
+  to,
+  tokenMintAddress,
+  tokenStandard,
+  recentBlockhash,
+  amount = 1,
+}) {
+  const fromAccount = findAssociatedTokenAddress(from, tokenMintAddress)
+
+  const toAccount = findAssociatedTokenAddress(to, tokenMintAddress)
+
+  const metadata = getMetadataAccount(tokenMintAddress)
+  const edition = getMasterEditionPDA(tokenMintAddress)
+  const ownerTokenRecord = getTokenRecordPDA(tokenMintAddress, fromAccount)
+  const destinationTokenRecord = getTokenRecordPDA(tokenMintAddress, toAccount)
+  const isProgrammable = tokenStandard === TOKEN_STANDARD.ProgrammableNonFungible
+
+  const transaction = prepareMetaplexTransferTx({
+    token: new PublicKey(fromAccount),
+    tokenOwner: new PublicKey(from),
+    destination: new PublicKey(toAccount),
+    destinationOwner: new PublicKey(to),
+    mint: new PublicKey(tokenMintAddress),
+    metadata: new PublicKey(metadata),
+    edition: new PublicKey(edition),
+    ownerTokenRecord: isProgrammable ? new PublicKey(ownerTokenRecord) : undefined,
+    destinationTokenRecord: isProgrammable ? new PublicKey(destinationTokenRecord) : undefined,
+    authority: new PublicKey(from),
+    payer: new PublicKey(from),
+    authorizationRulesProgram: TOKEN_AUTH_RULES_ID,
+    amount,
+  })
+
+  transaction.recentBlockhash = recentBlockhash
+
+  return transaction
+}
+
+export function encodeData({ amount, authorityType }) {
+  const TransferArgsV1 = BufferLayout.struct(
+    [
+      BufferLayout.u8('variant'), // For variant 'V1' of TransferArgs
+      BufferLayout.nu64('amount'),
+      BufferLayout.u8('authorizationData'),
+    ],
+    'transferArgs'
+  )
+
+  const TransferInstructionLayout = BufferLayout.struct([
+    BufferLayout.u8('instructionDiscriminator'),
+    TransferArgsV1,
+  ])
+
+  const buffer = Buffer.alloc(TransferInstructionLayout.span)
+  const data = {
+    instructionDiscriminator: TRANSFER_INSTRUCTION_DISCRIMINATOR,
+    transferArgs: {
+      variant: 0, // Variant 'V1' is represented as 0
+      amount,
+    },
+  }
+  TransferInstructionLayout.encode(data, buffer)
+
+  return buffer
+}

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

@@ -12,6 +12,7 @@ export function createUnsignedTx({
   destinationAddressType,
   isAssociatedTokenAccountActive, // true when recipient balance !== 0
   fromTokenAddresses, // sender token addresses
+  tokenStandard,
   // Program interactions:
   method,
   // Staking related:
@@ -46,6 +47,7 @@ export function createUnsignedTx({
       destinationAddressType,
       isAssociatedTokenAccountActive,
       fromTokenAddresses,
+      tokenStandard,
       // Staking related:
       method,
       stakeAddresses,

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

@@ -2,6 +2,7 @@ import { asset } from '@exodus/solana-meta'
 import type { UnsignedTransaction, SignedTransaction } from '@exodus/models/lib/types'
 
 import { Transaction, getTransactionStrategy } from '../'
+import { createMetaplexTransferTransaction } from '../helpers/metaplex-transfer'
 
 export function signUnsignedTx(
   unsignedTx: UnsignedTransaction,
@@ -58,6 +59,9 @@ const createTx = ({ txData, method }) => {
     case 'exchange':
       tx = createMagicEdenExchangeTransaction(txData)
       break
+    case 'metaplexTransfer':
+      tx = createMetaplexTransferTransaction(txData)
+      break
     default:
       // SOL and Token tx
       tx = createTokenTransaction(txData)

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

@@ -14,7 +14,13 @@ export function getTransactionSimulationParams(transactionMessage) {
 
   const accountAddresses = new Set()
 
-  if (!transactionMessage.accountKeys) {
+  // Get account keys from `staticAccountKeys` if it's a versioned transaction
+  // https://solana-labs.github.io/solana-web3.js/classes/Message.html#staticAccountKeys
+  if (transactionMessage.staticAccountKeys) {
+    transactionMessage.staticAccountKeys.forEach((account) =>
+      accountAddresses.add(account.toString())
+    )
+  } else if (!transactionMessage.accountKeys) {
     const programIds = new Set(
       transactionMessage.instructions.map((instruction) => instruction.programId.toString())
     )