@exodus/solana-lib 1.2.1 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.2.1",
+  "version": "1.2.4",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -15,12 +15,12 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.4.3",
     "@exodus/assets": "^8.0.0",
+    "@exodus/buffer-layout": "^1.2.0-exodus1",
     "@exodus/models": "^8.4.0",
-    "@exodus/solana-spl-token": "^0.0.13-exodus1",
-    "@exodus/solana-web3.js": "^0.87.1-exodus4",
     "bn.js": "~4.11.0",
     "bs58": "~4.0.1",
+    "create-hash": "~1.1.3",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "51f71e5bcebd886116bf433c8fe79859a185d16c"
+  "gitHead": "f5a2d444a2789ca118671566f32805dba061ce5a"
 }

package/src/constants.js

@@ -1,7 +1,8 @@
-import { PublicKey, SystemProgram } from '@exodus/solana-web3.js'
-export { TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
+import { PublicKey, SystemProgram } from './vendor'
 
 export const SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID = new PublicKey(
   'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'
 )
 export const SYSTEM_PROGRAM_ID = SystemProgram.programId
+
+export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')

package/src/encode.js

@@ -1,7 +1,6 @@
 // @flow
-import { PublicKey } from '@exodus/solana-web3.js'
-import { TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
-import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID } from './constants'
+import { PublicKey } from './vendor'
+import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_PROGRAM_ID } from './constants'
 import { getPublicKey } from './keypair'
 import bs58 from 'bs58'
 import BN from 'bn.js'

package/src/helpers/spl-token.js

@@ -0,0 +1,108 @@
+import assert from 'assert'
+import BN from 'bn.js'
+import * as BufferLayout from '@exodus/buffer-layout'
+import { Account, PublicKey, 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
+
+/**
+ * 64-bit value
+ */
+export class U64 extends BN {
+  /**
+   * Convert to Buffer representation
+   */
+  toBuffer(): typeof Buffer {
+    const a = super.toArray().reverse()
+    const b = Buffer.from(a)
+    if (b.length === 8) {
+      return b
+    }
+    assert(b.length < 8, 'u64 too large')
+
+    const zeroPad = Buffer.alloc(8)
+    b.copy(zeroPad)
+    return zeroPad
+  }
+
+  /**
+   * Construct a u64 from Buffer representation
+   */
+  static fromBuffer(buffer: typeof Buffer): U64 {
+    assert(buffer.length === 8, `Invalid buffer length: ${buffer.length}`)
+    return new U64(
+      [...buffer]
+        .reverse()
+        .map((i) => `00${i.toString(16)}`.slice(-2))
+        .join(''),
+      16
+    )
+  }
+}
+
+const u64 = U64 // alias
+
+/**
+ * An ERC20-like Token
+ */
+export class Token {
+  /**
+   * Construct a Transfer instruction
+   *
+   * @param programId SPL Token program account
+   * @param source Source account
+   * @param destination Destination account
+   * @param owner Owner of the source account
+   * @param multiSigners Signing accounts if `authority` is a multiSig
+   * @param amount Number of tokens to transfer
+   */
+  static createTransferInstruction(
+    programId: PublicKey,
+    source: PublicKey,
+    destination: PublicKey,
+    owner: PublicKey,
+    multiSigners: Array<Account>,
+    amount: number | u64
+  ): TransactionInstruction {
+    const dataLayout = BufferLayout.struct([
+      BufferLayout.u8('instruction'),
+      Layout.uint64('amount'),
+    ])
+
+    const data = Buffer.alloc(dataLayout.span)
+    dataLayout.encode(
+      {
+        instruction: 3, // Transfer instruction
+        amount: new U64(amount).toBuffer(),
+      },
+      data
+    )
+
+    let keys = [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: destination, 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: programId,
+      data,
+    })
+  }
+}

package/src/{helpers.js → helpers/tokenTransfer.js}

