algosdk 2.8.0 → 3.0.0-beta.1

package/dist/types/encoding/encoding.d.ts

@@ -9,19 +9,231 @@
  *  4. Every positive number must be encoded as uint
  *  5. Binary blob should be used for binary data and string for strings
  *  */
+import { RawBinaryString } from 'algorand-msgpack';
+import IntDecoding from '../types/intDecoding.js';
 export declare const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
 /**
- * rawEncode encodes objects using msgpack, regardless of whether there are
+ * msgpackRawEncode encodes objects using msgpack, regardless of whether there are
  * empty or 0 value fields.
  * @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.
  * @returns msgpack representation of the object
  */
-export declare function rawEncode(obj: Record<string | number | symbol, any>): Uint8Array;
+export declare function msgpackRawEncode(obj: unknown): Uint8Array;
 /**
- * encode encodes objects using msgpack
- * @param obj - a dictionary to be encoded. Must not contain empty or 0 values.
- * @returns msgpack representation of the object
+ * encodeObj takes a javascript object and returns its msgpack encoding
+ * Note that the encoding sorts the fields alphabetically
+ * @param o - js object to be encoded. Must not contain empty or 0 values.
+ * @returns Uint8Array binary representation
  * @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values
+ *
+ * @deprecated Use {@link msgpackRawEncode} instead. Note that function does not
+ *   check for empty values like this one does.
+ */
+export declare function encodeObj(obj: Record<string | number | symbol, any>): Uint8Array;
+/**
+ * Decodes msgpack bytes into a plain JavaScript object.
+ * @param buffer - The msgpack bytes to decode
+ * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+ * @returns The decoded object
+ */
+export declare function msgpackRawDecode(buffer: ArrayLike<number>, options?: {
+    intDecoding: IntDecoding;
+}): unknown;
+/**
+ * decodeObj takes a Uint8Array and returns its javascript obj
+ * @param o - Uint8Array to decode
+ * @returns object
+ *
+ * @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`
+ *   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is
+ *   configurable.
+ */
+export declare function decodeObj(o: ArrayLike<number>): unknown;
+/**
+ * Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.
+ * @param encoded - The msgpack bytes to decode
+ * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+ * @returns The decoded Map object
+ */
+export declare function msgpackRawDecodeAsMap(encoded: ArrayLike<number>, options?: {
+    intDecoding: IntDecoding;
+}): unknown;
+export type MsgpackEncodingData = null | undefined | string | number | bigint | boolean | Uint8Array | MsgpackEncodingData[] | Map<string | number | bigint | Uint8Array, MsgpackEncodingData>;
+export type JSONEncodingData = null | undefined | string | number | bigint | boolean | JSONEncodingData[] | {
+    [key: string]: JSONEncodingData;
+};
+export declare function msgpackEncodingDataToJSONEncodingData(e: MsgpackEncodingData): JSONEncodingData;
+export declare function jsonEncodingDataToMsgpackEncodingData(e: JSONEncodingData): MsgpackEncodingData;
+declare enum MsgpackObjectPathSegmentKind {
+    MAP_VALUE = 0,
+    ARRAY_ELEMENT = 1
+}
+interface MsgpackObjectPathSegment {
+    kind: MsgpackObjectPathSegmentKind;
+    key: string | number | bigint | Uint8Array | RawBinaryString;
+}
+/**
+ * This class is used to index into an encoded msgpack object and extract raw strings.
+ */
+export declare class MsgpackRawStringProvider {
+    private readonly parent?;
+    private readonly baseObjectBytes?;
+    private readonly segment?;
+    private resolvedCache;
+    private resolvedCachePresent;
+    constructor({ parent, segment, baseObjectBytes, }: {
+        parent: MsgpackRawStringProvider;
+        segment: MsgpackObjectPathSegment;
+        baseObjectBytes?: undefined;
+    } | {
+        parent?: undefined;
+        segment?: undefined;
+        baseObjectBytes: ArrayLike<number>;
+    });
+    /**
+     * Create a new provider that resolves to the current provider's map value at the given key.
+     */
+    withMapValue(key: string | number | bigint | Uint8Array | RawBinaryString): MsgpackRawStringProvider;
+    /**
+     * Create a new provider that resolves to the current provider's array element at the given index.
+     */
+    withArrayElement(index: number): MsgpackRawStringProvider;
+    /**
+     * Get the raw string at the current location. If the current location is not a raw string, an error is thrown.
+     */
+    getRawStringAtCurrentLocation(): Uint8Array;
+    /**
+     * Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.
+     */
+    getRawStringKeysAndValuesAtCurrentLocation(): Map<Uint8Array, MsgpackEncodingData>;
+    /**
+     * Resolve the provider by extracting the value it indicates from the base msgpack object.
+     */
+    private resolve;
+    /**
+     * Get the path string of the current location indicated by the provider. Useful for debugging.
+     */
+    getPathString(): string;
+}
+/**
+ * Options for {@link Schema.prepareJSON}
+ */
+export interface PrepareJSONOptions {
+    /**
+     * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+     *
+     * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+     */
+    lossyBinaryStringConversion?: boolean;
+}
+/**
+ * A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.
+ *
+ * Schemas represent a specific type.
+ */
+export declare abstract class Schema {
+    /**
+     * Get the default value for this type.
+     */
+    abstract defaultValue(): unknown;
+    /**
+     * Checks if the value is the default value for this type.
+     * @param data - The value to check
+     * @returns True if the value is the default value, false otherwise
+     */
+    abstract isDefaultValue(data: unknown): boolean;
+    /**
+     * Prepares the encoding data for encoding to msgpack.
+     * @param data - Encoding data to be prepared.
+     * @returns A value ready to be msgpack encoded.
+     */
+    abstract prepareMsgpack(data: unknown): MsgpackEncodingData;
+    /**
+     * Restores the encoding data from a msgpack encoding object.
+     * @param encoded - The msgpack encoding object to restore.
+     * @param rawStringProvider - A provider for raw strings.
+     * @returns The original encoding data.
+     */
+    abstract fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown;
+    /**
+     * Prepares the encoding data for encoding to JSON.
+     * @param data - The JSON encoding data to be prepared.
+     * @returns A value ready to be JSON encoded.
+     */
+    abstract prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    /**
+     * Restores the encoding data from a JSON encoding object.
+     * @param encoded - The JSON encoding object to restore.
+     * @returns The original encoding data.
+     */
+    abstract fromPreparedJSON(encoded: JSONEncodingData): unknown;
+}
+/**
+ * An interface for objects that can be encoded and decoded to/from msgpack and JSON.
+ */
+export interface Encodable {
+    /**
+     * Extract the encoding data for this object. This data, after being prepared by the encoding
+     * Schema, can be encoded to msgpack or JSON.
+     */
+    toEncodingData(): unknown;
+    /**
+     * Get the encoding Schema for this object, used to prepare the encoding data for msgpack and JSON.
+     */
+    getEncodingSchema(): Schema;
+}
+/**
+ * A type that represents the class of an Encodable object.
+ */
+export interface EncodableClass<T extends Encodable> {
+    /**
+     * Create a new instance of this class from the given encoding data.
+     * @param data - The encoding data to create the object from
+     */
+    fromEncodingData(data: unknown): T;
+    /**
+     * The encoding Schema for this class, used to prepare encoding data from msgpack and JSON.
+     */
+    readonly encodingSchema: Schema;
+}
+/**
+ * Decode a msgpack byte array to an Encodable object.
+ * @param encoded - The msgpack bytes to decode
+ * @param c - The class of the object to decode. This class must match the object that was encoded.
+ * @returns An instance of the class with the decoded data
+ */
+export declare function decodeMsgpack<T extends Encodable>(encoded: ArrayLike<number>, c: EncodableClass<T>): T;
+/**
+ * Encode an Encodable object to a msgpack byte array.
+ * @param e - The object to encode
+ * @returns A msgpack byte array encoding of the object
+ */
+export declare function encodeMsgpack(e: Encodable): Uint8Array;
+/**
+ * Decode a JSON string to an Encodable object.
+ * @param encoded - The JSON string to decode
+ * @param c - The class of the object to decode. This class must match the object that was encoded.
+ * @returns An instance of the class with the decoded data
+ */
+export declare function decodeJSON<T extends Encodable>(encoded: string, c: EncodableClass<T>): T;
+export interface EncodeJSONOptions {
+    /**
+     * Adds indentation, white space, and line break characters to the return-value JSON text to make
+     * it easier to read.
+     */
+    space?: string | number;
+    /**
+     * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+     *
+     * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+     */
+    lossyBinaryStringConversion?: boolean;
+}
+/**
+ * Encode an Encodable object to a JSON string.
+ * @param e - The object to encode
+ * @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.
+ * @returns A JSON string encoding of the object
  */
