@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.8 → 1.0.0-beta.1

package/abi-metadata.d.ts

@@ -2,15 +2,20 @@ import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript'
 import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
 export interface AbiMetadata {
     methodName: string;
-    methodSelector: string;
+    methodSignature: string | undefined;
     argTypes: string[];
     returnType: string;
     onCreate?: CreateOptions;
     allowActions?: OnCompleteActionStr[];
 }
+export declare const isContractProxy: unique symbol;
 export declare const attachAbiMetadata: (contract: {
     new (): Contract;
 }, methodName: string, metadata: AbiMetadata) => void;
+export declare const copyAbiMetadatas: <T extends BaseContract>(sourceContract: T, targetContract: T) => 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;
+export declare const getContractAbiMetadata: <T extends BaseContract>(contract: T) => Record<string, AbiMetadata>;
+export declare const getContractMethodAbiMetadata: <T extends BaseContract>(contract: T, methodName: string) => AbiMetadata;
+export declare const getArc4Signature: (metadata: AbiMetadata) => string;
+export declare const getArc4Selector: (metadata: AbiMetadata) => Uint8Array;

package/constants.d.ts

@@ -1,9 +1,14 @@
 export declare const UINT64_SIZE = 64;
 export declare const UINT512_SIZE = 512;
 export declare const MAX_UINT8: number;
+export declare const MAX_UINT16: number;
+export declare const MAX_UINT32: number;
 export declare const MAX_UINT64: bigint;
+export declare const MAX_UINT128: bigint;
+export declare const MAX_UINT256: 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;
@@ -12,7 +17,6 @@ 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
@@ -24,3 +28,19 @@ 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";
+export declare const DEFAULT_TEMPLATE_VAR_PREFIX = "TMPL_";
+export declare const APP_ID_PREFIX = "appID";
+export declare const HASH_BYTES_LENGTH = 32;
+export declare const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
+export declare const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
+export declare const ALGORAND_ADDRESS_LENGTH = 58;
+export declare const PROGRAM_TAG = "Program";
+export declare const TRANSACTION_GROUP_MAX_SIZE = 16;
+export declare enum OnApplicationComplete {
+    NoOpOC = 0,
+    OptInOC = 1,
+    CloseOutOC = 2,
+    ClearStateOC = 3,
+    UpdateApplicationOC = 4,
+    DeleteApplicationOC = 5
+}

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

@@ -0,0 +1,3 @@
+import { uint64 } from '@algorandfoundation/algorand-typescript';
+import { AbiMetadata } from '../abi-metadata';
+export declare const checkRoutingConditions: (appId: uint64, metadata: AbiMetadata) => void;

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

@@ -1,4 +1,4 @@
-import { Account, internal } from '@algorandfoundation/algorand-typescript';
+import { Account, BaseContract, internal } from '@algorandfoundation/algorand-typescript';
 import { AccountData } from '../impl/account';
 import { ApplicationData } from '../impl/application';
 import { AssetData } from '../impl/asset';
@@ -20,7 +20,7 @@ declare class InternalContext {
     get activeGroup(): TransactionGroup;
     getAccountData(account: Account): AccountData;
     getAssetData(id: internal.primitives.StubUint64Compat): AssetData;
-    getApplicationData(id: internal.primitives.StubUint64Compat): ApplicationData;
+    getApplicationData(id: internal.primitives.StubUint64Compat | BaseContract): ApplicationData;
 }
 export declare const lazyContext: InternalContext;
 export {};

package/encoders.d.ts

