@exodus/solana-lib 1.7.4 → 1.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -12,20 +12,27 @@
   "publishConfig": {
     "access": "restricted"
   },
+  "scripts": {
+    "test": "run -T jest",
+    "lint": "run -T eslint ./src",
+    "lint:fix": "yarn lint --fix"
+  },
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/buffer-layout": "^1.2.0-exodus1",
     "@exodus/key-utils": "^3.1.0",
     "@exodus/models": "^10.1.0",
-    "@exodus/solana-meta": "^1.0.5",
-    "@exodus/solana-spl-token": "0.1.8-exodus.1",
+    "@exodus/solana-meta": "^1.0.7",
     "@project-serum/serum": "0.13.64",
     "bn.js": "^4.11.0",
     "borsh": "^0.7.0",
     "bs58": "^4.0.1",
     "create-hash": "^1.1.3",
     "lodash": "^4.17.11",
+    "minimalistic-assert": "^1.0.1",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "88be13b711bcb6ca1be86993d67e69d4ec5ac263"
+  "devDependencies": {
+    "@solana/web3.js": "^1.90.0"
+  }
 }

package/src/constants.js

@@ -25,7 +25,7 @@ export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
 
 export const SEED = 'stake:0'
 
-export const LAMPORTS_PER_SOL = 1000000000
+export const LAMPORTS_PER_SOL = 1_000_000_000
 
 export const SOL_DECIMAL = Math.log10(LAMPORTS_PER_SOL)
 

package/src/encode.js

@@ -12,21 +12,6 @@ import BN from 'bn.js'
 import { Metadata, METADATA_SCHEMA } from './helpers/metadata-schema'
 import { deserializeUnchecked } from 'borsh'
 
-/*
-const { BinaryReader, BinaryWriter, deserializeUnchecked } = require('borsh')
-
-BinaryReader.prototype.readPubkeyAsString = function () {
-  const reader = this
-  const array = reader.readFixedArray(32)
-  return bs58.encode(array)
-}
-
-BinaryWriter.prototype.writePubkeyAsString = function (value) {
-  const writer = this
-  writer.writeFixedArray(bs58.decode(value))
-}
-*/
-
 export function getAddressFromPublicKey(publicKey) {
   return bs58.encode(Buffer.from(publicKey, 'hex'))
 }
@@ -42,12 +27,10 @@ export function isValidAddress(address) {
     if (decoded.length !== 32) {
       return false
     }
+
     const _bn = new BN(decoded)
-    if (_bn.byteLength() > 32) {
-      return false
-    }
-    return true
-  } catch (e) {
+    return _bn.byteLength() <= 32
+  } catch {
     return false
   }
 }

package/src/helpers/metadata-schema.js

@@ -3,15 +3,13 @@
 import bs58 from 'bs58'
 import { BinaryReader, BinaryWriter } from 'borsh'
 
