@exodus/solana-lib 1.2.3 → 1.2.5

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
+  }
+}

package/src/vendor/publickey.js

@@ -0,0 +1,192 @@
+// @flow
+import BN from 'bn.js'
+import bs58 from 'bs58'
+import nacl from 'tweetnacl'
+import createHash from 'create-hash'
+
+// $FlowFixMe
+let naclLowLevel = nacl.lowlevel
+
+/**
+ * Maximum length of derived pubkey seed
+ */
+export const MAX_SEED_LENGTH = 32
+
+/**
+ * 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()
+  }
+
+  /**
+   * Find a valid program address
+   *
+   * Valid program addresses must fall off the ed25519 curve.  This function
+   * iterates a nonce until it finds one that when combined with the seeds
+   * results in a valid program address.
+   * HACK: transformed in sync function
+   */
+  static findProgramAddress(seeds: Array<Buffer | Uint8Array>, programId: PublicKey) {
+    let nonce = 255
+    let address
+    while (nonce !== 0) {
+      try {
+        const seedsWithNonce = seeds.concat(Buffer.from([nonce]))
+        address = this.createProgramAddress(seedsWithNonce, programId)
+      } catch (err) {
+        nonce--
+        continue
+      }
+      return [address, nonce]
+    }
+    throw new Error('Unable to find a viable program address nonce')
+  }
+
+  /**
+   * Derive a program address from seeds and a program ID.
+   */
+  static createProgramAddress(seeds: Array<Buffer | Uint8Array>, programId: PublicKey) {
+    let buffer = Buffer.alloc(0)
+    seeds.forEach(function(seed) {
+      if (seed.length > MAX_SEED_LENGTH) {
+        throw new Error('Max seed length exceeded')
+      }
+      buffer = Buffer.concat([buffer, Buffer.from(seed)])
+    })
+    buffer = Buffer.concat([buffer, programId.toBuffer(), Buffer.from('ProgramDerivedAddress')])
+    let hash = createHash('sha256')
+      .update(buffer)
+      .digest('hex')
+    let publicKeyBytes = new BN(hash, 16).toArray(null, 32)
+    if (isOnCurve(publicKeyBytes)) {
+      throw new Error('Invalid seeds, address must fall off the curve')
+    }
+    return new PublicKey(publicKeyBytes)
+  }
+}
+
+// Check that a pubkey is on the curve.
+// This function and its dependents were sourced from:
+// https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
+function isOnCurve(p) {
+  let r = [naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf()]
+
+  let t = naclLowLevel.gf()
+  let chk = naclLowLevel.gf()
+  let num = naclLowLevel.gf()
+  let den = naclLowLevel.gf()
+  let den2 = naclLowLevel.gf()
+  let den4 = naclLowLevel.gf()
+  let den6 = naclLowLevel.gf()
+
+  naclLowLevel.set25519(r[2], gf1)
+  naclLowLevel.unpack25519(r[1], p)
+  naclLowLevel.S(num, r[1])
+  naclLowLevel.M(den, num, naclLowLevel.D)
+  naclLowLevel.Z(num, num, r[2])
+  naclLowLevel.A(den, r[2], den)
+
+  naclLowLevel.S(den2, den)
+  naclLowLevel.S(den4, den2)
+  naclLowLevel.M(den6, den4, den2)
+  naclLowLevel.M(t, den6, num)
+  naclLowLevel.M(t, t, den)
+
+  naclLowLevel.pow2523(t, t)
+  naclLowLevel.M(t, t, num)
+  naclLowLevel.M(t, t, den)
+  naclLowLevel.M(t, t, den)
+  naclLowLevel.M(r[0], t, den)
+
+  naclLowLevel.S(chk, r[0])
+  naclLowLevel.M(chk, chk, den)
+  if (neq25519(chk, num)) naclLowLevel.M(r[0], r[0], I)
+
+  naclLowLevel.S(chk, r[0])
+  naclLowLevel.M(chk, chk, den)
+  if (neq25519(chk, num)) return 0
+  return 1
+}
+
+let gf1 = naclLowLevel.gf([1])
+let I = naclLowLevel.gf([
+  0xa0b0,
+  0x4a0e,
+  0x1b27,
+  0xc4ee,
+  0xe478,
+  0xad2f,
+  0x1806,
+  0x2f43,
+  0xd7a7,
+  0x3dfb,
+  0x0099,
+  0x2b4d,
+  0xdf0b,
+  0x4fc1,
+  0x2480,
+  0x2b83,
+])
+
+function neq25519(a, b) {
+  var c = new Uint8Array(32)
+  var d = new Uint8Array(32)
+  naclLowLevel.pack25519(c, a)
+  naclLowLevel.pack25519(d, b)
+  return naclLowLevel.crypto_verify_32(c, 0, d, 0)
+}