algosdk 2.8.0 → 3.0.0-beta.1

package/src/types/transactions/encoded.ts

@@ -1,336 +1,12 @@
-import { Buffer } from 'buffer';
-
-/**
- * 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;
-}
+import {
+  NamedMapSchema,
+  FixedLengthByteArraySchema,
+  Uint64Schema,
+  ArraySchema,
+  OptionalSchema,
+  allOmitEmpty,
+} from '../../encoding/schema/index.js';
+import { ensureSafeUnsignedInteger } from '../../utils/utils.js';
 
 export interface EncodedSubsig {
   /**
@@ -344,6 +20,42 @@ export interface EncodedSubsig {
   s?: Uint8Array;
 }
 
+export const ENCODED_SUBSIG_SCHEMA = new NamedMapSchema(
+  allOmitEmpty([
+    {
+      key: 'pk',
+      valueSchema: new FixedLengthByteArraySchema(32),
+    },
+    {
+      key: 's',
+      valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(64)),
+    },
+  ])
+);
+
+export function encodedSubsigFromEncodingData(data: unknown): EncodedSubsig {
+  if (!(data instanceof Map)) {
+    throw new Error(`Invalid decoded EncodedSubsig: ${data}`);
+  }
+  const subsig: EncodedSubsig = {
+    pk: data.get('pk'),
+  };
+  if (data.get('s')) {
+    subsig.s = data.get('s');
+  }
+  return subsig;
+}
+
+export function encodedSubsigToEncodingData(
+  subsig: EncodedSubsig
+): Map<string, unknown> {
+  const data = new Map<string, unknown>([['pk', subsig.pk]]);
+  if (subsig.s) {
+    data.set('s', subsig.s);
+  }
+  return data;
+}
+
 /**
  * A rough structure for the encoded multi signature transaction object.
  * Every property is labelled with its associated `MultisigMetadata` type property
@@ -365,44 +77,42 @@ export interface EncodedMultisig {
   subsig: EncodedSubsig[];
 }
 
-export interface EncodedLogicSig {
-  l: Uint8Array;
-  arg?: Uint8Array[];
-  sig?: Uint8Array;
-  msig?: EncodedMultisig;
-}
-
-export interface EncodedLogicSigAccount {
-  lsig: EncodedLogicSig;
-  sigkey?: Uint8Array;
+export const ENCODED_MULTISIG_SCHEMA = new NamedMapSchema(
+  allOmitEmpty([
+    {
+      key: 'v',
+      valueSchema: new Uint64Schema(),
+    },
+    {
+      key: 'thr',
+      valueSchema: new Uint64Schema(),
+    },
+    {
+      key: 'subsig',
+      valueSchema: new ArraySchema(ENCODED_SUBSIG_SCHEMA),
+    },
+  ])
+);
+
+export function encodedMultiSigFromEncodingData(
+  data: unknown
+): EncodedMultisig {
+  if (!(data instanceof Map)) {
+    throw new Error(`Invalid decoded EncodedMultiSig: ${data}`);
+  }
+  return {
+    v: ensureSafeUnsignedInteger(data.get('v')),
+    thr: ensureSafeUnsignedInteger(data.get('thr')),
+    subsig: data.get('subsig').map(encodedSubsigFromEncodingData),
+  };
 }
 
-/**
- * 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;
+export function encodedMultiSigToEncodingData(
+  msig: EncodedMultisig
+): Map<string, unknown> {
+  return new Map<string, unknown>([
+    ['v', msig.v],
+    ['thr', msig.thr],
+    ['subsig', msig.subsig.map(encodedSubsigToEncodingData)],
+  ]);
 }

package/src/types/transactions/index.ts

@@ -1,72 +1,2 @@
-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;
+export * from './base.js';
+export * from './encoded.js';

package/src/types/utils.ts

@@ -5,8 +5,8 @@
 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;
+    ? { [K in keyof O]: O[K] }
+    : never;
 
 /**
  * Same as TypeScript's Pick, but will distribute the Pick over unions
@@ -59,5 +59,5 @@ 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

@@ -1,32 +1,30 @@
 import JSONbigWithoutConfig from 'json-bigint';
-import IntDecoding from '../types/intDecoding';
+import IntDecoding from '../types/intDecoding.js';
 
-const JSONbig = JSONbigWithoutConfig({ useNativeBigInt: true, strict: true });
+const JSONbig = JSONbigWithoutConfig({
+  useNativeBigInt: true,
+  strict: true,
+});
 
-export interface JSONOptions {
-  intDecoding?: IntDecoding;
+export interface ParseJSONOptions {
+  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.
+ * @param options - Configures how integers in this JSON string will be decoded. See the
+ *   `IntDecoding` enum for more details.
  */
