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

package/constants.d.ts

@@ -5,6 +5,7 @@ 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 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;

package/encoders.d.ts

@@ -0,0 +1,21 @@
+import { biguint, bytes, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
+import { OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4';
+export interface 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 declare const getEncoder: <T>(typeInfo: TypeInfo) => fromBytes<T>;
+export {};

package/impl/application.d.ts

@@ -8,6 +8,7 @@ export declare class ApplicationData {
         appLogs: bytes[];
         globalStates: BytesMap<GlobalStateCls<unknown>>;
         localStates: BytesMap<LocalState<unknown>>;
+        boxes: BytesMap<Uint8Array>;
     };
     isCreating: boolean;
     get appLogs(): bytes[];

package/impl/base.d.ts

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

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

@@ -1,12 +1,12 @@
-import { bytes, internal } from '@algorandfoundation/algorand-typescript';
+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: 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 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/index.d.ts

@@ -4,6 +4,7 @@ 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';

package/impl/pure.d.ts

@@ -1,6 +1,6 @@
-import { biguint, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+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: internal.opTypes.Base64, a: internal.primitives.StubBytesCompat) => bytes;
+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;

package/impl/state.d.ts

@@ -1,8 +1,9 @@
-import { Account, bytes, GlobalState, GlobalStateOptions, LocalState } from '@algorandfoundation/algorand-typescript';
+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;
@@ -21,7 +22,82 @@ 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?: {
+export declare function GlobalState<ValueType>(options?: GlobalStateOptions<ValueType>): GlobalStateType<ValueType>;
+export declare function LocalState<ValueType>(options?: {
     key?: bytes | string;
-}): LocalState<ValueType>;
+}): 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;