-BinaryReader.prototype.readPubkeyAsString = function() {
-  const reader = this
-  const array = reader.readFixedArray(32)
+BinaryReader.prototype.readPubkeyAsString = function () {
+  const array = this.readFixedArray(32)
   return bs58.encode(array)
 }
 
-BinaryWriter.prototype.writePubkeyAsString = function(value) {
-  const writer = this
-  writer.writeFixedArray(bs58.decode(value))
+BinaryWriter.prototype.writePubkeyAsString = function (value) {
+  this.writeFixedArray(bs58.decode(value))
 }
 
 class Data {

package/src/helpers/metaplex-transfer.js

@@ -8,7 +8,7 @@ import {
   TOKEN_PROGRAM_ID,
 } from '../constants'
 
-import { ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ASSOCIATED_TOKEN_PROGRAM_ID } from './spl-token'
 import {
   findAssociatedTokenAddress,
   getMasterEditionPDA,

package/src/helpers/spl-token.js

@@ -1,11 +1,16 @@
 import assert from 'assert'
 import BN from 'bn.js'
 import * as BufferLayout from '@exodus/buffer-layout'
-import { TransactionInstruction } from '../vendor'
+import { PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from '../vendor'
 import * as Layout from '../vendor/utils/layout'
 
 // Extracted from https://github.com/ExodusMovement/solana-spl-token/blob/master/src/index.js#L263
 
+export const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey(
+  'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'
+)
+export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')
+
 /**
  * 64-bit value
  */
@@ -19,6 +24,7 @@ export class U64 extends BN {
     if (b.length === 8) {
       return b
     }
+
     assert(b.length < 8, 'u64 too large')
 
     const zeroPad = Buffer.alloc(8)
@@ -55,10 +61,406 @@ const uint64 = (property = 'uint64') => {
   return BufferLayout.blob(8, property)
 }
 
+/**
+ * Unfortunately, BufferLayout.encode uses an `instanceof` check for `Buffer`
+ * which fails when using `publicKey.toBuffer()` directly because the bundled `Buffer`
+ * class in `@solana/web3.js` is different from the bundled `Buffer` class in this package
+ */
+const pubkeyToBuffer = (publicKey) => {
+  return Buffer.from(publicKey.toBuffer())
+}
+
 /**
  * An ERC20-like Token
  */
-export class Token {
+export const Token = {
+  /**
+   * Construct an Approve instruction
+   *
+   * @param programId SPL Token program account
+   * @param account Public key of the account
+   * @param delegate Account authorized to perform a transfer of tokens from the source account
+   * @param owner Owner of the source account
+   * @param multiSigners Signing accounts if `owner` is a multiSig
+   * @param amount Maximum number of tokens the delegate may transfer
+   */
+  createApproveInstruction(programId, account, delegate, owner, multiSigners, amount) {
+    const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction'), uint64('amount')])
+    const data = Buffer.alloc(dataLayout.span)
+
+    dataLayout.encode(
+      {
+        instruction: 4, // Approve instruction
+        amount: new U64(amount).toBuffer(),
+      },
+      data
+    )
+
+    const keys = [
+      {
+        pubkey: account,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: delegate,
+        isSigner: false,
+        isWritable: false,
+      },
+    ]
+
+    if (multiSigners.length === 0) {
+      keys.push({
+        pubkey: owner,
+        isSigner: true,
+        isWritable: false,
+      })
+    } else {
+      keys.push({
+        pubkey: owner,
+        isSigner: false,
+        isWritable: false,
+      })
+
+      multiSigners.forEach((signer) =>
+        keys.push({
+          pubkey: signer.publicKey,
+          isSigner: true,
+          isWritable: false,
+        })
+      )
+    }
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
+  /**
+   * Construct the AssociatedTokenProgram instruction to create the associated
+   * token account
+   *
+   * @param associatedProgramId SPL Associated Token program account
+   * @param programId SPL Token program account
+   * @param mint Token mint account
+   * @param associatedAccount New associated account
+   * @param owner Owner of the new account
+   * @param payer Payer of fees
+   */
+  createAssociatedTokenAccountInstruction(
+    associatedProgramId,
+    programId,
+    mint,
+    associatedAccount,
+    owner,
+    payer
+  ) {
+    const data = Buffer.alloc(0)
+
+    const keys = [
+      {
+        pubkey: payer,
+        isSigner: true,
+        isWritable: true,
+      },
+      {
+        pubkey: associatedAccount,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: owner,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: mint,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: SystemProgram.programId,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: programId,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false,
+      },
+    ]
+
+    return new TransactionInstruction({
+      keys,
+      programId: associatedProgramId,
+      data,
+    })
+  },
+
+  /**
+   * Construct a Close instruction
+   *
+   * @param programId SPL Token program account
+   * @param account Account to close
+   * @param dest Account to receive the remaining balance of the closed account
+   * @param authority Account Close authority
+   * @param multiSigners Signing accounts if `owner` is a multiSig
+   */
+  createCloseAccountInstruction(programId, account, dest, owner, multiSigners) {
+    const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction')])
+    const data = Buffer.alloc(dataLayout.span)
+
+    dataLayout.encode(
+      {
+        instruction: 9, // CloseAccount instruction
+      },
+      data
+    )
+
+    const keys = [
+      {
+        pubkey: account,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: dest,
+        isSigner: false,
+        isWritable: true,
+      },
+    ]
+
+    if (multiSigners.length === 0) {
+      keys.push({
+        pubkey: owner,
+        isSigner: true,
+        isWritable: false,
+      })
+    } else {
+      keys.push({
+        pubkey: owner,
+        isSigner: false,
+        isWritable: false,
+      })
+      multiSigners.forEach((signer) =>
+        keys.push({
+          pubkey: signer.publicKey,
+          isSigner: true,
+          isWritable: false,
+        })
+      )
+    }
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
+  /**
+   * Construct an InitializeAccount instruction
+   *
+   * @param programId SPL Token program account
+   * @param mint Token mint account
+   * @param account New account
+   * @param owner Owner of the new account
+   */
+  createInitAccountInstruction(programId, mint, account, owner) {
+    const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction')])
+    const data = Buffer.alloc(dataLayout.span)
+
+    dataLayout.encode(
+      {
+        instruction: 1, // InitializeAccount instruction
+      },
+      data
+    )
+
+    const keys = [
+      {
+        pubkey: account,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: mint,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: owner,
+        isSigner: false,
+        isWritable: false,
+      },
+      {
+        pubkey: SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false,
+      },
+    ]
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
+  /**
+   * Construct an InitializeMint instruction
+   *
+   * @param programId SPL Token program account
+   * @param mint Token mint account
+   * @param decimals Number of decimals in token account amounts
+   * @param mintAuthority Minting authority
+   * @param freezeAuthority Optional authority that can freeze token accounts
+   */
+  createInitMintInstruction(programId, mint, decimals, mintAuthority, freezeAuthority) {
+    const dataLayout = BufferLayout.struct([
+      BufferLayout.u8('instruction'),
+      BufferLayout.u8('decimals'),
+      publicKey('mintAuthority'),
+      BufferLayout.u8('option'),
+      publicKey('freezeAuthority'),
+    ])
+
+    let data = Buffer.alloc(1024)
+    const encodeLength = dataLayout.encode(
+      {
+        instruction: 0, // InitializeMint instruction
+        decimals,
+        mintAuthority: pubkeyToBuffer(mintAuthority),
+        option: freezeAuthority === null ? 0 : 1,
+        freezeAuthority: pubkeyToBuffer(freezeAuthority || new PublicKey(0)),
+      },
+      data
+    )
+    data = data.slice(0, encodeLength)
+
+    const keys = [
+      {
+        pubkey: mint,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false,
+      },
+    ]
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
+  /**
+   * Construct a MintTo instruction
+   *
+   * @param programId SPL Token program account
+   * @param mint Public key of the mint
+   * @param dest Public key of the account to mint to
+   * @param authority The mint authority
+   * @param multiSigners Signing accounts if `authority` is a multiSig
+   * @param amount Amount to mint
+   */
+  createMintToInstruction(programId, mint, dest, authority, multiSigners, amount) {
+    const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction'), uint64('amount')])
+    const data = Buffer.alloc(dataLayout.span)
+
+    dataLayout.encode(
+      {
+        instruction: 7, // MintTo instruction
+        amount: new U64(amount).toBuffer(),
+      },
+      data
+    )
+
+    const keys = [
+      {
+        pubkey: mint,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: dest,
+        isSigner: false,
+        isWritable: true,
+      },
+    ]
+
+    if (multiSigners.length === 0) {
+      keys.push({
+        pubkey: authority,
+        isSigner: true,
+        isWritable: false,
+      })
+    } else {
+      keys.push({
+        pubkey: authority,
+        isSigner: false,
+        isWritable: false,
+      })
+
+      multiSigners.forEach((signer) =>
+        keys.push({
+          pubkey: signer.publicKey,
+          isSigner: true,
+          isWritable: false,
+        })
+      )
+    }
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
+  /**
+   * Construct a SyncNative instruction
+   *
+   * @param programId SPL Token program account
+   * @param nativeAccount Account to sync lamports from
+   */
+  createSyncNativeInstruction(programId, nativeAccount) {
+    const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction')])
+    const data = Buffer.alloc(dataLayout.span)
+
+    dataLayout.encode(
+      {
+        instruction: 17, // SyncNative instruction
+      },
+      data
+    )
+
+    const keys = [
+      {
+        pubkey: nativeAccount,
+        isSigner: false,
+        isWritable: true,
+      },
+    ]
+
+    return new TransactionInstruction({
+      keys,
+      programId,
+      data,
+    })
+  },
+
   /**
    * Construct a Transfer instruction
    *
@@ -69,7 +471,7 @@ export class Token {
    * @param multiSigners Signing accounts if `authority` is a multiSig
    * @param amount Number of tokens to transfer
    */
-  static createTransferInstruction(programId, source, destination, owner, multiSigners, amount) {
+  createTransferInstruction(programId, source, destination, owner, multiSigners, amount) {
     const dataLayout = BufferLayout.struct([
       BufferLayout.u8('instruction'),
       Layout.uint64('amount'),
@@ -84,7 +486,7 @@ export class Token {
       data
     )
 
-    let keys = [
+    const keys = [
       { pubkey: source, isSigner: false, isWritable: true },
       { pubkey: destination, isSigner: false, isWritable: true },
     ]
@@ -104,14 +506,15 @@ export class Token {
         })
       )
     }
+
     return new TransactionInstruction({
       keys,
-      programId: programId,
+      programId,
       data,
     })
-  }
+  },
 
-  static decode(data) {
+  decode(data) {
     return BufferLayout.struct([
       publicKey('mint'),
       publicKey('owner'),
@@ -125,5 +528,5 @@ export class Token {
       BufferLayout.u32('closeAuthorityOption'),
       publicKey('closeAuthority'),
     ]).decode(data)
-  }
+  },
 }

package/src/helpers/tokenTransfer.js

@@ -1,4 +1,4 @@
-import { Token } from '@exodus/solana-spl-token'
+import { Token } from './spl-token'
 import { PublicKey, TransactionInstruction, SystemProgram, SYSVAR_RENT_PUBKEY } from '../vendor'
 import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../constants'
 import { findAssociatedTokenAddress } from '../encode'
@@ -17,14 +17,12 @@ export const createAssociatedTokenAccount = (
   const ownerPublicKey = new PublicKey(ownerAddress)
   const tokenMintPublicKey = new PublicKey(tokenMintAddress)
 
-  const ix = createIx(
+  return createIx(
     feePayerPublicKey, // feePayer
     associatedTokenAccountPublicKey,
     ownerPublicKey,
     tokenMintPublicKey
-  )
-
-  return ix // returns the instruction
+  ) // returns the instruction
 }
 
 function createIx(
@@ -59,7 +57,7 @@ export const createTokenTransferInstruction = (owner, fromTokenAddress, to, amou
   console.log(`destination token address: ${destinationPubkey.toBase58()}`)
   const ownerAccountOrWalletPublicKey = new PublicKey(owner) // the only native SOL address
 
-  const transferIx = Token.createTransferInstruction(
+  return Token.createTransferInstruction(
     TOKEN_PROGRAM_ID,
     sourcePubkey,
     destinationPubkey,
@@ -67,8 +65,6 @@ export const createTokenTransferInstruction = (owner, fromTokenAddress, to, amou
     [],
     amount
   )
-
-  return transferIx
 }
 
 export const createCloseAccountInstruction = ({

package/src/index.js

@@ -11,5 +11,5 @@ export {
   SystemProgram,
 } from './vendor'
 export { default as Transaction } from './transaction'
-export { U64 } from './helpers/spl-token'
+export { U64, Token } from './helpers/spl-token'
 export { createGetKeyIdentifier, getSupportedPurposes } from './key-identifier'