algosdk 1.24.0 → 2.0.0

package/src/types/transactions/encoded.ts

@@ -0,0 +1,406 @@
+/**
+ * Interfaces for the encoded transaction object. Every property is labelled with its associated Transaction type property
+ */
+
+export interface EncodedAssetParams {
+  /**
+   * assetTotal
+   */
+  t: number | bigint;
+
+  /**
+   * assetDefaultFrozen
+   */
+  df: boolean;
+
+  /**
+   * assetDecimals
+   */
+  dc: number;
+
+  /**
+   * assetManager
+   */
+  m?: Buffer;
+
+  /**
+   * assetReserve
+   */
+  r?: Buffer;
+
+  /**
+   * assetFreeze
+   */
+  f?: Buffer;
+
+  /**
+   * assetClawback
+   */
+  c?: Buffer;
+
+  /**
+   * assetName
+   */
+  an?: string;
+
+  /**
+   * assetUnitName
+   */
+  un?: string;
+
+  /**
+   * assetURL
+   */
+  au?: string;
+
+  /**
+   * assetMetadataHash
+   */
+  am?: Buffer;
+}
+
+export interface EncodedLocalStateSchema {
+  /**
+   * appLocalInts
+   */
+  nui: number;
+
+  /**
+   * appLocalByteSlices
+   */
+  nbs: number;
+}
+
+export interface EncodedGlobalStateSchema {
+  /**
+   * appGlobalInts
+   */
+  nui: number;
+
+  /**
+   * appGlobalByteSlices
+   */
+  nbs: number;
+}
+
+export interface EncodedBoxReference {
+  /**
+   * index of the app ID in the foreign apps array
+   */
+  i: number;
+
+  /**
+   * box name
+   */
+  n: Uint8Array;
+}
+
+/**
+ * A rough structure for the encoded transaction object. Every property is labelled with its associated Transaction type property
+ */
+export interface EncodedTransaction {
+  /**
+   * fee
+   */
+  fee?: number;
+
+  /**
+   * firstRound
+   */
+  fv?: number;
+
+  /**
+   * lastRound
+   */
+  lv: number;
+
+  /**
+   * note
+   */
+  note?: Buffer;
+
+  /**
+   * from
+   */
+  snd: Buffer;
+
+  /**
+   * type
+   */
+  type: string;
+
+  /**
+   * genesisID
+   */
+  gen: string;
+
+  /**
+   * genesisHash
+   */
+  gh: Buffer;
+
+  /**
+   * lease
+   */
+  lx?: Buffer;
+
+  /**
+   * group
+   */
+  grp?: Buffer;
+
+  /**
+   * amount
+   */
+  amt?: number | bigint;
+
+  /**
+   * amount (but for asset transfers)
+   */
+  aamt?: number | bigint;
+
+  /**
+   * closeRemainderTo
+   */
+  close?: Buffer;
+
+  /**
+   * closeRemainderTo (but for asset transfers)
+   */
+  aclose?: Buffer;
+
+  /**
+   * reKeyTo
+   */
+  rekey?: Buffer;
+
+  /**
+   * to
+   */
+  rcv?: Buffer;
+
+  /**
+   * to (but for asset transfers)
+   */
+  arcv?: Buffer;
+
+  /**
+   * voteKey
+   */
+  votekey?: Buffer;
+
+  /**
+   * selectionKey
+   */
+  selkey?: Buffer;
+
+  /**
+   * stateProofKey
+   */
+  sprfkey?: Buffer;
+
+  /**
+   * voteFirst
+   */
+  votefst?: number;
+
+  /**
+   * voteLast
+   */
+  votelst?: number;
+
+  /**
+   * voteKeyDilution
+   */
+  votekd?: number;
+
+  /**
+   * nonParticipation
+   */
+  nonpart?: boolean;
+
+  /**
+   * assetIndex
+   */
+  caid?: number;
+
+  /**
+   * assetIndex (but for asset transfers)
+   */
+  xaid?: number;
+
+  /**
+   * assetIndex (but for asset freezing/unfreezing)
+   */
+  faid?: number;
+
+  /**
+   * freezeState
+   */
+  afrz?: boolean;
+
+  /**
+   * freezeAccount
+   */
+  fadd?: Buffer;
+
+  /**
+   * assetRevocationTarget
+   */
+  asnd?: Buffer;
+
+  /**
+   * See EncodedAssetParams type
+   */
+  apar?: EncodedAssetParams;
+
+  /**
+   * appIndex
+   */
+  apid?: number;
+
+  /**
+   * appOnComplete
+   */
+  apan?: number;
+
+  /**
+   * See EncodedLocalStateSchema type
+   */
+  apls?: EncodedLocalStateSchema;
+
+  /**
+   * See EncodedGlobalStateSchema type
+   */
+  apgs?: EncodedGlobalStateSchema;
+
+  /**
+   * appForeignApps
+   */
+  apfa?: number[];
+
+  /**
+   * appForeignAssets
+   */
+  apas?: number[];
+
+  /**
+   * appApprovalProgram
+   */
+  apap?: Buffer;
+
+  /**
+   * appClearProgram
+   */
+  apsu?: Buffer;
+
+  /**
+   * appArgs
+   */
+  apaa?: Buffer[];
+
+  /**
+   * appAccounts
+   */
+  apat?: Buffer[];
+
+  /**
+   * extraPages
+   */
+  apep?: number;
+
+  /**
+   * boxes
+   */
+  apbx?: EncodedBoxReference[];
+
+  /*
+   * stateProofType
+   */
+  sptype?: number | bigint;
+
+  /**
+   * stateProof
+   */
+  sp?: Buffer;
+
+  /**
+   * stateProofMessage
+   */
+  spmsg?: Buffer;
+}
+
+export interface EncodedSubsig {
+  /**
+   *  The public key
+   */
+  pk: Uint8Array;
+
+  /**
+   * The signature provided by the public key, if any
+   */
+  s?: Uint8Array;
+}
+
+/**
+ * A rough structure for the encoded multi signature transaction object.
+ * Every property is labelled with its associated `MultisigMetadata` type property
+ */
+export interface EncodedMultisig {
+  /**
+   * version
+   */
+  v: number;
+
+  /**
+   * threshold
+   */
+  thr: number;
+
+  /**
+   * Subset of signatures. A threshold of `thr` signors is required.
+   */
+  subsig: EncodedSubsig[];
+}
+
+export interface EncodedLogicSig {
+  l: Uint8Array;
+  arg?: Uint8Array[];
+  sig?: Uint8Array;
+  msig?: EncodedMultisig;
+}
+
+export interface EncodedLogicSigAccount {
+  lsig: EncodedLogicSig;
+  sigkey?: Uint8Array;
+}
+
+/**
+ * A structure for an encoded signed transaction object
+ */
+export interface EncodedSignedTransaction {
+  /**
+   * Transaction signature
+   */
+  sig?: Buffer;
+
+  /**
+   * The transaction that was signed
+   */
+  txn: EncodedTransaction;
+
+  /**
+   * Multisig structure
+   */
+  msig?: EncodedMultisig;
+
+  /**
+   * Logic signature
+   */
+  lsig?: EncodedLogicSig;
+
+  /**
+   * The signer, if signing with a different key than the Transaction type `from` property indicates
+   */
+  sgnr?: Buffer;
+}