@@ -1,12 +1,7 @@
-import {
-  PublicKey,
-  TransactionInstruction,
-  SystemProgram,
-  SYSVAR_RENT_PUBKEY,
-} from '@exodus/solana-web3.js'
-import { Token, TOKEN_PROGRAM_ID } from '@exodus/solana-spl-token'
-import { SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID } from './constants'
-import { findAssociatedTokenAddress } from './encode'
+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'
 
 // https://github.com/paul-schaaf/spl-token-ui/blob/main/src/solana/token/associatedToken.ts#L59
 export const createAssociatedTokenAccount = (

package/src/transaction.js

@@ -1,9 +1,12 @@
 // @flow
 import assert from 'assert'
 
-import { Account, SystemProgram, Transaction, PublicKey } from '@exodus/solana-web3.js'
 import { getKeyPairFromPrivateKey } from './keypair'
-import { createAssociatedTokenAccount, createTokenTransferInstruction } from './helpers'
+import {
+  createAssociatedTokenAccount,
+  createTokenTransferInstruction,
+} from './helpers/tokenTransfer'
+import { PublicKey, Account, Transaction, SystemProgram } from './vendor'
 import TOKENS from './tokens'
 import bs58 from 'bs58'
 

package/src/vendor/account.js

@@ -0,0 +1,38 @@
+// @flow
+import type { KeyPair } from 'tweetnacl'
+import { PublicKey } from './publickey'
+import { getKeyPairFromPrivateKey } from '../keypair'
+
+/**
+ * An account key pair (public and secret keys).
+ */
+export class Account {
+  _keypair: KeyPair
+
+  /**
+   * Create a new Account object
+   *
+   * @param secretKey Secret key for the account
+   */
+  constructor(secretKey: Buffer | Uint8Array | Array<number>) {
+    if (secretKey) {
+      this._keypair = getKeyPairFromPrivateKey(Buffer.from(secretKey, 'hex'))
+    } else {
+      throw new Error('Please provide a secretKey')
+    }
+  }
+
+  /**
+   * The public key for this account
+   */
+  get publicKey(): PublicKey {
+    return new PublicKey(this._keypair.publicKey)
+  }
+
+  /**
+   * The **unencrypted** secret key for this account
+   */
+  get secretKey(): Buffer {
+    return this._keypair.secretKey
+  }
+}

package/src/vendor/index.js

@@ -0,0 +1,8 @@
+export * from './account'
+export * from './instruction'
+export * from './message'
+export * from './nonce-account'
+export * from './publickey'
+export * from './system-program'
+export * from './sysvar'
+export * from './transaction'

package/src/vendor/instruction.js

@@ -0,0 +1,46 @@
+// @flow
+
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import * as Layout from './utils/layout'
+
+/**
+ * @typedef {Object} InstructionType
+ * @property (index} The Instruction index (from solana upstream program)
+ * @property (BufferLayout} The BufferLayout to use to build data
+ */
+export type InstructionType = {|
+  index: number,
+  layout: typeof BufferLayout,
+|}
+
+/**
+ * Populate a buffer of instruction data using an InstructionType
+ */
+export function encodeData(type: InstructionType, fields: Object): Buffer {
+  const allocLength = type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields)
+  const data = Buffer.alloc(allocLength)
+  const layoutFields = Object.assign({ instruction: type.index }, fields)
+  type.layout.encode(layoutFields, data)
+  return data
+}
+
+/**
+ * Decode instruction data buffer using an InstructionType
+ */
+export function decodeData(type: InstructionType, buffer: Buffer): Object {
+  let data
+  try {
+    data = type.layout.decode(buffer)
+  } catch (err) {
+    throw new Error('invalid instruction; ' + err)
+  }
+
+  if (data.instruction !== type.index) {
+    throw new Error(
+      `invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`
+    )
+  }
+
+  return data
+}

package/src/vendor/message.js

