@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.10

package/abi-metadata.d.ts

@@ -0,0 +1,16 @@
+import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
+import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
+export interface AbiMetadata {
+    methodName: string;
+    methodSelector: string;
+    argTypes: string[];
+    returnType: string;
+    onCreate?: CreateOptions;
+    allowActions?: OnCompleteActionStr[];
+}
+export declare const attachAbiMetadata: (contract: {
+    new (): Contract;
+}, methodName: string, metadata: AbiMetadata) => void;
+export declare const captureMethodConfig: <T extends Contract>(contract: T, methodName: string, config?: AbiMethodConfig<T> | BareMethodConfig) => void;
+export declare const hasAbiMetadata: <T extends Contract>(contract: T) => boolean;
+export declare const getAbiMetadata: <T extends BaseContract>(contract: T, methodName: string) => AbiMetadata;

package/collections/custom-key-map.d.ts

@@ -0,0 +1,29 @@
+import { Account, internal } from '@algorandfoundation/algorand-typescript';
+import { DeliberateAny } from '../typescript-helpers';
+export declare abstract class CustomKeyMap<TKey, TValue> implements Map<TKey, TValue> {
+    #private;
+    constructor(keySerializer: (key: TKey) => number | bigint | string);
+    clear(): void;
+    delete(key: TKey): boolean;
+    forEach(callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void, thisArg?: DeliberateAny): void;
+    get(key: TKey): TValue | undefined;
+    getOrFail(key: TKey): TValue;
+    has(key: TKey): boolean;
+    set(key: TKey, value: TValue): this;
+    get size(): number;
+    entries(): MapIterator<[TKey, TValue]>;
+    keys(): MapIterator<TKey>;
+    values(): MapIterator<TValue>;
+    [Symbol.iterator](): MapIterator<[TKey, TValue]>;
+    get [Symbol.toStringTag](): string;
+}
+export declare class AccountMap<TValue> extends CustomKeyMap<Account, TValue> {
+    constructor();
+    private static getAddressStrFromAccount;
+}
+export declare class BytesMap<TValue> extends CustomKeyMap<internal.primitives.StubBytesCompat, TValue> {
+    constructor();
+}
+export declare class Uint64Map<TValue> extends CustomKeyMap<internal.primitives.StubUint64Compat, TValue> {
+    constructor();
+}

package/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const UINT64_SIZE = 64;
+export declare const UINT512_SIZE = 512;
+export declare const MAX_UINT8: number;
+export declare const MAX_UINT64: bigint;
+export declare const MAX_UINT512: bigint;
+export declare const MAX_BYTES_SIZE = 4096;
+export declare const MAX_LOG_SIZE = 1024;
+export declare const MAX_ITEMS_IN_LOG = 32;
+export declare const MAX_BOX_SIZE = 32768;
+export declare const BITS_IN_BYTE = 8;
+export declare const DEFAULT_ACCOUNT_MIN_BALANCE = 100000;
+export declare const DEFAULT_MAX_TXN_LIFE = 1000;
+export declare const DEFAULT_ASSET_CREATE_MIN_BALANCE = 1000000;
+export declare const DEFAULT_ASSET_OPT_IN_MIN_BALANCE = 10000;
+export declare const DEFAULT_GLOBAL_GENESIS_HASH: import("@algorandfoundation/algorand-typescript").bytes;
+export declare const ZERO_ADDRESS_B32 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ";
+export declare const ZERO_ADDRESS: import("@algorandfoundation/algorand-typescript").bytes;
+/**
+"\x09"  # pragma version 9
+"\x81\x01"  # pushint 1
+ */
+export declare const ALWAYS_APPROVE_TEAL_PROGRAM: import("@algorandfoundation/algorand-typescript").bytes;
+export declare const LOGIC_DATA_PREFIX: import("@algorandfoundation/algorand-typescript").bytes;
+export declare const MIN_TXN_FEE = 1000;
+export declare const ABI_RETURN_VALUE_LOG_PREFIX: import("@algorandfoundation/algorand-typescript").bytes;
+export declare const UINT64_OVERFLOW_UNDERFLOW_MESSAGE = "Uint64 overflow or underflow";
+export declare const BIGUINT_OVERFLOW_UNDERFLOW_MESSAGE = "BigUint overflow or underflow";