-export declare function encode(obj: Record<string | number | symbol, any>): Uint8Array;
-export declare function decode(buffer: ArrayLike<number>): unknown;
+export declare function encodeJSON(e: Encodable, options?: EncodeJSONOptions): string;
+export {};

package/dist/types/encoding/schema/address.d.ts

@@ -0,0 +1,10 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+import { Address } from '../address.js';
+export declare class AddressSchema extends Schema {
+    defaultValue(): Address;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Address;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Address;
+}

package/dist/types/encoding/schema/array.d.ts

@@ -0,0 +1,11 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class ArraySchema extends Schema {
+    readonly itemSchema: Schema;
+    constructor(itemSchema: Schema);
+    defaultValue(): unknown[];
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown[];
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): unknown[];
+}

package/dist/types/encoding/schema/binarystring.d.ts

@@ -0,0 +1,18 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * SpecialCaseBinaryStringSchema is a schema for byte arrays which are encoded
+ * as strings in msgpack and JSON.
+ *
+ * This schema allows lossless conversion between the in memory representation
+ * and the msgpack encoded representation, but NOT between the in memory and
+ * JSON encoded representations if the byte array contains invalid UTF-8
+ * sequences.
+ */
+export declare class SpecialCaseBinaryStringSchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(_encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/blockhash.d.ts

@@ -0,0 +1,16 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * BlockHashSchema is a schema for block hashes.
+ *
+ * In msgapck, these types are encoded as 32-byte binary strings. In JSON, they
+ * are encoded as strings prefixed with "blk-" followed by the base32 encoding
+ * of the 32-byte block hash without any padding.
+ */
+export declare class BlockHashSchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/boolean.d.ts

@@ -0,0 +1,10 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class BooleanSchema extends Schema {
+    defaultValue(): boolean;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): boolean;
+    prepareJSON(data: unknown, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): boolean;
+}

