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

package/impl/state.d.ts

@@ -0,0 +1,103 @@
+import { Account, BoxMap as BoxMapType, BoxRef as BoxRefType, Box as BoxType, bytes, GlobalStateOptions, GlobalState as GlobalStateType, internal, LocalState as LocalStateType, uint64 } from '@algorandfoundation/algorand-typescript';
+export declare class GlobalStateCls<ValueType> {
+    #private;
+    private readonly _type;
+    key: bytes | undefined;
+    get hasKey(): boolean;
+    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 GlobalState<ValueType>(options?: GlobalStateOptions<ValueType>): GlobalStateType<ValueType>;
+export declare function LocalState<ValueType>(options?: {
+    key?: bytes | string;
+}): LocalStateType<ValueType>;
+export declare class BoxCls<TValue> {
+    #private;
+    private readonly _type;
+    static [Symbol.hasInstance](x: unknown): x is BoxCls<unknown>;
+    constructor(key?: internal.primitives.StubBytesCompat);
+    private get fromBytes();
+    get value(): TValue;
+    set value(v: TValue);
+    get hasKey(): boolean;
+    get key(): bytes;
+    set key(key: internal.primitives.StubBytesCompat);
+    get exists(): boolean;
+    get length(): uint64;
+    get(options: {
+        default: TValue;
+    }): TValue;
+    delete(): boolean;
+    maybe(): readonly [TValue, boolean];
+}
+export declare class BoxMapCls<TKey, TValue> {
+    #private;
+    private readonly _type;
+    static [Symbol.hasInstance](x: unknown): x is BoxMapCls<unknown, unknown>;
+    private get fromBytes();
+    constructor(keyPrefix?: internal.primitives.StubBytesCompat);
+    get hasKeyPrefix(): boolean;
+    get keyPrefix(): bytes;
+    set keyPrefix(keyPrefix: internal.primitives.StubBytesCompat);
+    get(key: TKey, options?: {
+        default: TValue;
+    }): TValue;
+    set(key: TKey, value: TValue): void;
+    delete(key: TKey): boolean;
+    has(key: TKey): boolean;
+    maybe(key: TKey): readonly [TValue, boolean];
+    length(key: TKey): uint64;
+    private getFullKey;
+}
+export declare class BoxRefCls {
+    #private;
+    private readonly _type;
+    static [Symbol.hasInstance](x: unknown): x is BoxRefCls;
+    constructor(key?: internal.primitives.StubBytesCompat);
+    get hasKey(): boolean;
+    get key(): bytes;
+    set key(key: internal.primitives.StubBytesCompat);
+    get value(): bytes;
+    set value(v: internal.primitives.StubBytesCompat);
+    get exists(): boolean;
+    create(options: {
+        size: internal.primitives.StubUint64Compat;
+    }): boolean;
+    get(options: {
+        default: internal.primitives.StubBytesCompat;
+    }): bytes;
+    put(value: internal.primitives.StubBytesCompat): void;
+    splice(start: internal.primitives.StubUint64Compat, length: internal.primitives.StubUint64Compat, value: internal.primitives.StubBytesCompat): void;
+    replace(start: internal.primitives.StubUint64Compat, value: internal.primitives.StubBytesCompat): void;
+    extract(start: internal.primitives.StubUint64Compat, length: internal.primitives.StubUint64Compat): bytes;
+    delete(): boolean;
+    resize(newSize: uint64): void;
+    maybe(): readonly [bytes, boolean];
+    get length(): uint64;
+    private get backingValue();
+    private set backingValue(value);
+}
+export declare function Box<TValue>(options?: {
+    key: bytes | string;
+}): BoxType<TValue>;
+export declare function BoxMap<TKey, TValue>(options?: {
+    keyPrefix: bytes | string;
+}): BoxMapType<TKey, TValue>;
+export declare function BoxRef(options?: {
+    key: bytes | string;
+}): BoxRefType;

package/impl/transactions.d.ts

@@ -0,0 +1,140 @@
+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: Record<number, 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;
+    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;
+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';