package/context-helpers/internal-context.d.ts

@@ -0,0 +1,26 @@
+import { Account, internal } from '@algorandfoundation/algorand-typescript';
+import { AccountData } from '../impl/account';
+import { ApplicationData } from '../impl/application';
+import { AssetData } from '../impl/asset';
+import { TransactionGroup } from '../subcontexts/transaction-context';
+import { TestExecutionContext } from '../test-execution-context';
+/**
+ * For accessing implementation specific functions, with a convenient single entry
+ * point for other modules to import Also allows for a single place to check and
+ * provide.
+ */
+declare class InternalContext {
+    get value(): TestExecutionContext;
+    get defaultSender(): Account;
+    get ledger(): import("../subcontexts/ledger-context").LedgerContext;
+    get txn(): import("../subcontexts/transaction-context").TransactionContext;
+    get contract(): import("../subcontexts/contract-context").ContractContext;
+    get any(): import("../value-generators").ValueGenerator;
+    get activeApplication(): import("@algorandfoundation/algorand-typescript").Application;
+    get activeGroup(): TransactionGroup;
+    getAccountData(account: Account): AccountData;
+    getAssetData(id: internal.primitives.StubUint64Compat): AssetData;
+    getApplicationData(id: internal.primitives.StubUint64Compat): ApplicationData;
+}
+export declare const lazyContext: InternalContext;
+export {};

package/decode-logs.d.ts

@@ -0,0 +1,9 @@
+import { bytes } from '@algorandfoundation/algorand-typescript';
+export type LogDecoding = 'i' | 's' | 'b';
+export type DecodedLog<T extends LogDecoding> = T extends 'i' ? bigint : T extends 's' ? string : Uint8Array;
+export type DecodedLogs<T extends [...LogDecoding[]]> = {
+    [Index in keyof T]: DecodedLog<T[Index]>;
+} & {
+    length: T['length'];
+};
+export declare function decodeLogs<const T extends [...LogDecoding[]]>(logs: bytes[], decoding: T): DecodedLogs<T>;

package/encoders.d.ts

@@ -0,0 +1,9 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+import { DeliberateAny } from './typescript-helpers';
+export type TypeInfo = {
+    name: string;
+    genericArgs?: TypeInfo[] | Record<string, TypeInfo>;
+};
+export type fromBytes<T> = (val: Uint8Array | internal.primitives.StubBytesCompat, typeInfo: TypeInfo, prefix?: 'none' | 'log') => T;
+export declare const encoders: Record<string, fromBytes<DeliberateAny>>;
+export declare const getEncoder: <T>(typeInfo: TypeInfo) => fromBytes<T>;

package/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class NotImplementedError extends Error {
+    constructor(feature: string);
+}
+export declare function notImplementedError(feature: string): never;
+export declare function testInvariant(condition: unknown, message: string): asserts condition;

package/impl/account.d.ts

@@ -0,0 +1,32 @@
+import { Account, Application, Asset, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Uint64Map } from '../collections/custom-key-map';
+import { Mutable } from '../typescript-helpers';
+import { BytesBackedCls } from './base';
+export declare class AssetHolding {
+    balance: uint64;
+    frozen: boolean;
+    constructor(balance: internal.primitives.StubUint64Compat, frozen: boolean);
+}
+export declare class AccountData {
+    optedAssets: Uint64Map<AssetHolding>;
+    optedApplications: Uint64Map<Application>;
+    account: Mutable<Omit<Account, 'bytes' | 'isOptedIn'>>;
+    constructor();
+}
+export declare class AccountCls extends BytesBackedCls implements Account {
+    constructor(address?: bytes);
+    private get data();
+    get balance(): uint64;
+    get minBalance(): uint64;
+    get authAddress(): Account;
+    get totalNumUint(): uint64;
+    get totalNumByteSlice(): uint64;
+    get totalExtraAppPages(): uint64;
+    get totalAppsCreated(): uint64;
+    get totalAppsOptedIn(): uint64;
+    get totalAssetsCreated(): uint64;
+    get totalAssets(): uint64;
+    get totalBoxes(): uint64;
+    get totalBoxBytes(): uint64;
+    isOptedIn(assetOrApp: Asset | Application): boolean;
+}

