@exodus/solana-lib 1.7.5 → 1.8.0

package/src/vendor/compute-budget-program.js

@@ -0,0 +1,180 @@
+import * as BufferLayout from '@exodus/buffer-layout'
+
+import { encodeData, decodeData } from './instruction'
+import { PublicKey } from './publickey'
+import { TransactionInstruction } from './transaction'
+
+// 1 microLamport = 0.000001 lamports
+
+/**
+ * Compute Budget Instruction class
+ */
+// eslint-disable-next-line unicorn/no-static-only-class
+export class ComputeBudgetInstruction {
+  /**
+   * Decode a compute budget instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId)
+
+    const instructionTypeLayout = BufferLayout.u8('instruction')
+    const typeIndex = instructionTypeLayout.decode(instruction.data)
+
+    let type
+    for (const [ixType, layout] of Object.entries(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS)) {
+      if (layout.index === typeIndex) {
+        type = ixType
+        break
+      }
+    }
+
+    if (!type) {
+      throw new Error('Instruction type incorrect; not a ComputeBudgetInstruction')
+    }
+
+    return type
+  }
+
+  /**
+   * Decode request units compute budget instruction and retrieve the instruction params.
+   */
+  static decodeRequestUnits(instruction) {
+    this.checkProgramId(instruction.programId)
+    const { units, additionalFee } = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits,
+      instruction.data
+    )
+    return { units, additionalFee }
+  }
+
+  /**
+   * Decode request heap frame compute budget instruction and retrieve the instruction params.
+   */
+  static decodeRequestHeapFrame(instruction) {
+    this.checkProgramId(instruction.programId)
+    const { bytes } = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame,
+      instruction.data
+    )
+    return { bytes }
+  }
+
+  /**
+   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+   */
+  static decodeSetComputeUnitLimit(instruction) {
+    this.checkProgramId(instruction.programId)
+    const { units } = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit,
+      instruction.data
+    )
+    return { units }
+  }
+
+  /**
+   * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+   */
+  static decodeSetComputeUnitPrice(instruction) {
+    this.checkProgramId(instruction.programId)
+    const { microLamports } = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice,
+      instruction.data
+    )
+    return { microLamports }
+  }
+
+  /**
+   * @internal
+   */
+  static checkProgramId(programId) {
+    if (!programId.equals(ComputeBudgetProgram.programId)) {
+      throw new Error('invalid instruction; programId is not ComputeBudgetProgram')
+    }
+  }
+}
+
+/**
+ * An enumeration of valid ComputeBudget InstructionType's
+ * @internal
+ */
+export const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
+  RequestUnits: {
+    index: 0,
+    layout: BufferLayout.struct([
+      BufferLayout.u8('instruction'),
+      BufferLayout.u32('units'),
+      BufferLayout.u32('additionalFee'),
+    ]),
+  },
+  RequestHeapFrame: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')]),
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('units')]),
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct([
+      BufferLayout.u8('instruction'),
+      BufferLayout.ns64('microLamports'),
+    ]),
+  },
+})
+
+/**
+ * Factory class for transaction instructions to interact with the Compute Budget program
+ */
+// eslint-disable-next-line unicorn/no-static-only-class
+export class ComputeBudgetProgram {
+  /**
+   * Public key that identifies the Compute Budget program
+   */
+  static programId = new PublicKey('ComputeBudget111111111111111111111111111111')
+
+  /**
+   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}
+   */
+  static requestUnits(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits
+    const data = encodeData(type, params)
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    })
+  }
+
+  static requestHeapFrame(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame
+    const data = encodeData(type, params)
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    })
+  }
+
+  static setComputeUnitLimit(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit
+    const data = encodeData(type, params)
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    })
+  }
+
+  static setComputeUnitPrice(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice
+    const data = encodeData(type, {
+      microLamports: Number(params.microLamports), // replaced from BigInt
+    })
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    })
+  }
+}

package/src/vendor/constants.js

@@ -0,0 +1,8 @@
+/**
+ * Maximum over-the-wire size of a Transaction
+ *
+ * 1280 is IPv6 minimum MTU
+ * 40 bytes is the size of the IPv6 header
+ * 8 bytes is the size of the fragment header
+ */
+export const PACKET_DATA_SIZE = 1280 - 40 - 8

package/src/vendor/index.js

