@exodus/solana-lib 1.0.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -15,12 +15,11 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.4.3",
     "@exodus/assets": "^8.0.0",
-    "@exodus/buffer-layout": "^1.2.0-exodus0",
     "@exodus/models": "^8.2.0",
+    "@exodus/solana-web3.js": "^0.87.1-exodus3",
     "bn.js": "~4.11.0",
     "bs58": "~4.0.1",
-    "create-hash": "~1.1.3",
     "tweetnacl": "^1.0.3"
   },
-  "gitHead": "946e63be238d27a4e69b657c9979788e04bccea0"
+  "gitHead": "912e3574f02b1886ed0c6616a7d35f20de533dbd"
 }

package/src/transaction.js

@@ -1,10 +1,8 @@
 // @flow
 import assert from 'assert'
 
-import { Account } from './helpers/account'
-import { SystemProgram } from './helpers/system-program'
-import { Transaction } from './helpers/transaction'
-import { PublicKey } from './helpers/publickey'
+import { Account, SystemProgram, Transaction, PublicKey } from '@exodus/solana-web3.js'
+import { getKeyPairFromPrivateKey } from './keypair'
 import bs58 from 'bs58'
 
 class Tx {
@@ -40,7 +38,9 @@ class Tx {
   }
 
   static sign(tx: Tx, privateKey: Buffer | string) {
-    const signers = [new Account(Buffer.from(privateKey, 'hex'))]
+    if (!privateKey) throw new Error('Please provide a secretKey')
+    const { secretKey } = getKeyPairFromPrivateKey(privateKey)
+    const signers = [new Account(secretKey)]
 
     tx.transaction.sign(...signers)
     if (!tx.transaction.signature) {
@@ -50,7 +50,7 @@ class Tx {
 
   serialize() {
     const wireTransaction = this.transaction.serialize()
-    return bs58.encode(wireTransaction)
+    return wireTransaction.toString('base64')
   }
 
   getTxId() {

package/src/helpers/account.js

@@ -1,38 +0,0 @@
-// @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/helpers/blockhash.js

@@ -1,6 +0,0 @@
-// @flow
-
-/**
- * @typedef {string} Blockhash
- */
-export type Blockhash = string

package/src/helpers/fee-calculator.js

@@ -1,17 +0,0 @@
-// @flow
-import * as BufferLayout from '@exodus/buffer-layout'
-
-/**
- * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11
- *
- * @private
- */
-export const FeeCalculatorLayout = BufferLayout.nu64('lamportsPerSignature')
-
-/**
- * @typedef {Object} FeeCalculator
- * @property {number} lamportsPerSignature lamports Cost in lamports to validate a signature
- */
-export type FeeCalculator = {
-  lamportsPerSignature: number,
-}

package/src/helpers/instruction.js

@@ -1,46 +0,0 @@
-// @flow
-
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import * as Layout from './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/helpers/layout.js

@@ -1,80 +0,0 @@
-// @flow
-
-import * as BufferLayout from '@exodus/buffer-layout'
-
-/**
- * Layout for a public key
- */
-export const publicKey = (property: string = 'publicKey'): Object => {
-  return BufferLayout.blob(32, property)
-}
-
-/**
- * Layout for a 64bit unsigned value
- */
-export const uint64 = (property: string = 'uint64'): Object => {
-  return BufferLayout.blob(8, property)
-}
-
-/**
- * Layout for a Rust String type
- */
-export const rustString = (property: string = 'string') => {
-  const rsl = BufferLayout.struct(
-    [
-      BufferLayout.u32('length'),
-      BufferLayout.u32('lengthPadding'),
-      BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), 'chars'),
-    ],
-    property
-  )
-  const _decode = rsl.decode.bind(rsl)
-  const _encode = rsl.encode.bind(rsl)
-
-  rsl.decode = (buffer, offset) => {
-    const data = _decode(buffer, offset)
-    return data.chars.toString('utf8')
-  }
-
-  rsl.encode = (str, buffer, offset) => {
-    const data = {
-      chars: Buffer.from(str, 'utf8'),
-    }
-    return _encode(data, buffer, offset)
-  }
-
-  rsl.alloc = (str) => {
-    return BufferLayout.u32().span + BufferLayout.u32().span + Buffer.from(str, 'utf8').length
-  }
-
-  return rsl
-}
-
-/**
- * Layout for an Authorized object
- */
-export const authorized = (property: string = 'authorized') => {
-  return BufferLayout.struct([publicKey('staker'), publicKey('withdrawer')], property)
-}
-
-/**
- * Layout for a Lockup object
- */
-export const lockup = (property: string = 'lockup') => {
-  return BufferLayout.struct(
-    [BufferLayout.ns64('unixTimestamp'), BufferLayout.ns64('epoch'), publicKey('custodian')],
-    property
-  )
-}
-
-export function getAlloc(type: Object, fields: Object): number {
-  let alloc = 0
-  type.layout.fields.forEach((item) => {
-    if (item.span >= 0) {
-      alloc += item.span
-    } else if (typeof item.alloc === 'function') {
-      alloc += item.alloc(fields[item.property])
-    }
-  })
-  return alloc
-}

package/src/helpers/message.js

@@ -1,216 +0,0 @@
-// @flow
-
-import bs58 from 'bs58'
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import { PublicKey } from './publickey'
-import type { Blockhash } from './blockhash'
-import * as Layout from './layout'
-import { PACKET_DATA_SIZE } from './transaction'
-import * as shortvec from './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/helpers/nonce-account.js

@@ -1,46 +0,0 @@
-// @flow
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import type { Blockhash } from './blockhash'
-import * as Layout from './layout'
-import { PublicKey } from './publickey'
-import type { FeeCalculator } from './fee-calculator'
-import { FeeCalculatorLayout } from './fee-calculator'
-import { toBuffer } from './util/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
-  }
-}

package/src/helpers/publickey.js

@@ -1,65 +0,0 @@
-// @flow
-import BN from 'bn.js'
-import bs58 from 'bs58'
-
-/**
- * A public key
- */
-export class PublicKey {
-  _bn: BN
-
-  /**
-   * Create a new PublicKey object
-   */
-  constructor(value: number | string | Buffer | Uint8Array | Array<number>) {
-    if (typeof value === 'string') {
-      // assume base 58 encoding by default
-      const decoded = bs58.decode(value)
-      if (decoded.length !== 32) {
-        throw new Error(`Invalid public key input`)
-      }
-      this._bn = new BN(decoded)
-    } else {
-      this._bn = new BN(value)
-    }
-
-    if (this._bn.byteLength() > 32) {
-      throw new Error(`Invalid public key input`)
-    }
-  }
-
-  /**
-   * Checks if two publicKeys are equal
-   */
-  equals(publicKey: PublicKey): boolean {
-    return this._bn.eq(publicKey._bn)
-  }
-
-  /**
-   * Return the base-58 representation of the public key
-   */
-  toBase58(): string {
-    return bs58.encode(this.toBuffer())
-  }
-
-  /**
-   * Return the Buffer representation of the public key
-   */
-  toBuffer(): Buffer {
-    const b = this._bn.toArrayLike(Buffer)
-    if (b.length === 32) {
-      return b
-    }
-
-    const zeroPad = Buffer.alloc(32)
-    b.copy(zeroPad, 32 - b.length)
-    return zeroPad
-  }
-
-  /**
-   * Returns a string representation of the public key
-   */
-  toString(): string {
-    return this.toBase58()
-  }
-}

package/src/helpers/shortvec-encoding.js

@@ -1,30 +0,0 @@
-// @flow
-
-export function decodeLength(bytes: Array<number>): number {
-  let len = 0
-  let size = 0
-  for (;;) {
-    let elem = bytes.shift()
-    len |= (elem & 0x7f) << (size * 7)
-    size += 1
-    if ((elem & 0x80) === 0) {
-      break
-    }
-  }
-  return len
-}
-
-export function encodeLength(bytes: Array<number>, len: number) {
-  let remLen = len
-  for (;;) {
-    let elem = remLen & 0x7f
-    remLen >>= 7
-    if (remLen === 0) {
-      bytes.push(elem)
-      break
-    } else {
-      elem |= 0x80
-      bytes.push(elem)
-    }
-  }
-}