-export function parseJSON(str: string, options?: JSONOptions) {
-  const intDecoding =
-    options && options.intDecoding ? options.intDecoding : IntDecoding.DEFAULT;
+export function parseJSON(str: string, { intDecoding }: ParseJSONOptions) {
+  if (
+    intDecoding !== IntDecoding.SAFE &&
+    intDecoding !== IntDecoding.UNSAFE &&
+    intDecoding !== IntDecoding.BIGINT &&
+    intDecoding !== IntDecoding.MIXED
+  ) {
+    throw new Error(`Invalid intDecoding option: ${intDecoding}`);
+  }
   return JSONbig.parse(str, (_, value) => {
     if (
       value != null &&
@@ -39,14 +37,14 @@ export function parseJSON(str: string, options?: JSONOptions) {
     }
 
     if (typeof value === 'bigint') {
-      if (intDecoding === 'safe' && value > Number.MAX_SAFE_INTEGER) {
+      if (intDecoding === 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)
+        intDecoding === IntDecoding.BIGINT ||
+        (intDecoding === IntDecoding.MIXED && value > Number.MAX_SAFE_INTEGER)
       ) {
         return value;
       }
@@ -56,7 +54,7 @@ export function parseJSON(str: string, options?: JSONOptions) {
     }
 
     if (typeof value === 'number') {
-      if (intDecoding === 'bigint' && Number.isInteger(value)) {
+      if (intDecoding === IntDecoding.BIGINT && Number.isInteger(value)) {
         return BigInt(value);
       }
     }
@@ -65,10 +63,29 @@ export function parseJSON(str: string, options?: JSONOptions) {
   });
 }
 
+/**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ *
+ * This functions differs from the built-in JSON.stringify in that it supports serializing BigInts.
+ *
+ * This function takes the same arguments as the built-in JSON.stringify function.
+ *
+ * @param value - A JavaScript value, usually an object or array, to be converted.
+ * @param replacer - A function that transforms the results.
+ * @param space - Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ */
+export function stringifyJSON(
+  value: any,
+  replacer?: (this: any, key: string, value: any) => any,
+  space?: string | number
+): string {
+  return JSONbig.stringify(value, replacer, space);
+}
+
 /**
  * ArrayEqual takes two arrays and return true if equal, false otherwise
  */
-export function arrayEqual(a: ArrayLike<any>, b: ArrayLike<any>) {
+export function arrayEqual<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean {
   if (a.length !== b.length) {
     return false;
   }
@@ -134,3 +151,57 @@ export function isReactNative() {
   }
   return false;
 }
+
+export function ensureSafeInteger(value: unknown): number {
+  if (typeof value === 'undefined') {
+    throw new Error('Value is undefined');
+  }
+  if (typeof value === 'bigint') {
+    if (
+      value > BigInt(Number.MAX_SAFE_INTEGER) ||
+      value < BigInt(Number.MIN_SAFE_INTEGER)
+    ) {
+      throw new Error(`BigInt value ${value} is not a safe integer`);
+    }
+    return Number(value);
+  }
+  if (typeof value === 'number') {
+    if (Number.isSafeInteger(value)) {
+      return value;
+    }
+    throw new Error(`Value ${value} is not a safe integer`);
+  }
+  throw new Error(`Unexpected type ${typeof value}, ${value}`);
+}
+
+export function ensureSafeUnsignedInteger(value: unknown): number {
+  const intValue = ensureSafeInteger(value);
+  if (intValue < 0) {
+    throw new Error(`Value ${intValue} is negative`);
+  }
+  return intValue;
+}
+
+export function ensureBigInt(value: unknown): bigint {
+  if (typeof value === 'undefined') {
+    throw new Error('Value is undefined');
+  }
+  if (typeof value === 'bigint') {
+    return value;
+  }
+  if (typeof value === 'number') {
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`Value ${value} is not a safe integer`);
+    }
+    return BigInt(value);
+  }
+  throw new Error(`Unexpected type ${typeof value}, ${value}`);
+}
+
+export function ensureUint64(value: unknown): bigint {
+  const bigIntValue = ensureBigInt(value);
+  if (bigIntValue < 0 || bigIntValue > BigInt('0xffffffffffffffff')) {
+    throw new Error(`Value ${bigIntValue} is not a uint64`);
+  }
+  return bigIntValue;
+}