@@ -4,6 +4,8 @@ export * from './message'
 export * from './nonce-account'
 export * from './publickey'
 export * from './system-program'
+export * from './compute-budget-program'
 export * from './stake-program'
 export * from './sysvar'
 export * from './transaction'
+export * from './constants'

package/src/vendor/message.js

@@ -4,7 +4,7 @@ import * as BufferLayout from '@exodus/buffer-layout'
 import { PublicKey } from './publickey'
 
 import * as Layout from './utils/layout'
-import { PACKET_DATA_SIZE } from './transaction'
+import { PACKET_DATA_SIZE } from './constants'
 import * as shortvec from './utils/shortvec-encoding'
 
 /**
@@ -73,23 +73,24 @@ export class Message {
     if (index < 0) {
       throw new Error(`unknown signer: ${signer.toString()}`)
     }
+
     return index
   }
 
   serialize() {
     const numKeys = this.accountKeys.length
 
-    let keyCount = []
+    const keyCount = []
     shortvec.encodeLength(keyCount, numKeys)
 
     const instructions = this.instructions.map((instruction) => {
       const { accounts, programIdIndex } = instruction
       const data = bs58.decode(instruction.data)
 
-      let keyIndicesCount = []
+      const keyIndicesCount = []
       shortvec.encodeLength(keyIndicesCount, accounts.length)
 
-      let dataCount = []
+      const dataCount = []
       shortvec.encodeLength(dataCount, data.length)
 
       return {
@@ -101,7 +102,7 @@ export class Message {
       }
     })
 
-    let instructionCount = []
+    const instructionCount = []
     shortvec.encodeLength(instructionCount, instructions.length)
     let instructionBuffer = Buffer.alloc(PACKET_DATA_SIZE)
     Buffer.from(instructionCount).copy(instructionBuffer)
@@ -143,7 +144,7 @@ export class Message {
       recentBlockhash: bs58.decode(this.recentBlockhash),
     }
 
-    let signData = Buffer.alloc(2048)
+    const signData = Buffer.alloc(2048)
     const length = signDataLayout.encode(transaction, signData)
     instructionBuffer.copy(signData, length)
     return signData.slice(0, length + instructionBuffer.length)
@@ -161,7 +162,7 @@ export class Message {
     const numReadonlyUnsignedAccounts = byteArray.shift()
 
     const accountCount = shortvec.decodeLength(byteArray)
-    let accountKeys = []
+    const accountKeys = []
     for (let i = 0; i < accountCount; i++) {
       const account = byteArray.slice(0, PUBKEY_LENGTH)
       byteArray = byteArray.slice(PUBKEY_LENGTH)
@@ -172,9 +173,9 @@ export class Message {
     byteArray = byteArray.slice(PUBKEY_LENGTH)
 
     const instructionCount = shortvec.decodeLength(byteArray)
-    let instructions = []
+    const instructions = []
     for (let i = 0; i < instructionCount; i++) {
-      let instruction = {}
+      const instruction = Object.create(null)
       instruction.programIdIndex = byteArray.shift()
       const accountCount = shortvec.decodeLength(byteArray)
       instruction.accounts = byteArray.slice(0, accountCount)

package/src/vendor/publickey.js

@@ -4,7 +4,7 @@ import nacl from 'tweetnacl'
 import createHash from 'create-hash'
 
 // $FlowFixMe
-let naclLowLevel = nacl.lowlevel
+const naclLowLevel = nacl.lowlevel
 
 /**
  * Maximum length of derived pubkey seed
@@ -27,6 +27,7 @@ export class PublicKey {
       if (decoded.length !== 32) {
         throw new Error(`Invalid public key input`)
       }
+
       this._bn = new BN(decoded)
     } else {
       this._bn = new BN(value)
@@ -100,14 +101,16 @@ export class PublicKey {
     let address
     while (nonce !== 0) {
       try {
-        const seedsWithNonce = seeds.concat(Buffer.from([nonce]))
+        const seedsWithNonce = [...seeds, Buffer.from([nonce])]
         address = this.createProgramAddress(seedsWithNonce, programId)
-      } catch (err) {
+      } catch {
         nonce--
         continue
       }
+
       return [address, nonce]
     }
+
     throw new Error('Unable to find a viable program address nonce')
   }
 
@@ -121,9 +124,7 @@ export class PublicKey {
       Buffer.from(seed),
       programId.toBuffer(),
     ])
-    const hash = createHash('sha256')
-      .update(buffer)
-      .digest('hex')
+    const hash = createHash('sha256').update(buffer).digest('hex')
     return new PublicKey(Buffer.from(hash, 'hex'))
   }
 
@@ -132,20 +133,20 @@ export class PublicKey {
    */
   static createProgramAddress(seeds, programId) {
     let buffer = Buffer.alloc(0)
-    seeds.forEach(function(seed) {
+    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)
+    const hash = createHash('sha256').update(buffer).digest('hex')
+    const 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)
   }
 }
