@algorandfoundation/algorand-typescript-testing 1.0.0-alpha.3 → 1.0.0-alpha.5

package/abi-metadata.d.ts

@@ -1,4 +1,4 @@
-import { Contract } from '@algorandfoundation/algorand-typescript';
+import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
 import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
 export interface AbiMetadata {
     methodName: string;
@@ -13,4 +13,4 @@ export declare const attachAbiMetadata: (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;
+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

@@ -11,6 +11,7 @@ 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
@@ -19,3 +20,6 @@ export declare const ZERO_ADDRESS: import("@algorandfoundation/algorand-typescri
 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

@@ -1,4 +1,4 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import { Account, internal } from '@algorandfoundation/algorand-typescript';
 import { AccountData } from '../impl/account';
 import { ApplicationData } from '../impl/application';
 import { AssetData } from '../impl/asset';
@@ -11,14 +11,14 @@ import { TestExecutionContext } from '../test-execution-context';
  */
 declare class InternalContext {
     get value(): TestExecutionContext;
-    get defaultSender(): import("@algorandfoundation/algorand-typescript").Account;
+    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(accountPublicKey: internal.primitives.StubBytesCompat): AccountData;
+    getAccountData(account: Account): AccountData;
     getAssetData(id: internal.primitives.StubUint64Compat): AssetData;
     getApplicationData(id: internal.primitives.StubUint64Compat): ApplicationData;
 }

package/decode-logs.d.ts

@@ -1,3 +1,4 @@
+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[]]> = {
@@ -5,4 +6,4 @@ export type DecodedLogs<T extends [...LogDecoding[]]> = {
 } & {
     length: T['length'];
 };
-export declare function decodeLogs<const T extends [...LogDecoding[]]>(logs: Uint8Array[], decoding: T): DecodedLogs<T>;
+export declare function decodeLogs<const T extends [...LogDecoding[]]>(logs: bytes[], decoding: T): DecodedLogs<T>;

package/impl/account.d.ts

@@ -1,19 +1,20 @@
 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: Map<bigint, AssetHolding>;
-    optedApplications: Map<bigint, Application>;
+    optedAssets: Uint64Map<AssetHolding>;
+    optedApplications: Uint64Map<Application>;
     account: Mutable<Omit<Account, 'bytes' | 'isOptedIn'>>;
     constructor();
 }
-export declare class AccountCls implements Account {
-    readonly bytes: bytes;
-    constructor(address?: internal.primitives.StubBytesCompat);
+export declare class AccountCls extends BytesBackedCls implements Account {
+    constructor(address?: bytes);
     private get data();
     get balance(): uint64;
     get minBalance(): uint64;

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/application.d.ts

@@ -1,15 +1,20 @@
 import { Account, Application, bytes, uint64 } from '@algorandfoundation/algorand-typescript';
+import { BytesMap } from '../collections/custom-key-map';
 import { Mutable } from '../typescript-helpers';
+import { Uint64BackedCls } from './base';
+import { GlobalStateCls, LocalStateMapCls } from './state';
 export declare class ApplicationData {
     application: Mutable<Omit<Application, 'id' | 'address'>> & {
         appLogs: bytes[];
+        globalStates: BytesMap<GlobalStateCls<unknown>>;
+        localStates: BytesMap<LocalStateMapCls<unknown>>;
     };
     isCreating: boolean;
     get appLogs(): bytes[];
     constructor();
 }
-export declare class ApplicationCls implements Application {
-    readonly id: uint64;
+export declare class ApplicationCls extends Uint64BackedCls implements Application {
+    get id(): uint64;
     constructor(id?: uint64);
     private get data();
     get approvalProgram(): bytes;

package/impl/asset.d.ts

@@ -1,8 +1,9 @@
 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 implements Asset {
-    readonly id: uint64;
+export declare class AssetCls extends Uint64BackedCls implements Asset {
+    get id(): uint64;
     constructor(id?: internal.primitives.StubUint64Compat);
     private get data();
     get total(): uint64;

package/impl/base.d.ts

@@ -0,0 +1,11 @@
+import { bytes, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare abstract class BytesBackedCls {
+    #private;
+    get bytes(): bytes;
+    constructor(value: bytes);
+}
+export declare abstract class Uint64BackedCls {
+    #private;
+    get uint64(): uint64;
+    constructor(value: uint64);
+}

package/impl/block.d.ts

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

package/impl/index.d.ts

@@ -1,11 +1,13 @@
 export { AcctParams, balance, minBalance } from './acct-params';
+export { AppGlobal } from './app-global';
 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 { GITxn, ITxn, ITxnCreate } from './itxn';
 export * from './pure';
+export { Scratch, gloadBytes, gloadUint64 } from './scratch';
+export { Block } from './block';
 export { Txn, gaid } from './txn';
-export { GITxn, ITxn, ITxnCreate } from './itxn';
-export { Scratch } from './scratch';

package/impl/scratch.d.ts

@@ -1,2 +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;

package/impl/state.d.ts

@@ -0,0 +1,27 @@
+import { Account, bytes, GlobalState, GlobalStateOptions, LocalState } from '@algorandfoundation/algorand-typescript';
+export declare class GlobalStateCls<ValueType> {
+    #private;
+    private readonly _type;
+    key: bytes | undefined;
+    delete: () => void;
+    static [Symbol.hasInstance](x: unknown): x is GlobalStateCls<unknown>;
+    get value(): ValueType;
+    set value(v: ValueType);
+    get hasValue(): boolean;
+    constructor(key?: bytes | string, value?: ValueType);
+}
+export declare class LocalStateCls<ValueType> {
+    #private;
+    delete: () => void;
+    get value(): ValueType;
+    set value(v: ValueType);
+    get hasValue(): boolean;
+}
+export declare class LocalStateMapCls<ValueType> {
+    #private;
+    getValue(account: Account): LocalStateCls<ValueType>;
+}
+export declare function createGlobalState<ValueType>(options?: GlobalStateOptions<ValueType>): GlobalState<ValueType>;
+export declare function createLocalState<ValueType>(options?: {
+    key?: bytes | string;
+}): LocalState<ValueType>;

package/impl/transactions.d.ts

@@ -98,7 +98,7 @@ export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Part
     approvalProgramPages: Array<bytes>;
     clearStateProgramPages: Array<bytes>;
     appLogs: Array<bytes>;
-    scratchSpace: Array<bytes | uint64>;
+    scratchSpace: Record<number, bytes | uint64>;
 }>;
 export declare class ApplicationTransaction extends TransactionBase implements gtxn.ApplicationTxn {
     #private;
@@ -133,6 +133,7 @@ export declare class ApplicationTransaction extends TransactionBase implements g
     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;