package/impl/acct-params.d.ts

@@ -0,0 +1,5 @@
+import { Account, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare const getAccount: (acct: Account | internal.primitives.StubUint64Compat) => Account;
+export declare const balance: (a: Account | internal.primitives.StubUint64Compat) => uint64;
+export declare const minBalance: (a: Account | internal.primitives.StubUint64Compat) => uint64;
+export declare const AcctParams: internal.opTypes.AcctParamsType;

package/impl/app-global.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const AppGlobal: internal.opTypes.AppGlobalType;

package/impl/app-local.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const AppLocal: internal.opTypes.AppLocalType;

package/impl/app-params.d.ts

@@ -0,0 +1,3 @@
+import { Application, internal } from '@algorandfoundation/algorand-typescript';
+export declare const getApp: (app: Application | internal.primitives.StubUint64Compat) => Application | undefined;
+export declare const AppParams: internal.opTypes.AppParamsType;

package/impl/application.d.ts

@@ -0,0 +1,30 @@
+import { Account, Application, bytes, LocalState, uint64 } from '@algorandfoundation/algorand-typescript';
+import { BytesMap } from '../collections/custom-key-map';
+import { Mutable } from '../typescript-helpers';
+import { Uint64BackedCls } from './base';
+import { GlobalStateCls } from './state';
+export declare class ApplicationData {
+    application: Mutable<Omit<Application, 'id' | 'address'>> & {
+        appLogs: bytes[];
+        globalStates: BytesMap<GlobalStateCls<unknown>>;
+        localStates: BytesMap<LocalState<unknown>>;
+        boxes: BytesMap<Uint8Array>;
+    };
+    isCreating: boolean;
+    get appLogs(): bytes[];
+    constructor();
+}
+export declare class ApplicationCls extends Uint64BackedCls implements Application {
+    get id(): uint64;
+    constructor(id?: uint64);
+    private get data();
+    get approvalProgram(): bytes;
+    get clearStateProgram(): bytes;
+    get globalNumUint(): uint64;
+    get globalNumBytes(): uint64;
+    get localNumUint(): uint64;
+    get localNumBytes(): uint64;
+    get extraProgramPages(): uint64;
+    get creator(): Account;
+    get address(): Account;
+}

package/impl/asset-holding.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const AssetHolding: internal.opTypes.AssetHoldingType;

package/impl/asset-params.d.ts

@@ -0,0 +1,3 @@
+import { Asset, internal } from '@algorandfoundation/algorand-typescript';
+export declare const getAsset: (asset: Asset | internal.primitives.StubUint64Compat) => Asset | undefined;
+export declare const AssetParams: internal.opTypes.AssetParamsType;

package/impl/asset.d.ts

@@ -0,0 +1,24 @@
+import { Account, Asset, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Mutable } from '../typescript-helpers';
+import { Uint64BackedCls } from './base';
+export type AssetData = Mutable<Omit<Asset, 'id' | 'balance' | 'frozen'>>;
+export declare class AssetCls extends Uint64BackedCls implements Asset {
+    get id(): uint64;
+    constructor(id?: internal.primitives.StubUint64Compat);
+    private get data();
+    get total(): uint64;
+    get decimals(): uint64;
+    get defaultFrozen(): boolean;
+    get unitName(): bytes;
+    get name(): bytes;
+    get url(): bytes;
+    get metadataHash(): bytes;
+    get manager(): Account;
+    get reserve(): Account;
+    get freeze(): Account;
+    get clawback(): Account;
+    get creator(): Account;
+    balance(account: Account): uint64;
+    frozen(account: Account): boolean;
+    private getAssetHolding;
+}

package/impl/base.d.ts

@@ -0,0 +1,18 @@
+import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { TypeInfo } from '../encoders';
+export declare abstract class BytesBackedCls {
+    #private;
+    get bytes(): bytes;
+    constructor(value: bytes, _typeInfo?: TypeInfo);
+    static fromBytes<T extends BytesBackedCls>(this: {
+        new (v: bytes, typeInfo?: TypeInfo): T;
+    }, value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo?: TypeInfo): T;
+}
+export declare abstract class Uint64BackedCls {
+    #private;
+    get uint64(): uint64;
+    constructor(value: uint64);
+    static fromBytes<T extends Uint64BackedCls>(this: {
+        new (v: uint64): T;
+    }, value: internal.primitives.StubBytesCompat | Uint8Array): T;
+}

package/impl/block.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const Block: internal.opTypes.BlockType;

package/impl/box.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const Box: internal.opTypes.BoxType;

package/impl/crypto.d.ts

@@ -0,0 +1,12 @@
+import { bytes, Ecdsa, internal, VrfVerify } from '@algorandfoundation/algorand-typescript';
+export declare const sha256: (a: internal.primitives.StubBytesCompat) => bytes;
+export declare const sha3_256: (a: internal.primitives.StubBytesCompat) => bytes;
+export declare const keccak256: (a: internal.primitives.StubBytesCompat) => bytes;
+export declare const sha512_256: (a: internal.primitives.StubBytesCompat) => bytes;
+export declare const ed25519verifyBare: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat, c: internal.primitives.StubBytesCompat) => boolean;
+export declare const ed25519verify: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat, c: internal.primitives.StubBytesCompat) => boolean;
+export declare const ecdsaVerify: (v: Ecdsa, a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat, c: internal.primitives.StubBytesCompat, d: internal.primitives.StubBytesCompat, e: internal.primitives.StubBytesCompat) => boolean;
+export declare const ecdsaPkRecover: (v: Ecdsa, a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubBytesCompat, d: internal.primitives.StubBytesCompat) => readonly [bytes, bytes];
+export declare const ecdsaPkDecompress: (v: Ecdsa, a: internal.primitives.StubBytesCompat) => readonly [bytes, bytes];
+export declare const vrfVerify: (_s: VrfVerify, _a: internal.primitives.StubBytesCompat, _b: internal.primitives.StubBytesCompat, _c: internal.primitives.StubBytesCompat) => readonly [bytes, boolean];
+export declare const EllipticCurve: internal.opTypes.EllipticCurveType;