package/dist/types/encoding/schema/bytearray.d.ts

@@ -0,0 +1,19 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class ByteArraySchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}
+export declare class FixedLengthByteArraySchema extends Schema {
+    readonly length: number;
+    constructor(length: number);
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/index.d.ts

@@ -0,0 +1,11 @@
+export { BooleanSchema } from './boolean.js';
+export { StringSchema } from './string.js';
+export { Uint64Schema } from './uint64.js';
+export { AddressSchema } from './address.js';
+export { ByteArraySchema, FixedLengthByteArraySchema } from './bytearray.js';
+export { BlockHashSchema } from './blockhash.js';
+export { SpecialCaseBinaryStringSchema } from './binarystring.js';
+export { ArraySchema } from './array.js';
+export { NamedMapSchema, NamedMapEntry, allOmitEmpty, combineMaps, convertMap, Uint64MapSchema, StringMapSchema, ByteArrayMapSchema, SpecialCaseBinaryStringMapSchema, } from './map.js';
+export { OptionalSchema } from './optional.js';
+export { UntypedSchema } from './untyped.js';

package/dist/types/encoding/schema/map.d.ts

@@ -0,0 +1,125 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * Describes a key-value entry in a NamedMapSchema.
+ */
+export interface NamedMapEntry {
+    /**
+     * Key of the entry. Must be unique for this map.
+     */
+    key: string;
+    /**
+     * The Schema for the entry's value.
+     */
+    valueSchema: Schema;
+    /**
+     * If true, the entry will be omitted from the encoding if the value is the default value.
+     */
+    omitEmpty: boolean;
+    /**
+     * If true, valueSchema must be a NamedMapSchema and key must be the empty string. The fields of
+     * valueSchema will be embedded directly in the parent map.
+     *
+     * omitEmpty is ignored for embedded entries. Instead, the individual omitEmpty values of the
+     * embedded fields are used.
+     */
+    embedded?: boolean;
+}
+/**
+ * Applies the omitEmpty flag to all entries in the array.
+ * @param entries - The entries to apply the flag to.
+ * @returns A new array with the omitEmpty flag applied to all entries.
+ */
+export declare function allOmitEmpty(entries: Array<Omit<NamedMapEntry, 'omitEmpty'>>): NamedMapEntry[];
+/**
+ * Schema for a map/struct with a fixed set of known string fields.
+ */
+export declare class NamedMapSchema extends Schema {
+    private readonly entries;
+    constructor(entries: NamedMapEntry[]);
+    /**
+     * Adds new entries to the map schema. WARNING: this is a mutable operation, and you should be very
+     * careful when using it. Any error that happens here is non-recoverable and will corrupt the
+     * NamedMapSchema object;
+     * @param entries - The entries to add.
+     */
+    pushEntries(...entries: NamedMapEntry[]): void;
+    private checkEntries;
+    /**
+     * Returns all top-level entries, properly accounting for fields from embedded entries.
+     * @returns An array of all top-level entries for this map.
+     */
+    getEntries(): NamedMapEntry[];
+    defaultValue(): Map<string, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<string, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<string, unknown>;
+}
+/**
+ * Combines multiple maps into a single map. Throws an error if any of the maps have duplicate keys.
+ * @param maps - The maps to combine.
+ * @returns A new map with all the entries from the input maps.
+ */
+export declare function combineMaps<K, V>(...maps: Array<Map<K, V>>): Map<K, V>;
+/**
+ * Converts a map to a new map with different keys and values.
+ * @param map - The map to convert.
+ * @param func - The function to convert each entry.
+ * @returns A new map with the converted entries.
+ */
+export declare function convertMap<K1, V1, K2, V2>(map: Map<K1, V1>, func: (k: K1, v: V1) => [K2, V2]): Map<K2, V2>;
+/**
+ * Schema for a map with a variable number of uint64 keys.
+ */
+export declare class Uint64MapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<bigint, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<bigint, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<bigint, unknown>;
+}
+/**
+ * Schema for a map with a variable number of string keys.
+ */
+export declare class StringMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<string, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<string, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<string, unknown>;
+}
+/**
+ * Schema for a map with a variable number of byte array keys.
+ */
+export declare class ByteArrayMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<Uint8Array, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<Uint8Array, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<Uint8Array, unknown>;
+}
+/**
+ * Schema for a map with a variable number of binary string keys.
+ *
+ * See SpecialCaseBinaryStringSchema for more information about the key type.
+ */
+export declare class SpecialCaseBinaryStringMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<Uint8Array, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(_encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<Uint8Array, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<Uint8Array, unknown>;
+}