package/src/types/transactions/index.ts

@@ -0,0 +1,72 @@
+import PaymentTxn from './payment';
+import KeyRegistrationTxn from './keyreg';
+import {
+  AssetCreateTransaction as AssetCreateTxn,
+  AssetConfigurationTransaction as AssetConfigTxn,
+  AssetDestroyTransaction as AssetDestroyTxn,
+  AssetFreezeTransaction as AssetFreezeTxn,
+  AssetTransferTransaction as AssetTransferTxn,
+} from './asset';
+import {
+  ApplicationCreateTransaction as AppCreateTxn,
+  ApplicationUpdateTransaction as AppUpdateTxn,
+  ApplicationDeleteTransaction as AppDeleteTxn,
+  ApplicationOptInTransaction as AppOptInTxn,
+  ApplicationCloseOutTransaction as AppCloseOutTxn,
+  ApplicationClearStateTransaction as AppClearStateTxn,
+  ApplicationNoOpTransaction as AppNoOpTxn,
+} from './application';
+import StateProofTxn from './stateproof';
+
+// Utilities
+export {
+  TransactionParams,
+  TransactionType,
+  SuggestedParams,
+  BoxReference,
+} from './base';
+export {
+  MustHaveSuggestedParams,
+  MustHaveSuggestedParamsInline,
+} from './builder';
+export * from './encoded';
+
+// Transaction types
+export { default as PaymentTxn } from './payment';
+export { default as KeyRegistrationTxn } from './keyreg';
+export {
+  AssetCreateTransaction as AssetCreateTxn,
+  AssetConfigurationTransaction as AssetConfigTxn,
+  AssetDestroyTransaction as AssetDestroyTxn,
+  AssetFreezeTransaction as AssetFreezeTxn,
+  AssetTransferTransaction as AssetTransferTxn,
+} from './asset';
+export {
+  ApplicationCreateTransaction as AppCreateTxn,
+  ApplicationUpdateTransaction as AppUpdateTxn,
+  ApplicationDeleteTransaction as AppDeleteTxn,
+  ApplicationOptInTransaction as AppOptInTxn,
+  ApplicationCloseOutTransaction as AppCloseOutTxn,
+  ApplicationClearStateTransaction as AppClearStateTxn,
+  ApplicationNoOpTransaction as AppNoOpTxn,
+} from './application';
+export { default as StateProofTxn } from './stateproof';
+
+// All possible transaction types
+type AnyTransaction =
+  | PaymentTxn
+  | KeyRegistrationTxn
+  | AssetCreateTxn
+  | AssetConfigTxn
+  | AssetDestroyTxn
+  | AssetFreezeTxn
+  | AssetTransferTxn
+  | AppCreateTxn
+  | AppUpdateTxn
+  | AppDeleteTxn
+  | AppOptInTxn
+  | AppCloseOutTxn
+  | AppClearStateTxn
+  | AppNoOpTxn
+  | StateProofTxn;
+export default AnyTransaction;