package/impl/encoded-types.d.ts

@@ -0,0 +1,165 @@
+import { Account, BigUintCompat, bytes, internal, StringCompat, uint64, Uint64Compat } from '@algorandfoundation/algorand-typescript';
+import { Address, ARC4Encoded, BitSize, Bool, Byte, DynamicArray, DynamicBytes, StaticArray, StaticBytes, Str, Tuple, UFixedNxM, UintN } from '@algorandfoundation/algorand-typescript/arc4';
+import { fromBytes, TypeInfo } from '../encoders';
+import { DeliberateAny } from '../typescript-helpers';
+type CompatForArc4Int<N extends BitSize> = N extends 8 | 16 | 32 | 64 ? Uint64Compat : BigUintCompat;
+export declare class UintNImpl<N extends BitSize> extends UintN<N> {
+    private value;
+    private bitSize;
+    typeInfo: TypeInfo;
+    constructor(typeInfo: TypeInfo | string, v?: CompatForArc4Int<N>);
+    get native(): UintN<N>["native"];
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): UintNImpl<BitSize>;
+    static getMaxBitsLength(typeInfo: TypeInfo): BitSize;
+}
+export declare class UFixedNxMImpl<N extends BitSize, M extends number> extends UFixedNxM<N, M> {
+    private value;
+    private bitSize;
+    private precision;
+    private typeInfo;
+    constructor(typeInfo: TypeInfo | string, v: `${number}.${number}`);
+    get native(): UFixedNxM<N, M>["native"];
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): UFixedNxM<BitSize, number>;
+    static getMaxBitsLength(typeInfo: TypeInfo): BitSize;
+}
+export declare class ByteImpl extends Byte {
+    private value;
+    constructor(typeInfo: TypeInfo | string, v?: CompatForArc4Int<8>);
+    get native(): uint64;
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): ByteImpl;
+    static getMaxBitsLength(typeInfo: TypeInfo): BitSize;
+}
+export declare class StrImpl extends Str {
+    private value;
+    constructor(_typeInfo: TypeInfo | string, s?: StringCompat);
+    get native(): string;
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StrImpl;
+}
+export declare class BoolImpl extends Bool {
+    private value;
+    constructor(_typeInfo: TypeInfo | string, v?: boolean);
+    get native(): boolean;
+    equals(other: this): boolean;
+    get bytes(): bytes;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): BoolImpl;
+}
+type StaticArrayGenericArgs = {
+    elementType: TypeInfo;
+    size: TypeInfo;
+};
+export declare class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends number> extends StaticArray<TItem, TLength> {
+    private value?;
+    private uint8ArrayValue?;
+    private typeInfo;
+    private size;
+    genericArgs: StaticArrayGenericArgs;
+    constructor(typeInfo: TypeInfo | string, ...items: TItem[] & {
+        length: TLength;
+    });
+    constructor(typeInfo: TypeInfo | string, ...items: TItem[]);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): uint64;
+    get items(): TItem[];
+    setItem(index: number, value: TItem): void;
+    copy(): StaticArrayImpl<TItem, TLength>;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StaticArrayImpl<ARC4Encoded, number>;
+    static getMaxBytesLength(typeInfo: TypeInfo): number;
+}
+export declare class AddressImpl extends Address {
+    private typeInfo;
+    private value;
+    constructor(typeInfo: TypeInfo | string, value?: Account | string | bytes);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): uint64;
+    get native(): Account;
+    get items(): ByteImpl[];
+    setItem(_index: number, _value: ByteImpl): void;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): AddressImpl;
+    static getMaxBytesLength(typeInfo: TypeInfo): number;
+}
+type DynamicArrayGenericArgs = {
+    elementType: TypeInfo;
+};
+export declare class DynamicArrayImpl<TItem extends ARC4Encoded> extends DynamicArray<TItem> {
+    private value?;
+    private uint8ArrayValue?;
+    private typeInfo;
+    genericArgs: DynamicArrayGenericArgs;
+    constructor(typeInfo: TypeInfo | string, ...items: TItem[]);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): uint64;
+    get items(): TItem[];
+    setItem(index: number, value: TItem): void;
+    copy(): DynamicArrayImpl<TItem>;
+    push(...values: TItem[]): void;
+    pop(): TItem;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): DynamicArrayImpl<ARC4Encoded>;
+    private encodeWithLength;
+}
+export declare class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends Tuple<TTuple> {
+    private value?;
+    private uint8ArrayValue?;
+    private typeInfo;
+    genericArgs: TypeInfo[];
+    constructor(typeInfo: TypeInfo | string);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): TTuple['length'] & uint64;
+    get native(): TTuple;
+    at<TIndex extends keyof TTuple>(index: TIndex): TTuple[TIndex];
+    private get items();
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): TupleImpl<[ARC4Encoded, ...ARC4Encoded[]]>;
+    static getMaxBytesLength(typeInfo: TypeInfo): number;
+}
+type StructConstraint = Record<string, ARC4Encoded>;
+declare const StructImpl_base: any;
+export declare class StructImpl<T extends StructConstraint> extends StructImpl_base {
+    private uint8ArrayValue?;
+    private typeInfo;
+    genericArgs: Record<string, TypeInfo>;
+    constructor(typeInfo: TypeInfo | string, value?: T);
+    get bytes(): bytes;
+    get items(): T;
+    private decodeAsProperties;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StructImpl<StructConstraint>;
+}
+export declare class DynamicBytesImpl extends DynamicBytes {
+    private typeInfo;
+    private value;
+    constructor(typeInfo: TypeInfo | string, value?: bytes | string);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): uint64;
+    get native(): bytes;
+    get items(): ByteImpl[];
+    setItem(_index: number, _value: ByteImpl): void;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): DynamicBytesImpl;
+}
+export declare class StaticBytesImpl extends StaticBytes {
+    private value;
+    private typeInfo;
+    constructor(typeInfo: TypeInfo | string, value?: bytes | string);
+    get bytes(): bytes;
+    equals(other: this): boolean;
+    get length(): uint64;
+    get native(): bytes;
+    get items(): ByteImpl[];
+    setItem(_index: number, _value: ByteImpl): void;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StaticBytesImpl;
+    static getMaxBytesLength(typeInfo: TypeInfo): number;
+}
+export declare function interpretAsArc4Impl<T extends ARC4Encoded>(typeInfoString: string, bytes: internal.primitives.StubBytesCompat, prefix?: 'none' | 'log'): T;
+export declare const arc4Encoders: Record<string, fromBytes<DeliberateAny>>;
+export declare const getArc4Encoder: <T>(typeInfo: TypeInfo, encoders?: Record<string, fromBytes<DeliberateAny>>) => fromBytes<T>;
+export {};