@@ -154,15 +155,15 @@ export class PublicKey {
 // 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()]
+  const 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()
+  const t = naclLowLevel.gf()
+  const chk = naclLowLevel.gf()
+  const num = naclLowLevel.gf()
+  const den = naclLowLevel.gf()
+  const den2 = naclLowLevel.gf()
+  const den4 = naclLowLevel.gf()
+  const den6 = naclLowLevel.gf()
 
   naclLowLevel.set25519(r[2], gf1)
   naclLowLevel.unpack25519(r[1], p)
@@ -193,24 +194,10 @@ function isOnCurve(p) {
   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,
+const gf1 = naclLowLevel.gf([1])
+const I = naclLowLevel.gf([
+  0xa0_b0, 0x4a_0e, 0x1b_27, 0xc4_ee, 0xe4_78, 0xad_2f, 0x18_06, 0x2f_43, 0xd7_a7, 0x3d_fb, 0x00_99,
+  0x2b_4d, 0xdf_0b, 0x4f_c1, 0x24_80, 0x2b_83,
 ])
 
 function neq25519(a, b) {

package/src/vendor/stake-program.js

@@ -176,11 +176,11 @@ export const STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
 /**
  * Stake Instruction class
  */
-export class StakeInstruction {
+export const StakeInstruction = {
   /**
    * Decode a stake instruction and retrieve the instruction type.
    */
-  static decodeInstructionType(instruction) {
+  decodeInstructionType(instruction) {
     this.checkProgramId(instruction.programId)
 
     const instructionTypeLayout = BufferLayout.u32('instruction')
@@ -198,12 +198,12 @@ export class StakeInstruction {
     }
 
     return type
-  }
+  },
 
   /**
    * Decode a initialize stake instruction and retrieve the instruction params.
    */
-  static decodeInitialize(instruction) {
+  decodeInitialize(instruction) {
     this.checkProgramId(instruction.programId)
     this.checkKeyLength(instruction.keys, 2)
 
@@ -220,12 +220,12 @@ export class StakeInstruction {
       ),
       lockup: new Lockup(lockup.unixTimestamp, lockup.epoch, new PublicKey(lockup.custodian)),
     }
-  }
+  },
 
   /**
    * Decode a delegate stake instruction and retrieve the instruction params.
    */
-  static decodeDelegate(instruction) {
+  decodeDelegate(instruction) {
     this.checkProgramId(instruction.programId)
     this.checkKeyLength(instruction.keys, 6)
     decodeData(STAKE_INSTRUCTION_LAYOUTS.Delegate, instruction.data)
@@ -235,12 +235,12 @@ export class StakeInstruction {
       votePubkey: instruction.keys[1].pubkey,
       authorizedPubkey: instruction.keys[5].pubkey,
     }
-  }
+  },
 
   /**
    * Decode a withdraw stake instruction and retrieve the instruction params.
    */
-  static decodeWithdraw(instruction) {
+  decodeWithdraw(instruction) {
     this.checkProgramId(instruction.programId)
     this.checkKeyLength(instruction.keys, 5)
     const { lamports } = decodeData(STAKE_INSTRUCTION_LAYOUTS.Withdraw, instruction.data)
@@ -251,12 +251,12 @@ export class StakeInstruction {
       authorizedPubkey: instruction.keys[4].pubkey,
       lamports,
     }
-  }
+  },
 
   /**
    * Decode a deactivate stake instruction and retrieve the instruction params.
    */
-  static decodeDeactivate(instruction) {
+  decodeDeactivate(instruction) {
     this.checkProgramId(instruction.programId)
     this.checkKeyLength(instruction.keys, 3)
     decodeData(STAKE_INSTRUCTION_LAYOUTS.Deactivate, instruction.data)
@@ -265,27 +265,27 @@ export class StakeInstruction {
       stakePubkey: instruction.keys[0].pubkey,
       authorizedPubkey: instruction.keys[2].pubkey,
     }
-  }
+  },
 
   /**
    * @private
    */
-  static checkProgramId(programId) {
+  checkProgramId(programId) {
     if (!programId.equals(StakeProgram.programId)) {
       throw new Error('invalid instruction; programId is not StakeProgram')
     }
-  }
+  },
 
   /**
    * @private
    */
-  static checkKeyLength(keys, expectedLength) {
+  checkKeyLength(keys, expectedLength) {
     if (keys.length < expectedLength) {
       throw new Error(
         `invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`
       )
     }
-  }
+  },
 }
 
 /**
@@ -303,13 +303,13 @@ export const StakeAuthorizationLayout = Object.freeze({
 /**
  * Factory class for transactions to interact with the Stake program
  */
-export class StakeProgram {
+export const StakeProgram = {
   /**
    * Public key that identifies the Stake program
    */
-  static get programId() {
+  get programId() {
     return new PublicKey('Stake11111111111111111111111111111111111111')
-  }
+  },
 
   /**
    * Max space of a Stake account
@@ -318,14 +318,14 @@ export class StakeProgram {
    * `std::mem::size_of::<StakeState>()`:
    * https://docs.rs/solana-stake-program/1.4.4/solana_stake_program/stake_state/enum.StakeState.html
    */
-  static get space() {
+  get space() {
     return 200
-  }
+  },
 
   /**
    * Generate an Initialize instruction to add to a Stake Create transaction
    */
-  static initialize(params) {
+  initialize(params) {
     const { stakePubkey, authorized, lockup } = params
     const type = STAKE_INSTRUCTION_LAYOUTS.Initialize
     const data = encodeData(type, {
@@ -348,13 +348,13 @@ export class StakeProgram {
       data,
     }
     return new TransactionInstruction(instructionData)
-  }
+  },
 
   /**
    * Generate a Transaction that creates a new Stake account at
    *   an address generated with `from`, a seed, and the Stake programId
    */
-  static createAccountWithSeed(params) {
+  createAccountWithSeed(params) {
     const transaction = new Transaction()
     transaction.add(
       SystemProgram.createAccountWithSeed({
@@ -370,12 +370,12 @@ export class StakeProgram {
 
     const { stakePubkey, authorized, lockup } = params
     return transaction.add(this.initialize({ stakePubkey, authorized, lockup }))
-  }
+  },
 
   /**
    * Generate a Transaction that creates a new Stake account
    */
-  static createAccount(params) {
+  createAccount(params) {
     const transaction = new Transaction()
     transaction.add(
       SystemProgram.createAccount({
@@ -389,14 +389,14 @@ export class StakeProgram {
 
     const { stakePubkey, authorized, lockup } = params
     return transaction.add(this.initialize({ stakePubkey, authorized, lockup }))
-  }
+  },
 
   /**
    * Generate a Transaction that delegates Stake tokens to a validator
    * Vote PublicKey. This transaction can also be used to redelegate Stake
    * to a new validator Vote PublicKey.
    */
-  static delegate(params) {
+  delegate(params) {
     const { stakePubkey, authorizedPubkey, votePubkey } = params
 
     const type = STAKE_INSTRUCTION_LAYOUTS.Delegate
@@ -418,12 +418,12 @@ export class StakeProgram {
       programId: this.programId,
       data,
     })
-  }
+  },
 
   /**
    * Generate a Transaction that withdraws deactivated Stake tokens.
    */
-  static withdraw(params) {
+  withdraw(params) {
     const { stakePubkey, authorizedPubkey, toPubkey, lamports } = params
     const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw
     const data = encodeData(type, { lamports })
@@ -443,12 +443,12 @@ export class StakeProgram {
       programId: this.programId,
       data,
     })
-  }
+  },
 
   /**
    * Generate a Transaction that deactivates Stake tokens.
    */
-  static deactivate(params) {
+  deactivate(params) {
     const { stakePubkey, authorizedPubkey } = params
     const type = STAKE_INSTRUCTION_LAYOUTS.Deactivate
     const data = encodeData(type)
@@ -462,5 +462,5 @@ export class StakeProgram {
       programId: this.programId,
       data,
     })
-  }
+  },
 }