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

package/abi-metadata.d.ts

@@ -0,0 +1,16 @@
+import { 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 Contract>(contract: T, methodName: string) => AbiMetadata;

package/constants.d.ts

@@ -0,0 +1,21 @@
+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_ITEMS_IN_LOG = 32;
+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: 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;

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

@@ -0,0 +1,26 @@
+import { 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(): import("@algorandfoundation/algorand-typescript").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(accountPublicKey: internal.primitives.StubBytesCompat): 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,8 @@
+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: Uint8Array[], decoding: T): DecodedLogs<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,31 @@
+import { Account, Application, Asset, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Mutable } from '../typescript-helpers';
+export declare class AssetHolding {
+    balance: uint64;
+    frozen: boolean;
+    constructor(balance: internal.primitives.StubUint64Compat, frozen: boolean);
+}
+export declare class AccountData {
+    optedAssets: Map<bigint, AssetHolding>;
+    optedApplications: Map<bigint, Application>;
+    account: Mutable<Omit<Account, 'bytes' | 'isOptedIn'>>;
+    constructor();
+}
+export declare class AccountCls implements Account {
+    readonly bytes: bytes;
+    constructor(address?: internal.primitives.StubBytesCompat);
+    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-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,24 @@
+import { Account, Application, bytes, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Mutable } from '../typescript-helpers';
+export declare class ApplicationData {
+    application: Mutable<Omit<Application, 'id' | 'address'>> & {
+        appLogs: bytes[];
+    };
+    isCreating: boolean;
+    get appLogs(): bytes[];
+    constructor();
+}
+export declare class ApplicationCls implements Application {
+    readonly 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,23 @@
+import { Account, Asset, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Mutable } from '../typescript-helpers';
+export type AssetData = Mutable<Omit<Asset, 'id' | 'balance' | 'frozen'>>;
+export declare class AssetCls implements Asset {
+    readonly 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/crypto.d.ts

@@ -0,0 +1,12 @@
+import { bytes, internal } 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: internal.opTypes.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: internal.opTypes.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: internal.opTypes.Ecdsa, a: internal.primitives.StubBytesCompat) => readonly [bytes, bytes];
+export declare const vrfVerify: (_s: internal.opTypes.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/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,11 @@
+export { AcctParams, balance, minBalance } from './acct-params';
+export { AppParams } from './app-params';
+export { AssetHolding } from './asset-holding';
+export { AssetParams } from './asset-params';
+export * from './crypto';
+export { Global } from './global';
+export { GTxn } from './gtxn';
+export * from './pure';
+export { Txn, gaid } from './txn';
+export { GITxn, ITxn, ITxnCreate } from './itxn';
+export { Scratch } from './scratch';

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 { 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: internal.opTypes.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,2 @@
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare const Scratch: internal.opTypes.ScratchType;

package/impl/transactions.d.ts

@@ -0,0 +1,139 @@
+import { Account, Application, arc4, Asset, bytes, gtxn, internal, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Mutable, ObjectKeys } from '../typescript-helpers';
+declare const baseDefaultFields: () => {
+    sender: Account;
+    fee: uint64;
+    firstValid: uint64;
+    firstValidTime: uint64;
+    lastValid: uint64;
+    note: bytes;
+    lease: bytes;
+    groupIndex: uint64;
+    txnId: bytes;
+    rekeyTo: Account;
+};
+export type TxnFields<TTxn> = Partial<Mutable<Pick<TTxn, ObjectKeys<TTxn>>>>;
+declare abstract class TransactionBase {
+    protected constructor(fields: Partial<ReturnType<typeof baseDefaultFields>>);
+    readonly sender: Account;
+    readonly fee: uint64;
+    readonly firstValid: uint64;
+    readonly firstValidTime: uint64;
+    readonly lastValid: uint64;
+    readonly note: bytes;
+    readonly lease: bytes;
+    readonly groupIndex: uint64;
+    readonly txnId: bytes;
+    readonly rekeyTo: Account;
+    readonly scratchSpace: Array<bytes | uint64>;
+    setScratchSlot(index: internal.primitives.StubUint64Compat, value: internal.primitives.StubBytesCompat | internal.primitives.StubUint64Compat): void;
+    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;
+    readonly closeRemainderTo: Account;
+    readonly type: TransactionType.Payment;
+    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;
+    readonly voteFirst: uint64;
+    readonly voteLast: uint64;
+    readonly voteKeyDilution: uint64;
+    readonly nonparticipation: boolean;
+    readonly stateProofKey: bytes;
+    readonly type: TransactionType.KeyRegistration;
+    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;
+    readonly decimals: uint64;
+    readonly defaultFrozen: boolean;
+    readonly unitName: bytes;
+    readonly assetName: bytes;
+    readonly url: bytes;
+    readonly metadataHash: bytes;
+    readonly manager: Account;
+    readonly reserve: Account;
+    readonly freeze: Account;
+    readonly clawback: Account;
+    readonly createdAsset: Asset;
+    readonly type: TransactionType.AssetConfig;
+    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;
+    readonly assetSender: Account;
+    readonly assetReceiver: Account;
+    readonly assetCloseTo: Account;
+    readonly type: TransactionType.AssetTransfer;
+    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;
+    readonly frozen: boolean;
+    readonly type: TransactionType.AssetFreeze;
+    readonly typeBytes: bytes;
+}
+export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Partial<{
+    appArgs: Array<bytes>;
+    accounts: Array<Account>;
+    assets: Array<Asset>;
+    apps: Array<Application>;
+    approvalProgramPages: Array<bytes>;
+    clearStateProgramPages: Array<bytes>;
+    appLogs: Array<bytes>;
+    scratchSpace: Array<bytes | uint64>;
+}>;
+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;
+    readonly globalNumUint: uint64;
+    readonly globalNumBytes: uint64;
+    readonly localNumUint: uint64;
+    readonly localNumBytes: uint64;
+    readonly extraProgramPages: uint64;
+    readonly createdApp: Application;
+    get approvalProgram(): bytes;
+    get clearStateProgram(): bytes;
+    get numAppArgs(): uint64;
+    get numAccounts(): uint64;
+    get numAssets(): uint64;
+    get numApps(): uint64;
+    get numApprovalProgramPages(): uint64;
+    get numClearStateProgramPages(): uint64;
+    get numLogs(): uint64;
+    get lastLog(): bytes;
+    appArgs(index: internal.primitives.StubUint64Compat): bytes;
+    accounts(index: internal.primitives.StubUint64Compat): Account;
+    assets(index: internal.primitives.StubUint64Compat): Asset;
+    apps(index: internal.primitives.StubUint64Compat): Application;
+    approvalProgramPages(index: internal.primitives.StubUint64Compat): bytes;
+    clearStateProgramPages(index: internal.primitives.StubUint64Compat): bytes;
+    logs(index: internal.primitives.StubUint64Compat): bytes;
+    readonly type: TransactionType.ApplicationCall;
+    readonly typeBytes: bytes;
+    get appLogs(): bytes[];
+    appendLog(value: internal.primitives.StubBytesCompat): 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;
+export {};

package/impl/txn.d.ts

@@ -0,0 +1,3 @@
+import { internal, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare const gaid: (a: internal.primitives.StubUint64Compat) => uint64;
+export declare const Txn: internal.opTypes.TxnType;

package/index.d.ts

@@ -0,0 +1 @@
+export { TestExecutionContext } from './test-execution-context';