package/src/types/transactions/keyreg.ts

@@ -0,0 +1,23 @@
+import { TransactionType, TransactionParams } from './base';
+import { ConstructTransaction } from './builder';
+
+type SpecificParameters = Pick<
+  TransactionParams,
+  | 'voteKey'
+  | 'selectionKey'
+  | 'stateProofKey'
+  | 'voteFirst'
+  | 'voteLast'
+  | 'voteKeyDilution'
+  | 'nonParticipation'
+>;
+
+interface Overwrites {
+  type?: TransactionType.keyreg;
+}
+
+type KeyRegistrationTransaction = ConstructTransaction<
+  SpecificParameters,
+  Overwrites
+>;
+export default KeyRegistrationTransaction;

package/src/types/transactions/payment.ts

@@ -0,0 +1,14 @@
+import { TransactionType, TransactionParams } from './base';
+import { ConstructTransaction } from './builder';
+
+type SpecificParameters = Pick<
+  TransactionParams,
+  'to' | 'amount' | 'closeRemainderTo'
+>;
+
+interface Overwrites {
+  type?: TransactionType.pay;
+}
+
+type PaymentTransaction = ConstructTransaction<SpecificParameters, Overwrites>;
+export default PaymentTransaction;

package/src/types/transactions/stateproof.ts

@@ -0,0 +1,17 @@
+import { TransactionType, TransactionParams } from './base';
+import { ConstructTransaction } from './builder';
+
+type SpecificParameters = Pick<
+  TransactionParams,
+  'stateProofType' | 'stateProof' | 'stateProofMessage'
+>;
+
+interface Overwrites {
+  type?: TransactionType.stpf;
+}
+
+type StateProofTransaction = ConstructTransaction<
+  SpecificParameters,
+  Overwrites
+>;
+export default StateProofTransaction;

package/src/types/utils.ts

@@ -0,0 +1,63 @@
+/**
+ * Expands types for IntelliSense so they are more human readable
+ * See https://stackoverflow.com/a/69288824
+ */
+export type Expand<T> = T extends (...args: infer A) => infer R
+  ? (...args: Expand<A>) => Expand<R>
+  : T extends infer O
+  ? { [K in keyof O]: O[K] }
+  : never;
+
+/**
+ * Same as TypeScript's Pick, but will distribute the Pick over unions
+ */
+export type DistributivePick<T, K extends keyof T> = T extends unknown
+  ? Pick<T, K>
+  : never;
+
+/**
+ * Overwrite a type with properties from another type
+ */
+export type Overwrite<T, U extends Partial<T>> = Pick<
+  T,
+  Exclude<keyof T, keyof U>
+> &
+  U;
+
+/**
+ * Same as Overwrite, but will distribute the Overwrite over unions
+ */
+export type DistributiveOverwrite<T, K> = T extends unknown
+  ? Overwrite<T, K>
+  : never;
+
+/**
+ * Mark certain keys as prohibited
+ */
+export type NeverAllow<T, K extends keyof T> = {
+  // eslint-disable-next-line no-unused-vars
+  [P in K]?: never;
+};
+
+/**
+ * Rename a specific property of a type to another name
+ *
+ * Usage: RenameProperty\<\{ a: string \}, 'a', 'b'\>
+ * -\> \{ b: string \}
+ */
+export type RenameProperty<T, K extends keyof T, R extends PropertyKey> = {
+  [P in keyof T as P extends K ? R : P]: T[P];
+};
+
+/**
+ * Rename multiple properties of one type to another name
+ *
+ * Usage: RenameProperties\<\{ a: string, b: number \}, \{ a: 'c', b: 'd' \}\>
+ * -\> \{ c: string, d: number \}
+ */
+export type RenameProperties<
+  T,
+  R extends {
+    [K in keyof R]: K extends keyof T ? PropertyKey : 'Error: key not in T';
+  }
+> = { [P in keyof T as P extends keyof R ? R[P] : P]: T[P] };

