algosdk 1.23.2 → 1.24.1

package/src/logic/logic.ts

@@ -0,0 +1,316 @@
+/* eslint-disable no-bitwise */
+/**
+ * Utilities for working with program bytes.
+ */
+
+/** @deprecated langspec.json is deprecated aross all SDKs */
+import langspec from './langspec.json';
+
+/**
+ * Langspec Op Structure
+ * @deprecated for langspec.json is deprecated aross all SDKs
+ */
+interface OpStructure {
+  Opcode: number;
+  Name: string;
+  Args?: string;
+  Returns?: string;
+  Cost: number;
+  Size: number;
+  ArgEnum?: string[];
+  ArgEnumTypes?: string;
+  Doc: string;
+  DocExtra?: string;
+  ImmediateNote?: string;
+  Groups: string[];
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+let opcodes: {
+  [key: number]: OpStructure;
+};
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+const maxCost = 20000;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+const maxLength = 1000;
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export function parseUvarint(
+  array: Uint8Array
+): [numberFound: number, size: number] {
+  let x = 0;
+  let s = 0;
+  for (let i = 0; i < array.length; i++) {
+    const b = array[i];
+    if (b < 0x80) {
+      if (i > 9 || (i === 9 && b > 1)) {
+        return [0, -(i + 1)];
+      }
+      return [x | (b << s), i + 1];
+    }
+    x += (b & 0x7f) << s;
+    s += 7;
+  }
+  return [0, 0];
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+function readIntConstBlock(
+  program: Uint8Array,
+  pc: number
+): [size: number, ints: number[]] {
+  let size = 1;
+  const parsed = parseUvarint(program.slice(pc + size));
+  const numInts = parsed[0];
+  let bytesUsed = parsed[1];
+  if (bytesUsed <= 0) {
+    throw new Error(`could not decode int const block size at pc=${pc + size}`);
+  }
+  const ints: number[] = [];
+  size += bytesUsed;
+  for (let i = 0; i < numInts; i++) {
+    if (pc + size >= program.length) {
+      throw new Error('intcblock ran past end of program');
+    }
+    let numberFound: number;
+    [numberFound, bytesUsed] = parseUvarint(program.slice(pc + size));
+    if (bytesUsed <= 0) {
+      throw new Error(
+        `could not decode int const[${i}] block size at pc=${pc + size}`
+      );
+    }
+    ints.push(numberFound);
+    size += bytesUsed;
+  }
+  return [size, ints];
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+function readByteConstBlock(
+  program: Uint8Array,
+  pc: number
+): [size: number, byteArrays: Uint8Array[]] {
+  let size = 1;
+  const parsed = parseUvarint(program.slice(pc + size));
+  const numInts = parsed[0];
+  let bytesUsed = parsed[1];
+  if (bytesUsed <= 0) {
+    throw new Error(
+      `could not decode []byte const block size at pc=${pc + size}`
+    );
+  }
+  const byteArrays: Uint8Array[] = [];
+  size += bytesUsed;
+  for (let i = 0; i < numInts; i++) {
+    if (pc + size >= program.length) {
+      throw new Error('bytecblock ran past end of program');
+    }
+    let itemLen: number;
+    [itemLen, bytesUsed] = parseUvarint(program.slice(pc + size));
+    if (bytesUsed <= 0) {
+      throw new Error(
+        `could not decode []byte] const[${i}] block size at pc=${pc + size}`
+      );
+    }
+    size += bytesUsed;
+    if (pc + size + itemLen > program.length) {
+      throw new Error('bytecblock ran past end of program');
+    }
+    const byteArray = program.slice(pc + size, pc + size + itemLen);
+    byteArrays.push(byteArray);
+    size += itemLen;
+  }
+  return [size, byteArrays];
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+function readPushIntOp(
+  program: Uint8Array,
+  pc: number
+): [size: number, numberFound: number] {
+  let size = 1;
+  const [numberFound, bytesUsed] = parseUvarint(program.slice(pc + size));
+  if (bytesUsed <= 0) {
+    throw new Error(`could not decode push int const at pc=${pc + size}`);
+  }
+  size += bytesUsed;
+  return [size, numberFound];
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+function readPushByteOp(
+  program: Uint8Array,
+  pc: number
+): [size: number, byteArray: Uint8Array] {
+  let size = 1;
+  const [itemLen, bytesUsed] = parseUvarint(program.slice(pc + size));
+  if (bytesUsed <= 0) {
+    throw new Error(
+      `could not decode push []byte const size at pc=${pc + size}`
+    );
+  }
+  size += bytesUsed;
+  if (pc + size + itemLen > program.length) {
+    throw new Error('pushbytes ran past end of program');
+  }
+  const byteArray = program.slice(pc + size, pc + size + itemLen);
+  size += itemLen;
+  return [size, byteArray];
+}
+
+/** readProgram validates program for length and running cost,
+ * and additionally provides the found int variables and byte blocks
+ *
+ * @deprecated Validation relies on metadata (`langspec.json`) that
+ * does not accurately represent opcode behavior across program versions.
+ * The behavior of `readProgram` relies on `langspec.json`.
+ * Thus, this method is being deprecated.
+ *
+ * @param program - Program to check
+ * @param args - Program arguments as array of Uint8Array arrays
+ * @throws
+ * @returns
+ */
+export function readProgram(
+  program: Uint8Array,
+  args?: Uint8Array[]
+): [ints: number[], byteArrays: Uint8Array[], valid: boolean] {
+  const intcblockOpcode = 32;
+  const bytecblockOpcode = 38;
+  const pushbytesOpcode = 128;
+  const pushintOpcode = 129;
+
+  if (!program) {
+    throw new Error('empty program');
+  }
+
+  if (typeof args === 'undefined') {
+    // eslint-disable-next-line no-param-reassign
+    args = [];
+  }
+  if (!Array.isArray(args)) {
+    throw new Error('invalid arguments');
+  }
+
+  const [version, vlen] = parseUvarint(program);
+  if (vlen <= 0) {
+    throw new Error('version parsing error');
+  }
+  if (version > langspec.EvalMaxVersion) {
+    throw new Error('unsupported version');
+  }
+
+  let cost = 0;
+  let { length } = program;
+  for (const arg of args) {
+    length += arg.length;
+  }
+  if (length > maxLength) {
+    throw new Error('program too long');
+  }
+
+  if (!opcodes) {
+    opcodes = {};
+    for (const op of langspec.Ops) {
+      opcodes[op.Opcode] = op;
+    }
+  }
+
+  let pc = vlen;
+  let ints: number[] = [];
+  let byteArrays: Uint8Array[] = [];
+  while (pc < program.length) {
+    const op = opcodes[program[pc]];
+    if (op === undefined) {
+      throw new Error('invalid instruction');
+    }
+
+    cost += op.Cost;
+    let size = op.Size;
+    if (size === 0) {
+      switch (op.Opcode) {
+        case intcblockOpcode: {
+          let foundInts: number[];
+          [size, foundInts] = readIntConstBlock(program, pc);
+          ints = ints.concat(foundInts);
+          break;
+        }
+        case bytecblockOpcode: {
+          let foundByteArrays: Uint8Array[];
+          [size, foundByteArrays] = readByteConstBlock(program, pc);
+          byteArrays = byteArrays.concat(foundByteArrays);
+          break;
+        }
+        case pushintOpcode: {
+          let foundInt: number;
+          [size, foundInt] = readPushIntOp(program, pc);
+          ints.push(foundInt);
+          break;
+        }
+        case pushbytesOpcode: {
+          let foundByteArray;
+          [size, foundByteArray] = readPushByteOp(program, pc);
+          byteArrays.push(foundByteArray);
+          break;
+        }
+        default: {
+          throw new Error('invalid instruction');
+        }
+      }
+    }
+    pc += size;
+  }
+  // costs calculated dynamically starting in v4
+  if (version < 4 && cost > maxCost) {
+    throw new Error('program too costly for version < 4. consider using v4.');
+  }
+  return [ints, byteArrays, true];
+}
+
+/**
+ * checkProgram validates program for length and running cost
+ *
+ * @deprecated Validation relies on metadata (`langspec.json`) that
+ * does not accurately represent opcode behavior across program versions.
+ * The behavior of `checkProgram` relies on `langspec.json`.
+ * Thus, this method is being deprecated.
+ *
+ * @param program - Program to check
+ * @param args - Program arguments as array of Uint8Array arrays
+ * @throws
+ * @returns true if success
+ */
+export function checkProgram(program: Uint8Array, args?: Uint8Array[]) {
+  const [, , success] = readProgram(program, args);
+  return success;
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export function checkIntConstBlock(program: Uint8Array, pc: number) {
+  const [size] = readIntConstBlock(program, pc);
+  return size;
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export function checkByteConstBlock(program: Uint8Array, pc: number) {
+  const [size] = readByteConstBlock(program, pc);
+  return size;
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export function checkPushIntOp(program: Uint8Array, pc: number) {
+  const [size] = readPushIntOp(program, pc);
+  return size;
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export function checkPushByteOp(program: Uint8Array, pc: number) {
+  const [size] = readPushByteOp(program, pc);
+  return size;
+}
+
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export const langspecEvalMaxVersion = langspec.EvalMaxVersion;
+/** @deprecated for langspec.json is deprecated aross all SDKs */
+export const langspecLogicSigVersion = langspec.LogicSigVersion;

package/src/logic/sourcemap.ts

@@ -0,0 +1,67 @@
+import * as vlq from 'vlq';
+
+export class SourceMap {
+  version: number;
+  sources: string[];
+  names: string[];
+  mappings: string;
+
+  pcToLine: { [key: number]: number };
+  lineToPc: { [key: number]: number[] };
+
+  constructor({
+    version,
+    sources,
+    names,
+    mappings,
+  }: {
+    version: number;
+    sources: string[];
+    names: string[];
+    mappings: string;
+  }) {
+    this.version = version;
+    this.sources = sources;
+    this.names = names;
+    this.mappings = mappings;
+
+    if (this.version !== 3)
+      throw new Error(`Only version 3 is supported, got ${this.version}`);
+
+    if (this.mappings === undefined)
+      throw new Error(
+        'mapping undefined, cannot build source map without `mapping`'
+      );
+
+    const pcList = this.mappings.split(';').map((m) => {
+      const decoded = vlq.decode(m);
+      if (decoded.length > 2) return decoded[2];
+      return undefined;
+    });
+
+    this.pcToLine = {};
+    this.lineToPc = {};
+
+    let lastLine = 0;
+    for (const [pc, lineDelta] of pcList.entries()) {
+      // If the delta is not undefined, the lastLine should be updated with
+      // lastLine + the delta
+      if (lineDelta !== undefined) {
+        lastLine += lineDelta;
+      }
+
+      if (!(lastLine in this.lineToPc)) this.lineToPc[lastLine] = [];
+
+      this.lineToPc[lastLine].push(pc);
+      this.pcToLine[pc] = lastLine;
+    }
+  }
+
+  getLineForPc(pc: number): number | undefined {
+    return this.pcToLine[pc];
+  }
+
+  getPcsForLine(line: number): number[] | undefined {
+    return this.lineToPc[line];
+  }
+}

package/src/logicTemplates/dynamicfee.js

@@ -0,0 +1,219 @@
+const address = require('../encoding/address');
+const encoding = require('../encoding/encoding');
+const group = require('../group');
+const logic = require('../logic/logic');
+const logicSig = require('../logicsig');
+const nacl = require('../nacl/naclWrappers');
+const templates = require('./templates');
+const transaction = require('../transaction');
+
+class DynamicFee {
+  /**
+   * DynamicFee contract allows you to create a transaction without
+   * specifying the fee. The fee will be determined at the moment of
+   * transfer.
+   *
+   * @deprecated This feature will be removed in v2.
+   *
+   * Constructor Parameters:
+   * @param {string} receiver: address to receive the assets
+   * @param {int} amount: amount of assets to transfer
+   * @param {int} firstValid: first valid round for the transaction
+   * @param {int} lastValid:  last valid round for the transaction
+   * @param {string} closeRemainder: if you would like to close the account after the transfer, specify the address that would recieve the remainder, else leave undefined
+   * @param {string} lease: leave undefined to generate a random lease, or supply a lease as base64
+   * @returns {DynamicFee}
+   */
+  constructor(receiver, amount, firstValid, lastValid, closeRemainder, lease) {
+    // don't need to validate receiver, closeremainderto - insert will handle that
+    if (!Number.isSafeInteger(amount) || amount < 0)
+      throw Error('amount must be a positive number and smaller than 2^53-1');
+    if (!Number.isSafeInteger(firstValid) || firstValid < 0)
+      throw Error(
+        'firstValid must be a positive number and smaller than 2^53-1'
+      );
+    if (!Number.isSafeInteger(lastValid) || lastValid < 0)
+      throw Error(
+        'lastValid must be a positive number and smaller than 2^53-1'
+      );
+
+    if (typeof closeRemainder === 'undefined') {
+      // eslint-disable-next-line no-param-reassign
+      closeRemainder = address.ALGORAND_ZERO_ADDRESS_STRING;
+    }
+    if (typeof lease === 'undefined') {
+      const leaseBytes = nacl.randomBytes(32);
+      // eslint-disable-next-line no-param-reassign
+      lease = Buffer.from(leaseBytes).toString('base64');
+    }
+
+    const referenceProgramB64 =
+      'ASAFAgEHBgUmAyD+vKC7FEpaTqe0OKRoGsgObKEFvLYH/FZTJclWlfaiEyDmmpYeby1feshmB5JlUr6YI17TM2PKiJGLuck4qRW2+SB/g7Flf/H8U7ktwYFIodZd/C1LH6PWdyhK3dIAEm2QaTIEIhIzABAjEhAzAAcxABIQMwAIMQESEDEWIxIQMRAjEhAxBygSEDEJKRIQMQgkEhAxAiUSEDEEIQQSEDEGKhIQ';
+    const referenceProgramBytes = Buffer.from(referenceProgramB64, 'base64');
+    const referenceOffsets = [
+      5 /* firstValid */,
+      6 /* lastValid */,
+      7 /* receiver */,
+      11 /* closeRemainder */,
+      44 /* lease */,
+      76,
+    ];
+    const injectionVector = [
+      amount,
+      firstValid,
+      lastValid,
+      receiver,
+      closeRemainder,
+      lease,
+    ];
+    const injectionTypes = [
+      templates.valTypes.INT,
+      templates.valTypes.INT,
+      templates.valTypes.INT,
+      templates.valTypes.ADDRESS,
+      templates.valTypes.ADDRESS,
+      templates.valTypes.BASE64,
+    ];
+    const injectedBytes = templates.inject(
+      referenceProgramBytes,
+      referenceOffsets,
+      injectionVector,
+      injectionTypes
+    );
+    this.programBytes = injectedBytes;
+    const lsig = new logicSig.LogicSig(injectedBytes, undefined);
+    this.address = lsig.address();
+  }
+
+  /**
+   * returns the program bytes
+   * @returns {Uint8Array}
+   */
+  getProgram() {
+    return this.programBytes;
+  }
+
+  /**
+   * returns the string address of the contract
+   * @returns {string}
+   */
+  getAddress() {
+    return this.address;
+  }
+}
+/**
+ * signDynamicFee returns the main transaction and signed logic needed to complete the transfer.
+ * These should be sent to the fee payer, who can use GetDynamicFeeTransactions
+ *
+ * @deprecated This feature will be removed in v2.
+ *
+ * @param {Uint8Array} contract: the bytearray representing the contract
+ * @param {Uint8Array} secretKey: the secret key for building the logic sig
+ * @param {string} genesisHash: the genesisHash to use for the txn
+ * @returns {Object} object containing json of txnbuilder constructor arguments under "txn" and signed logicsig under "lsig"
+ */
+function signDynamicFee(contract, secretKey, genesisHash) {
+  const programOutputs = logic.readProgram(contract, undefined);
+  const ints = programOutputs[0];
+  const byteArrays = programOutputs[1];
+  const keys = nacl.keyPairFromSecretKey(secretKey);
+  const from = address.encodeAddress(keys.publicKey);
+  const to = address.encodeAddress(byteArrays[0]);
+  const fee = 0;
+  const amount = ints[2];
+  const closeRemainderTo = address.encodeAddress(byteArrays[1]);
+  const firstRound = ints[3];
+  const lastRound = ints[4];
+  const lease = new Uint8Array(byteArrays[2]);
+  const txn = {
+    from,
+    to,
+    fee,
+    amount,
+    closeRemainderTo,
+    firstRound,
+    lastRound,
+    genesisHash,
+    type: 'pay',
+    lease,
+  };
+
+  const lsig = new logicSig.LogicSig(contract, undefined);
+  lsig.sign(secretKey);
+  return { txn, lsig };
+}
+
+/**
+ * getDynamicFeeTransactions creates and signs the secondary dynamic fee transaction, updates
+ * transaction fields, and signs as the fee payer; it returns both
+ * transactions as bytes suitable for sendRaw.
+ *
+ * @deprecated This feature will be removed in v2.
+ *
+ * Parameters:
+ * @param {dict} txn - main transaction from payer's signDynamicFee output (a dict of constructor arguments, NOT a transaction.Transaction)
+ * @param {LogicSig} lsig - the signed logic received from the payer's signDynamicFee output
+ * @param {Uint8Array} privateKey - the private key for the account that pays the fee
+ * @param {int} fee - fee per byte for both transactions
+ *
+ * @throws on invalid lsig
+ */
+/* eslint-disable no-param-reassign */
+function getDynamicFeeTransactions(txn, lsig, privateKey, fee) {
+  if (!lsig.verify(address.decodeAddress(txn.from).publicKey)) {
+    throw new Error('invalid signature');
+  }
+
+  txn.fee = fee;
+  if (txn.fee < transaction.ALGORAND_MIN_TX_FEE) {
+    txn.fee = transaction.ALGORAND_MIN_TX_FEE;
+  }
+
+  const keys = nacl.keyPairFromSecretKey(privateKey);
+  const from = address.encodeAddress(keys.publicKey);
+
+  // must remove lease and re-add using addLease so that fee calculation will match other SDKs
+  const { lease } = txn;
+  delete txn.lease;
+
+  const txnObj = new transaction.Transaction(txn);
+  txnObj.addLease(lease, fee);
+
+  const feePayTxn = {
+    from,
+    to: txn.from,
+    fee,
+    amount: txnObj.fee, // calculated after txnObj is built to have the correct fee
+    firstRound: txn.firstRound,
+    lastRound: txn.lastRound,
+    genesisHash: txn.genesisHash,
+    type: 'pay',
+  };
+  const feePayTxnObj = new transaction.Transaction(feePayTxn);
+  feePayTxnObj.addLease(lease, fee);
+
+  const txnGroup = group.assignGroupID([feePayTxnObj, txnObj], undefined);
+  const feePayTxnWithGroup = txnGroup[0];
+  const txnObjWithGroup = txnGroup[1];
+
+  const lstx = {
+    lsig: lsig.get_obj_for_encoding(),
+    txn: txnObjWithGroup.get_obj_for_encoding(),
+  };
+
+  const stx1 = feePayTxnWithGroup.signTxn(privateKey);
+  const stx2 = encoding.encode(lstx);
+
+  const concatStx = new Uint8Array(stx1.length + stx2.length);
+  concatStx.set(stx1);
+  concatStx.set(stx2, stx1.length);
+
+  return concatStx;
+}
+/* eslint-enable no-param-reassign */
+
+module.exports = {
+  DynamicFee,
+  getDynamicFeeTransactions,
+  signDynamicFee,
+};