package/impl/global.d.ts

@@ -0,0 +1,18 @@
+import { Account, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare class GlobalData {
+    minTxnFee: uint64;
+    minBalance: uint64;
+    maxTxnLife: uint64;
+    zeroAddress: Account;
+    logicSigVersion?: uint64;
+    round?: uint64;
+    latestTimestamp?: uint64;
+    groupId?: bytes;
+    callerApplicationId: uint64;
+    assetCreateMinBalance: uint64;
+    assetOptInMinBalance: uint64;
+    genesisHash: bytes;
+    opcodeBudget?: uint64;
+    constructor();
+}
+export declare const Global: internal.opTypes.GlobalType;

package/impl/gtxn.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const GTxn: internal.opTypes.GTxnType;

package/impl/index.d.ts

@@ -0,0 +1,15 @@
+export { AcctParams, balance, minBalance } from './acct-params';
+export { AppGlobal } from './app-global';
+export { AppLocal } from './app-local';
+export { AppParams } from './app-params';
+export { AssetHolding } from './asset-holding';
+export { AssetParams } from './asset-params';
+export { Box } from './box';
+export * from './crypto';
+export { Global } from './global';
+export { GTxn } from './gtxn';
+export { GITxn, ITxn, ITxnCreate } from './itxn';
+export * from './pure';
+export { Scratch, gloadBytes, gloadUint64 } from './scratch';
+export { Block } from './block';
+export { Txn, gaid } from './txn';

package/impl/inner-transactions.d.ts

@@ -0,0 +1,51 @@
+import { arc4, itxn, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
+import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
+import { InnerTxn, InnerTxnFields } from './itxn';
+import { Mutable } from '../typescript-helpers';
+export declare class PaymentInnerTxn extends PaymentTransaction implements itxn.PaymentInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: itxn.PaymentFields): PaymentInnerTxn;
+    constructor(fields: itxn.PaymentFields);
+}
+export declare class KeyRegistrationInnerTxn extends KeyRegistrationTransaction implements itxn.KeyRegistrationInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: itxn.KeyRegistrationFields): KeyRegistrationInnerTxn;
+    constructor(fields: itxn.KeyRegistrationFields);
+}
+export declare class AssetConfigInnerTxn extends AssetConfigTransaction implements itxn.AssetConfigInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: itxn.AssetConfigFields): AssetConfigInnerTxn;
+    constructor(fields: itxn.AssetConfigFields);
+}
+export declare class AssetTransferInnerTxn extends AssetTransferTransaction implements itxn.AssetTransferInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: Partial<itxn.AssetTransferFields>): AssetTransferInnerTxn;
+    constructor(fields: itxn.AssetTransferFields);
+}
+export declare class AssetFreezeInnerTxn extends AssetFreezeTransaction implements itxn.AssetFreezeInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: Partial<itxn.AssetFreezeFields>): AssetFreezeInnerTxn;
+    constructor(fields: itxn.AssetFreezeFields);
+}
+export declare class ApplicationInnerTxn extends ApplicationTransaction implements itxn.ApplicationInnerTxn {
+    readonly isItxn?: true;
+    static create(fields: Omit<itxn.ApplicationCallFields, 'onCompletion'> & {
+        onCompletion?: arc4.OnCompleteAction | uint64 | arc4.OnCompleteActionStr;
+    }): ApplicationInnerTxn;
+    constructor(fields: Mutable<itxn.ApplicationCallFields>);
+}
+export declare const createInnerTxn: <TFields extends InnerTxnFields>(fields: TFields) => PaymentInnerTxn | KeyRegistrationInnerTxn | AssetTransferInnerTxn | ApplicationInnerTxn | AssetConfigInnerTxn | AssetFreezeInnerTxn;
+export declare function submitGroup<TFields extends itxn.InnerTxnList>(...transactionFields: TFields): itxn.TxnFor<TFields>;
+export declare function payment(fields: itxn.PaymentFields): itxn.PaymentItxnParams;
+export declare function keyRegistration(fields: itxn.KeyRegistrationFields): itxn.KeyRegistrationItxnParams;
+export declare function assetConfig(fields: itxn.AssetConfigFields): itxn.AssetConfigItxnParams;
+export declare function assetTransfer(fields: itxn.AssetTransferFields): itxn.AssetTransferItxnParams;
+export declare function assetFreeze(fields: itxn.AssetFreezeFields): itxn.AssetFreezeItxnParams;
+export declare function applicationCall(fields: itxn.ApplicationCallFields): itxn.ApplicationCallItxnParams;
+export declare class ItxnParams<TFields extends InnerTxnFields, TTransaction extends InnerTxn> {
+    #private;
+    constructor(fields: TFields, type: TransactionType);
+    submit(): TTransaction;
+    set(p: Partial<TFields>): void;
+    copy(): ItxnParams<TFields, TTransaction>;
+}