package/dist/types/encoding/schema/optional.d.ts

@@ -0,0 +1,24 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * OptionalSchema allows for another schema-defined value to be optional.
+ *
+ * This expands the set of values which can be represented by the given schema to include `undefined`.
+ *
+ * Note that this schema considers `undefined` _and_ any default values from the underlying schema
+ * to all be default values. This means that when using NamedMapSchema to omit default values, an
+ * `undefined` value is indistinguishable from the given schema's default value; in this respect,
+ * OptionalSchema does not affect the encoding of NamedMapSchema values, but rather allows the
+ * application to restore omitted values as `undefined` instead of their default value.
+ *
+ * Upon decoding, this schema also allows null/undefined values to be acceptable as values.
+ */
+export declare class OptionalSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): undefined;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): unknown;
+}

package/dist/types/encoding/schema/string.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class StringSchema extends Schema {
+    defaultValue(): string;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): string;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): string;
+}

package/dist/types/encoding/schema/uint64.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class Uint64Schema extends Schema {
+    defaultValue(): bigint;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): bigint;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): bigint;
+}

package/dist/types/encoding/schema/untyped.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class UntypedSchema extends Schema {
+    defaultValue(): undefined;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): MsgpackEncodingData;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): MsgpackEncodingData;
+}

package/dist/types/encoding/uint64.d.ts