package/src/utils/utils.ts

@@ -0,0 +1,121 @@
+import JSONbigWithoutConfig from 'json-bigint';
+import IntDecoding from '../types/intDecoding';
+
+const JSONbig = JSONbigWithoutConfig({ useNativeBigInt: true, strict: true });
+
+export interface JSONOptions {
+  intDecoding?: IntDecoding;
+}
+
+/**
+ * Parse JSON with additional options.
+ * @param str - The JSON string to parse.
+ * @param options - Options object to configure how integers in
+ *   this request's JSON response will be decoded. Use the `intDecoding`
+ *   property with one of the following options:
+ *
+ *   * "default": All integers will be decoded as Numbers, meaning any values greater than
+ *     Number.MAX_SAFE_INTEGER will lose precision.
+ *   * "safe": All integers will be decoded as Numbers, but if any values are greater than
+ *     Number.MAX_SAFE_INTEGER an error will be thrown.
+ *   * "mixed": Integers will be decoded as Numbers if they are less than or equal to
+ *     Number.MAX_SAFE_INTEGER, otherwise they will be decoded as BigInts.
+ *   * "bigint": All integers will be decoded as BigInts.
+ *
+ *   Defaults to "default" if not included.
+ */
+export function parseJSON(str: string, options?: JSONOptions) {
+  const intDecoding =
+    options && options.intDecoding ? options.intDecoding : IntDecoding.DEFAULT;
+  return JSONbig.parse(str, (_, value) => {
+    if (
+      value != null &&
+      typeof value === 'object' &&
+      Object.getPrototypeOf(value) == null
+    ) {
+      // JSONbig.parse objects are created with Object.create(null) and thus have a null prototype
+      // let us remedy that
+      Object.setPrototypeOf(value, Object.prototype);
+    }
+
+    if (typeof value === 'bigint') {
+      if (intDecoding === 'safe' && value > Number.MAX_SAFE_INTEGER) {
+        throw new Error(
+          `Integer exceeds maximum safe integer: ${value.toString()}. Try parsing with a different intDecoding option.`
+        );
+      }
+      if (
+        intDecoding === 'bigint' ||
+        (intDecoding === 'mixed' && value > Number.MAX_SAFE_INTEGER)
+      ) {
+        return value;
+      }
+      // JSONbig.parse converts number to BigInts if they are >= 10**15. This is smaller than
+      // Number.MAX_SAFE_INTEGER, so we can convert some BigInts back to normal numbers.
+      return Number(value);
+    }
+
+    if (typeof value === 'number') {
+      if (intDecoding === 'bigint' && Number.isInteger(value)) {
+        return BigInt(value);
+      }
+    }
+
+    return value;
+  });
+}
+
+/**
+ * ArrayEqual takes two arrays and return true if equal, false otherwise
+ */
+export function arrayEqual(a: ArrayLike<any>, b: ArrayLike<any>) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return Array.from(a).every((val, i) => val === b[i]);
+}
+
+/**
+ * ConcatArrays takes n number arrays and returns a joint Uint8Array
+ * @param arrs - An arbitrary number of n array-like number list arguments
+ * @returns [a,b]
+ */
+export function concatArrays(...arrs: ArrayLike<number>[]) {
+  const size = arrs.reduce((sum, arr) => sum + arr.length, 0);
+  const c = new Uint8Array(size);
+
+  let offset = 0;
+  for (let i = 0; i < arrs.length; i++) {
+    c.set(arrs[i], offset);
+    offset += arrs[i].length;
+  }
+
+  return c;
+}
+
+/**
+ * Remove undefined properties from an object
+ * @param obj - An object, preferably one with some undefined properties
+ * @returns A copy of the object with undefined properties removed
+ */
+export function removeUndefinedProperties(
+  obj: Record<string | number | symbol, any>
+) {
+  const mutableCopy = { ...obj };
+  Object.keys(mutableCopy).forEach((key) => {
+    if (typeof mutableCopy[key] === 'undefined') delete mutableCopy[key];
+  });
+  return mutableCopy;
+}
+
+/**
+ * Check whether the environment is Node.js (as opposed to the browser)
+ * @returns True if Node.js environment, false otherwise
+ */
+export function isNode() {
+  return (
+    typeof process === 'object' &&
+    typeof process.versions === 'object' &&
+    typeof process.versions.node !== 'undefined'
+  );
+}