package/impl/itxn.d.ts

@@ -0,0 +1,8 @@
+import { internal, itxn, TransactionType } from '@algorandfoundation/algorand-typescript';
+export type InnerTxn = itxn.PaymentInnerTxn | itxn.KeyRegistrationInnerTxn | itxn.AssetConfigInnerTxn | itxn.AssetTransferInnerTxn | itxn.AssetFreezeInnerTxn | itxn.ApplicationInnerTxn;
+export type InnerTxnFields = (itxn.PaymentFields | itxn.KeyRegistrationFields | itxn.AssetConfigFields | itxn.AssetTransferFields | itxn.AssetFreezeFields | itxn.ApplicationCallFields) & {
+    type?: TransactionType;
+};
+export declare const GITxn: internal.opTypes.GITxnType;
+export declare const ITxn: internal.opTypes.ITxnType;
+export declare const ITxnCreate: internal.opTypes.ITxnCreateType;

package/impl/pure.d.ts

@@ -0,0 +1,32 @@
+import { Base64, biguint, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare const addw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => readonly [uint64, uint64];
+export declare const base64Decode: (e: Base64, a: internal.primitives.StubBytesCompat) => bytes;
+export declare const bitLength: (a: internal.primitives.StubUint64Compat | internal.primitives.StubBytesCompat) => uint64;
+export declare const bsqrt: (a: internal.primitives.StubBigUintCompat) => biguint;
+export declare const btoi: (a: internal.primitives.StubBytesCompat) => uint64;
+export declare const bzero: (a: internal.primitives.StubUint64Compat) => bytes;
+export declare const concat: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat) => bytes;
+export declare const divmodw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat, d: internal.primitives.StubUint64Compat) => readonly [uint64, uint64, uint64, uint64];
+export declare const divw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => uint64;
+export declare const exp: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const expw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => readonly [uint64, uint64];
+export declare const extract: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => bytes;
+export declare const extractUint16: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const extractUint32: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const extractUint64: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const getBit: (a: internal.primitives.StubUint64Compat | internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const getByte: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const itob: (a: internal.primitives.StubUint64Compat) => bytes;
+export declare const mulw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => readonly [uint64, uint64];
+export declare const replace: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubBytesCompat) => bytes;
+type selectType = ((a: internal.primitives.StubBytesCompat, b: internal.primitives.StubBytesCompat, c: internal.primitives.StubUint64Compat) => bytes) & ((a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => uint64);
+export declare const select: selectType;
+type SetBitType = ((target: internal.primitives.StubBytesCompat, n: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => bytes) & ((target: internal.primitives.StubUint64Compat, n: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => uint64);
+export declare const setBit: SetBitType;
+export declare const setByte: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => bytes;
+export declare const shl: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const shr: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => uint64;
+export declare const sqrt: (a: internal.primitives.StubUint64Compat) => uint64;
+export declare const substring: (a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat, c: internal.primitives.StubUint64Compat) => bytes;
+export declare const JsonRef: internal.opTypes.JsonRefType;
+export {};

package/impl/scratch.d.ts

@@ -0,0 +1,4 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const gloadUint64: internal.opTypes.GloadUint64Type;
+export declare const gloadBytes: internal.opTypes.GloadBytesType;
+export declare const Scratch: internal.opTypes.ScratchType;