@@ -27,3 +27,4 @@ export declare function encodeUint64(num: number | bigint): Uint8Array;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'safe'): number;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'mixed'): number | bigint;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'bigint'): bigint;
+export declare function decodeUint64(data: Uint8Array): number;

package/dist/types/group.d.ts

@@ -1,31 +1,12 @@
-/// <reference types="node" />
-import * as txnBuilder from './transaction';
-interface EncodedTxGroup {
-    txlist: Buffer[];
-}
-/**
- * Aux class for group id calculation of a group of transactions
- */
-export declare class TxGroup {
-    name: string;
-    tag: Buffer;
-    txGroupHashes: Buffer[];
-    constructor(hashes: Buffer[]);
-    get_obj_for_encoding(): EncodedTxGroup;
-    static from_obj_for_encoding(txgroupForEnc: EncodedTxGroup): any;
-    toByte(): Uint8Array;
-}
+import { Transaction } from './transaction.js';
 /**
  * computeGroupID returns group ID for a group of transactions
- * @param txns - array of transactions (every element is a dict or Transaction)
- * @returns Buffer
+ * @param txns - array of transactions
+ * @returns Uint8Array
  */
-export declare function computeGroupID(txns: txnBuilder.TransactionLike[]): Buffer;
+export declare function computeGroupID(txns: ReadonlyArray<Transaction>): Uint8Array;
 /**
  * assignGroupID assigns group id to a given list of unsigned transactions
- * @param txns - array of transactions (every element is a dict or Transaction)
- * @param from - optional sender address specifying which transaction return
- * @returns possible list of matching transactions
+ * @param txns - array of transactions. The array elements will be modified with the group id
  */
-export declare function assignGroupID(txns: txnBuilder.TransactionLike[], from?: string): txnBuilder.Transaction[];
-export default TxGroup;
+export declare function assignGroupID(txns: Transaction[]): Transaction[];

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
-import * as algosdk from './main';
-export * from './main';
+import * as algosdk from './main.js';
+export * from './main.js';
 export default algosdk;

package/dist/types/logic/sourcemap.d.ts

@@ -1,20 +1,46 @@
-export declare class SourceMap {
-    version: number;
-    sources: string[];
-    names: string[];
-    mappings: string;
-    pcToLine: {
-        [key: number]: number;
-    };
-    lineToPc: {
-        [key: number]: number[];
-    };
+/**
+ * Represents a location in a source file.
+ */
+export interface SourceLocation {
+    line: number;
+    column: number;
+    sourceIndex: number;
+    nameIndex?: number;
+}
+/**
+ * Represents the location of a specific PC in a source line.
+ */
+export interface PcLineLocation {
+    pc: number;
+    column: number;
+    nameIndex?: number;
+}
+/**
+ * Contains a mapping from TEAL program PC to source file location.
+ */
+export declare class ProgramSourceMap {
+    readonly version: number;
+    /**
+     * A list of original sources used by the "mappings" entry.
+     */
+    readonly sources: string[];
+    /**
+     * A list of symbol names used by the "mappings" entry.
+     */
+    readonly names: string[];
+    /**
+     * A string with the encoded mapping data.
+     */
+    readonly mappings: string;
+    private pcToLocation;
+    private sourceAndLineToPc;
     constructor({ version, sources, names, mappings, }: {
         version: number;
         sources: string[];
         names: string[];
         mappings: string;
     });
-    getLineForPc(pc: number): number | undefined;
-    getPcsForLine(line: number): number[] | undefined;
+    getPcs(): number[];
+    getLocationForPc(pc: number): SourceLocation | undefined;
+    getPcsOnSourceLine(sourceIndex: number, line: number): PcLineLocation[];
 }