@exodus/solana-lib 1.6.1 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.6.1",
+  "version": "1.6.4",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -14,9 +14,9 @@
   },
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
-    "@exodus/assets": "^8.0.74",
     "@exodus/buffer-layout": "^1.2.0-exodus1",
     "@exodus/models": "^8.10.4",
+    "@exodus/solana-meta": "^1.0.2",
     "@exodus/solana-spl-token": "0.1.8-exodus.1",
     "@project-serum/serum": "0.13.64",
     "bn.js": "^4.11.0",
@@ -26,5 +26,5 @@
     "lodash": "^4.17.11",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "145ae526c51aefa39ffda8c63c70b30724aa9881"
+  "gitHead": "123d67b94e313496373a6ec97447361bb6bec6d7"
 }

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/fee-data/solana.js

@@ -1,5 +1,5 @@
 import { FeeData } from '@exodus/asset-lib'
-import assets from '@exodus/assets'
+import { asset } from '@exodus/solana-meta'
 
 export default new FeeData({
   config: {
@@ -7,5 +7,5 @@ export default new FeeData({
     fuelThreshold: '0.000015 SOL',
   },
   mainKey: 'fee',
-  currency: assets.solana.currency,
+  currency: asset.currency,
 })

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/parse-unsigned-tx.js

@@ -1,8 +1,7 @@
-import assets from '@exodus/assets'
+import { asset } from '@exodus/solana-meta'
 import type { UnsignedTransaction, ParsedTransaction } from '@exodus/models/lib/types'
 
 export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransaction {
-  const asset = assets.solana
   const {
     from,
     to,
@@ -32,7 +31,6 @@ export function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransact
   const amount = asset.currency.baseUnit(txData.amount)
   const fee = asset.currency.baseUnit(txData.fee)
   return {
-    asset,
     from: [from],
     to,
     amount,

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

@@ -1,8 +1,8 @@
-import { merge } from 'lodash'
-import assets from '@exodus/assets'
+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,
@@ -14,17 +14,12 @@ export function signUnsignedTx(
     return _signTx({ tx: transaction, privateKey })
   }
 
-  const asset = assets.solana
   const address = from
   const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount
 
-  const args = merge(unsignedTx.txData, {
-    asset,
-    address,
-    amount,
-  })
+  const txData = { ...unsignedTx.txData, address, amount }
 
-  const tx = createTx({ txData: args, method })
+  const tx = createTx({ txData, method })
   return _signTx({ tx, privateKey })
 }
 
@@ -64,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

@@ -12,15 +12,17 @@ export function getTransactionSimulationParams(transactionMessage) {
     commitment: 'confirmed',
   }
 
-  let accountAddresses = []
+  const accountAddresses = new Set()
+
   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.push(key.pubkey.toString())
+          accountAddresses.add(key.pubkey.toString())
         }
       })
     })
@@ -35,19 +37,19 @@ export function getTransactionSimulationParams(transactionMessage) {
       )
     }
 
-    accountAddresses = transactionMessage.accountKeys
+    transactionMessage.accountKeys
       .filter((_, index) => !indexToProgramIds.has(index))
-      .map((account) => account.toString())
+      .forEach((account) => accountAddresses.add(account.toString()))
   }
 
   config['accounts'] = {
     encoding: 'base64',
-    addresses: accountAddresses,
+    addresses: Array.from(accountAddresses),
   }
 
   return {
     config,
-    accountAddresses,
+    accountAddresses: Array.from(accountAddresses),
   }
 }