@@ -0,0 +1,216 @@
+// @flow
+
+import bs58 from 'bs58'
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { PublicKey } from './publickey'
+import type { Blockhash } from './utils/blockhash'
+import * as Layout from './utils/layout'
+import { PACKET_DATA_SIZE } from './transaction'
+import * as shortvec from './utils/shortvec-encoding'
+
+/**
+ * The message header, identifying signed and read-only account
+ *
+ * @typedef {Object} MessageHeader
+ * @property {number} numRequiredSignatures The number of signatures required for this message to be considered valid. The
+ * signatures must match the first `numRequiredSignatures` of `accountKeys`.
+ * @property {number} numReadonlySignedAccounts: The last `numReadonlySignedAccounts` of the signed keys are read-only accounts
+ * @property {number} numReadonlyUnsignedAccounts The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts
+ */
+export type MessageHeader = {
+  numRequiredSignatures: number,
+  numReadonlySignedAccounts: number,
+  numReadonlyUnsignedAccounts: number,
+}
+
+/**
+ * An instruction to execute by a program
+ *
+ * @typedef {Object} CompiledInstruction
+ * @property {number} programIdIndex Index into the transaction keys array indicating the program account that executes this instruction
+ * @property {number[]} accounts Ordered indices into the transaction keys array indicating which accounts to pass to the program
+ * @property {string} data The program input data encoded as base 58
+ */
+export type CompiledInstruction = {
+  programIdIndex: number,
+  accounts: number[],
+  data: string,
+}
+
+/**
+ * Message constructor arguments
+ *
+ * @typedef {Object} MessageArgs
+ * @property {MessageHeader} header The message header, identifying signed and read-only `accountKeys`
+ * @property {string[]} accounts All the account keys used by this transaction
+ * @property {Blockhash} recentBlockhash The hash of a recent ledger block
+ * @property {CompiledInstruction[]} instructions Instructions that will be executed in sequence and committed in one atomic transaction if all succeed.
+ */
+type MessageArgs = {
+  header: MessageHeader,
+  accountKeys: string[],
+  recentBlockhash: Blockhash,
+  instructions: CompiledInstruction[],
+}
+
+const PUBKEY_LENGTH = 32
+
+/**
+ * List of instructions to be processed atomically
+ */
+export class Message {
+  header: MessageHeader
+  accountKeys: PublicKey[]
+  recentBlockhash: Blockhash
+  instructions: CompiledInstruction[]
+
+  constructor(args: MessageArgs) {
+    this.header = args.header
+    this.accountKeys = args.accountKeys.map((account) => new PublicKey(account))
+    this.recentBlockhash = args.recentBlockhash
+    this.instructions = args.instructions
+  }
+
+  isAccountWritable(index: number): boolean {
+    return (
+      index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts ||
+      (index >= this.header.numRequiredSignatures &&
+        index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts)
+    )
+  }
+
+  findSignerIndex(signer: PublicKey): number {
+    const index = this.accountKeys.findIndex((accountKey) => {
+      return accountKey.equals(signer)
+    })
+    if (index < 0) {
+      throw new Error(`unknown signer: ${signer.toString()}`)
+    }
+    return index
+  }
+
+  serialize(): Buffer {
+    const numKeys = this.accountKeys.length
+
+    let keyCount = []
+    shortvec.encodeLength(keyCount, numKeys)
+
+    const instructions = this.instructions.map((instruction) => {
+      const { accounts, programIdIndex } = instruction
+      const data = bs58.decode(instruction.data)
+
+      let keyIndicesCount = []
+      shortvec.encodeLength(keyIndicesCount, accounts.length)
+
+      let dataCount = []
+      shortvec.encodeLength(dataCount, data.length)
+
+      return {
+        programIdIndex,
+        keyIndicesCount: Buffer.from(keyIndicesCount),
+        keyIndices: Buffer.from(accounts),
+        dataLength: Buffer.from(dataCount),
+        data,
+      }
+    })
+
+    let instructionCount = []
+    shortvec.encodeLength(instructionCount, instructions.length)
+    let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE)
+    Buffer.from(instructionCount).copy(instructionBuffer)
+    let instructionBufferLength = instructionCount.length
+
+    instructions.forEach((instruction) => {
+      const instructionLayout = BufferLayout.struct([
+        BufferLayout.u8('programIdIndex'),
+
+        BufferLayout.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'),
+        BufferLayout.seq(BufferLayout.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'),
+        BufferLayout.blob(instruction.dataLength.length, 'dataLength'),
+        BufferLayout.seq(BufferLayout.u8('userdatum'), instruction.data.length, 'data'),
+      ])
+      const length = instructionLayout.encode(
+        instruction,
+        instructionBuffer,
+        instructionBufferLength
+      )
+      instructionBufferLength += length
+    })
+    instructionBuffer = instructionBuffer.slice(0, instructionBufferLength)
+
+    const signDataLayout = BufferLayout.struct([
+      BufferLayout.blob(1, 'numRequiredSignatures'),
+      BufferLayout.blob(1, 'numReadonlySignedAccounts'),
+      BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'),
+      BufferLayout.blob(keyCount.length, 'keyCount'),
+      BufferLayout.seq(Layout.publicKey('key'), numKeys, 'keys'),
+      Layout.publicKey('recentBlockhash'),
+    ])
+
+    const transaction = {
+      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
+      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
+      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
+      keyCount: Buffer.from(keyCount),
+      keys: this.accountKeys.map((key) => key.toBuffer()),
+      recentBlockhash: bs58.decode(this.recentBlockhash),
+    }
+
+    let signData = Buffer.alloc(2048)
+    const length = signDataLayout.encode(transaction, signData)
+    instructionBuffer.copy(signData, length)
+    return signData.slice(0, length + instructionBuffer.length)
+  }
+
+  /**
+   * Decode a compiled message into a Message object.
+   */
+  static from(buffer: Buffer | Uint8Array | Array<number>): Message {
+    // Slice up wire data
+    let byteArray = [...buffer]
+
+    const numRequiredSignatures = byteArray.shift()
+    const numReadonlySignedAccounts = byteArray.shift()
+    const numReadonlyUnsignedAccounts = byteArray.shift()
+
+    const accountCount = shortvec.decodeLength(byteArray)
+    let accountKeys = []
+    for (let i = 0; i < accountCount; i++) {
+      const account = byteArray.slice(0, PUBKEY_LENGTH)
+      byteArray = byteArray.slice(PUBKEY_LENGTH)
+      accountKeys.push(bs58.encode(Buffer.from(account)))
+    }
+
+    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH)
+    byteArray = byteArray.slice(PUBKEY_LENGTH)
+
+    const instructionCount = shortvec.decodeLength(byteArray)
+    let instructions = []
+    for (let i = 0; i < instructionCount; i++) {
+      let instruction = {}
+      instruction.programIdIndex = byteArray.shift()
+      const accountCount = shortvec.decodeLength(byteArray)
+      instruction.accounts = byteArray.slice(0, accountCount)
+      byteArray = byteArray.slice(accountCount)
+      const dataLength = shortvec.decodeLength(byteArray)
+      const data = byteArray.slice(0, dataLength)
+      instruction.data = bs58.encode(Buffer.from(data))
+      byteArray = byteArray.slice(dataLength)
+      instructions.push(instruction)
+    }
+
+    const messageArgs = {
+      header: {
+        numRequiredSignatures,
+        numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts,
+      },
+      recentBlockhash: bs58.encode(Buffer.from(recentBlockhash)),
+      accountKeys,
+      instructions,
+    }
+
+    return new Message(messageArgs)
+  }
+}