@@ -1,21 +1,10 @@
-import { biguint, bytes, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
-import { OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4';
-export interface TypeInfo {
+import { bytes, internal } from '@algorandfoundation/algorand-typescript';
+import { DeliberateAny } from './typescript-helpers';
+export type TypeInfo = {
     name: string;
     genericArgs?: TypeInfo[] | Record<string, TypeInfo>;
-}
-type fromBytes<T> = (val: Uint8Array, typeInfo: TypeInfo) => T;
-export declare const encoders: {
-    account: typeof import("./impl/base").BytesBackedCls.fromBytes;
-    application: typeof import("./impl/base").Uint64BackedCls.fromBytes;
-    asset: typeof import("./impl/base").Uint64BackedCls.fromBytes;
-    'bool(ean)?': fromBytes<boolean>;
-    biguint: fromBytes<biguint>;
-    bytes: fromBytes<bytes>;
-    string: fromBytes<string>;
-    uint64: fromBytes<uint64>;
-    OnCompleteAction: fromBytes<OnCompleteAction>;
-    TransactionType: fromBytes<TransactionType>;
 };
+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>;
-export {};
+export declare const toBytes: (val: unknown) => bytes;

package/impl/acct-params.d.ts

@@ -1,5 +1,6 @@
-import { Account, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Account, Application, 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 appOptedIn: (a: Account | internal.primitives.StubUint64Compat, b: Application | internal.primitives.StubUint64Compat) => boolean;
 export declare const AcctParams: internal.opTypes.AcctParamsType;

package/impl/base.d.ts

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

package/impl/compiled.d.ts

@@ -0,0 +1,3 @@
+import { BaseContract, CompileContractOptions, CompiledContract, CompiledLogicSig, CompileLogicSigOptions, LogicSig } from '@algorandfoundation/algorand-typescript';
+import { ConstructorFor } from '../typescript-helpers';
+export declare function compileImpl(artefact: ConstructorFor<BaseContract> | ConstructorFor<LogicSig>, options?: CompileContractOptions | CompileLogicSigOptions): CompiledLogicSig | CompiledContract;

package/impl/emit.d.ts

@@ -0,0 +1 @@
+export declare function emitImpl<T>(typeInfoString: string, event: T | string, ...eventProps: unknown[]): void;

package/impl/encoded-types.d.ts

@@ -0,0 +1,183 @@
+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;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+export declare class UFixedNxMImpl<N extends BitSize, M extends number> extends UFixedNxM<N, M> {
+    private value;
+    private bitSize;
+    private precision;
+    typeInfo: 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;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+export declare class ByteImpl extends Byte {
+    typeInfo: TypeInfo;
+    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 {
+    typeInfo: TypeInfo;
+    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;
+    typeInfo: TypeInfo;
+    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 size;
+    typeInfo: TypeInfo;
+    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>;
+    get native(): TItem[];
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StaticArrayImpl<ARC4Encoded, number>;
+    static getMaxBytesLength(typeInfo: TypeInfo): number;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+export declare class AddressImpl extends Address {
+    typeInfo: 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?;
+    typeInfo: 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>;
+    get native(): TItem[];
+    push(...values: TItem[]): void;
+    pop(): TItem;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): DynamicArrayImpl<ARC4Encoded>;
+    static getArc4TypeName: (t: TypeInfo) => string;
+    private encodeWithLength;
+}
+export declare class TupleImpl<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends Tuple<TTuple> {
+    private value?;
+    private uint8ArrayValue?;
+    typeInfo: 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;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+type StructConstraint = Record<string, ARC4Encoded>;
+declare const StructImpl_base: DeliberateAny;
+export declare class StructImpl<T extends StructConstraint> extends StructImpl_base {
+    static [x: string]: any;
+    private uint8ArrayValue?;
+    genericArgs: Record<string, TypeInfo>;
+    constructor(typeInfo: TypeInfo | string, value?: T);
+    get bytes(): bytes;
+    get items(): T;
+    get native(): T;
+    private decodeAsProperties;
+    static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): StructImpl<StructConstraint>;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+export declare class DynamicBytesImpl extends DynamicBytes {
+    typeInfo: 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;
+    static getArc4TypeName: (_t: TypeInfo) => string;
+}
+export declare class StaticBytesImpl extends StaticBytes {
+    private value;
+    typeInfo: 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;
+    static getArc4TypeName: (t: TypeInfo) => string;
+}
+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 declare const getArc4TypeName: (typeInfo: TypeInfo) => string | undefined;
+export declare function decodeArc4Impl<T>(sourceTypeInfoString: string, bytes: internal.primitives.StubBytesCompat, prefix?: 'none' | 'log'): T;
+export declare function encodeArc4Impl<T>(_targetTypeInfoString: string, source: T): bytes;
+export declare const getArc4Encoded: (value: DeliberateAny) => ARC4Encoded;
+export {};

package/impl/ensure-budget.d.ts

@@ -0,0 +1,2 @@
+import { OpUpFeeSource, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare function ensureBudgetImpl(_budget: uint64, _feeSource?: OpUpFeeSource): void;

package/impl/index.d.ts

@@ -1,15 +1,16 @@
-export { AcctParams, balance, minBalance } from './acct-params';
+export { AcctParams, appOptedIn, 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 { Block } from './block';
 export { Box } from './box';
 export * from './crypto';
 export { Global } from './global';
 export { GTxn } from './gtxn';
 export { GITxn, ITxn, ITxnCreate } from './itxn';
+export { arg } from './logicSigArg';
 export * from './pure';
-export { Scratch, gloadBytes, gloadUint64 } from './scratch';
-export { Block } from './block';
-export { Txn, gaid } from './txn';
+export { gloadBytes, gloadUint64, Scratch } from './scratch';
+export { gaid, Txn } from './txn';

package/impl/inner-transactions.d.ts

@@ -1,38 +1,23 @@
-import { arc4, itxn, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
-import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
+import { itxn, TransactionType } from '@algorandfoundation/algorand-typescript';
 import { InnerTxn, InnerTxnFields } from './itxn';
-import { Mutable } from '../typescript-helpers';
+import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
 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>;

package/impl/logicSigArg.d.ts

@@ -0,0 +1,2 @@
+import { bytes, internal } from '@algorandfoundation/algorand-typescript';
+export declare const arg: (a: internal.primitives.StubUint64Compat) => bytes;

package/impl/match.d.ts

@@ -0,0 +1,3 @@
+import { assertMatch, match } from '@algorandfoundation/algorand-typescript';
+export declare const matchImpl: typeof match;
+export declare const assertMatchImpl: typeof assertMatch;

package/impl/pure.d.ts

@@ -17,6 +17,7 @@ export declare const extractUint64: (a: internal.primitives.StubBytesCompat, b:
 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 len: (a: internal.primitives.StubBytesCompat) => uint64;
 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);

package/impl/template-var.d.ts

@@ -0,0 +1 @@
+export declare function TemplateVarImpl<T>(variableName: string, prefix?: string): T;

package/impl/transactions.d.ts

@@ -30,7 +30,6 @@ declare abstract class TransactionBase {
     getScratchSlot(index: internal.primitives.StubUint64Compat): bytes | uint64;
 }
 export declare class PaymentTransaction extends TransactionBase implements gtxn.PaymentTxn {
-    static create(fields: TxnFields<gtxn.PaymentTxn>): PaymentTransaction;
     protected constructor(fields: TxnFields<gtxn.PaymentTxn>);
     readonly receiver: Account;
     readonly amount: uint64;
@@ -39,7 +38,6 @@ export declare class PaymentTransaction extends TransactionBase implements gtxn.
     readonly typeBytes: bytes;
 }
 export declare class KeyRegistrationTransaction extends TransactionBase implements gtxn.KeyRegistrationTxn {
-    static create(fields: TxnFields<gtxn.KeyRegistrationTxn>): KeyRegistrationTransaction;
     protected constructor(fields: TxnFields<gtxn.KeyRegistrationTxn>);
     readonly voteKey: bytes;
     readonly selectionKey: bytes;
@@ -52,7 +50,6 @@ export declare class KeyRegistrationTransaction extends TransactionBase implemen
     readonly typeBytes: bytes;
 }
 export declare class AssetConfigTransaction extends TransactionBase implements gtxn.AssetConfigTxn {
-    static create(fields: TxnFields<gtxn.AssetConfigTxn>): AssetConfigTransaction;
     protected constructor(fields: TxnFields<gtxn.AssetConfigTxn>);
     readonly configAsset: Asset;
     readonly total: uint64;
@@ -71,7 +68,6 @@ export declare class AssetConfigTransaction extends TransactionBase implements g
     readonly typeBytes: bytes;
 }
 export declare class AssetTransferTransaction extends TransactionBase implements gtxn.AssetTransferTxn {
-    static create(fields: TxnFields<gtxn.AssetTransferTxn>): AssetTransferTransaction;
     protected constructor(fields: TxnFields<gtxn.AssetTransferTxn>);
     readonly xferAsset: Asset;
     readonly assetAmount: uint64;
@@ -82,7 +78,6 @@ export declare class AssetTransferTransaction extends TransactionBase implements
     readonly typeBytes: bytes;
 }
 export declare class AssetFreezeTransaction extends TransactionBase implements gtxn.AssetFreezeTxn {
-    static create(fields: TxnFields<gtxn.AssetFreezeTxn>): AssetFreezeTransaction;
     protected constructor(fields: TxnFields<gtxn.AssetFreezeTxn>);
     readonly freezeAsset: Asset;
     readonly freezeAccount: Account;
@@ -91,7 +86,7 @@ export declare class AssetFreezeTransaction extends TransactionBase implements g
     readonly typeBytes: bytes;
 }
 export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Partial<{
-    appArgs: Array<bytes>;
+    appArgs: Array<unknown>;
     accounts: Array<Account>;
     assets: Array<Asset>;
     apps: Array<Application>;
@@ -102,7 +97,6 @@ export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Part
 }>;
 export declare class ApplicationTransaction extends TransactionBase implements gtxn.ApplicationTxn {
     #private;
-    static create(fields: ApplicationTransactionFields): ApplicationTransaction;
     protected constructor(fields: ApplicationTransactionFields);
     readonly appId: Application;
     readonly onCompletion: arc4.OnCompleteActionStr;
@@ -122,6 +116,9 @@ export declare class ApplicationTransaction extends TransactionBase implements g
     get numClearStateProgramPages(): uint64;
     get numLogs(): uint64;
     get lastLog(): bytes;
+    get apat(): Account[];
+    get apas(): Asset[];
+    get apfa(): Application[];
     appArgs(index: internal.primitives.StubUint64Compat): bytes;
     accounts(index: internal.primitives.StubUint64Compat): Account;
     assets(index: internal.primitives.StubUint64Compat): Asset;
@@ -131,9 +128,6 @@ export declare class ApplicationTransaction extends TransactionBase implements g
     logs(index: internal.primitives.StubUint64Compat): bytes;
     readonly type: TransactionType.ApplicationCall;
     readonly typeBytes: bytes;
-    get appLogs(): bytes[];
-    appendLog(value: internal.primitives.StubBytesCompat): void;
-    logArc4ReturnValue(value: unknown): void;
 }
 export type Transaction = PaymentTransaction | KeyRegistrationTransaction | AssetConfigTransaction | AssetTransferTransaction | AssetFreezeTransaction | ApplicationTransaction;
 export type AllTransactionFields = TxnFields<gtxn.PaymentTxn> & TxnFields<gtxn.KeyRegistrationTxn> & TxnFields<gtxn.AssetConfigTxn> & TxnFields<gtxn.AssetTransferTxn> & TxnFields<gtxn.AssetFreezeTxn> & ApplicationTransactionFields;

package/impl/urange.d.ts

@@ -0,0 +1,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare function urangeImpl(a: internal.primitives.StubUint64Compat, b?: internal.primitives.StubUint64Compat, c?: internal.primitives.StubUint64Compat): Generator<import("@algorandfoundation/algorand-typescript").uint64, number, unknown>;

package/index.d.ts

@@ -1 +1,15 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
 export { TestExecutionContext } from './test-execution-context';
+export declare const encodingUtil: {
+    toExternalValue: typeof internal.primitives.toExternalValue;
+    uint8ArrayToBigInt: (v: Uint8Array) => bigint;
+    hexToUint8Array: (value: string) => Uint8Array;
+    base64ToUint8Array: (value: string) => Uint8Array;
+    bigIntToUint8Array: (val: bigint, fixedSize?: number | "dynamic") => Uint8Array;
+    utf8ToUint8Array: (value: string) => Uint8Array;
+    uint8ArrayToUtf8: (value: Uint8Array) => string;
+    uint8ArrayToHex: (value: Uint8Array) => string;
+    uint8ArrayToBase64: (value: Uint8Array) => string;
+    uint8ArrayToBase64Url: (value: Uint8Array) => string;
+    uint8ArrayToBase32: (value: Uint8Array) => string;
+};