package/src/vendor/nonce-account.js

@@ -0,0 +1,46 @@
+// @flow
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { PublicKey } from './publickey'
+import type { Blockhash } from './utils/blockhash'
+import * as Layout from './utils/layout'
+import type { FeeCalculator } from './utils/fee-calculator'
+import { FeeCalculatorLayout } from './utils/fee-calculator'
+import { toBuffer } from './utils/to-buffer'
+
+/**
+ * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32
+ *
+ * @private
+ */
+const NonceAccountLayout = BufferLayout.struct([
+  BufferLayout.u32('version'),
+  BufferLayout.u32('state'),
+  Layout.publicKey('authorizedPubkey'),
+  Layout.publicKey('nonce'),
+  BufferLayout.struct([FeeCalculatorLayout], 'feeCalculator'),
+])
+
+export const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span
+
+/**
+ * NonceAccount class
+ */
+export class NonceAccount {
+  authorizedPubkey: PublicKey
+  nonce: Blockhash
+  feeCalculator: FeeCalculator
+
+  /**
+   * Deserialize NonceAccount from the account data.
+   *
+   * @param buffer account data
+   * @return NonceAccount
+   */
+  static fromAccountData(buffer: Buffer | Uint8Array | Array<number>): NonceAccount {
+    const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0)
+    nonceAccount.authorizedPubkey = new PublicKey(nonceAccount.authorizedPubkey)
+    nonceAccount.nonce = new PublicKey(nonceAccount.nonce).toString()
+    return nonceAccount
+  }
+}