@algorandfoundation/algorand-typescript 0.0.1-alpha.1

package/arc4/encoded-types.d.ts

@@ -0,0 +1,65 @@
+import { biguint, BigUintCompat, bytes, BytesBacked, StringCompat, uint64, Uint64Compat } from '../primitives';
+import { Account } from '../reference';
+export type BitSize = 8 | 16 | 32 | 64 | 128 | 256 | 512;
+type NativeForArc4Int<N extends BitSize> = N extends 8 | 16 | 32 | 64 ? uint64 : biguint;
+type CompatForArc4Int<N extends BitSize> = N extends 8 | 16 | 32 | 64 ? Uint64Compat : BigUintCompat;
+declare abstract class AbiEncoded implements BytesBacked {
+    get bytes(): bytes;
+}
+export declare class Str extends AbiEncoded {
+    constructor(s: StringCompat);
+    get native(): string;
+}
+export declare class UintN<N extends BitSize> extends AbiEncoded {
+    constructor(v?: CompatForArc4Int<N>);
+    get native(): NativeForArc4Int<N>;
+}
+export declare class UFixedNxM<N extends BitSize, M extends number> {
+    constructor(v: `${number}:${number}`, n?: N, m?: M);
+    get native(): NativeForArc4Int<N>;
+}
+export declare class Byte extends UintN<8> {
+    constructor(v: Uint64Compat);
+    get native(): uint64;
+}
+export declare class Bool {
+    #private;
+    constructor(v: boolean);
+    get native(): boolean;
+}
+declare abstract class Arc4Array<TItem> extends AbiEncoded {
+    protected items: TItem[];
+    protected constructor(items: TItem[]);
+    get length(): uint64;
+    at(index: Uint64Compat): TItem;
+    slice(start: Uint64Compat, end: Uint64Compat): DynamicArray<TItem>;
+    [Symbol.iterator](): IterableIterator<TItem>;
+    entries(): IterableIterator<readonly [uint64, TItem]>;
+    keys(): IterableIterator<uint64>;
+}
+export declare class StaticArray<TItem, TLength extends number> extends Arc4Array<TItem> {
+    constructor();
+    constructor(...items: TItem[] & {
+        length: TLength;
+    });
+    constructor(...items: TItem[]);
+    copy(): StaticArray<TItem, TLength>;
+}
+export declare class DynamicArray<TItem> extends Arc4Array<TItem> {
+    constructor(...items: TItem[]);
+    push(...items: TItem[]): void;
+    pop(): TItem;
+    copy(): DynamicArray<TItem>;
+}
+type ItemAt<TTuple extends unknown[], TIndex extends number> = undefined extends TTuple[TIndex] ? never : TTuple[TIndex];
+export declare class Tuple<TTuple extends unknown[]> {
+    #private;
+    constructor(...items: TTuple);
+    at<TIndex extends number>(index: TIndex): ItemAt<TTuple, TIndex>;
+    get native(): TTuple;
+}
+export declare class Address extends StaticArray<Byte, 32> {
+    constructor(value: Account | string | bytes);
+    get native(): Account;
+}
+export {};

package/arc4/index.d.ts

@@ -0,0 +1,57 @@
+import { BaseContract } from '../base-contract';
+import { DeliberateAny } from '../typescript-helpers';
+export * from './encoded-types';
+export declare class Contract extends BaseContract {
+    approvalProgram(): boolean;
+}
+export type CreateOptions = 'allow' | 'disallow' | 'require';
+export type OnCompleteActionStr = 'NoOp' | 'OptIn' | 'ClearState' | 'CloseOut' | 'UpdateApplication' | 'DeleteApplication';
+export declare enum OnCompleteAction {
+    NoOp,
+    OptIn,
+    CloseOut,
+    ClearState,
+    UpdateApplication,
+    DeleteApplication
+}
+export type DefaultArgument<TContract extends Contract> = {
+    constant: string | boolean | number | bigint;
+} | {
+    from: keyof TContract;
+};
+export type AbiMethodConfig<TContract extends Contract> = {
+    /**
+     * Which on complete action(s) are allowed when invoking this method.
+     * @default 'NoOp'
+     */
+    allowActions?: OnCompleteActionStr | OnCompleteActionStr[];
+    /**
+     * Whether this method should be callable when creating the application.
+     * @default 'disallow'
+     */
+    onCreate?: CreateOptions;
+    /**
+     * Does the method only perform read operations (no mutation of chain state)
+     * @default false
+     */
+    readonly?: boolean;
+    /**
+     * Override the name used to generate the abi method selector
+     */
+    name?: string;
+    defaultArguments?: Record<string, DefaultArgument<TContract>>;
+};
+export declare function abimethod<TContract extends Contract>(config?: AbiMethodConfig<TContract>): <TArgs extends DeliberateAny[], TReturn>(target: (this: TContract, ...args: TArgs) => TReturn, ctx: ClassMethodDecoratorContext<TContract>) => (this: TContract, ...args: TArgs) => TReturn;
+export type BareMethodConfig = {
+    /**
+     * Which on complete action(s) are allowed when invoking this method.
+     * @default 'NoOp'
+     */
+    allowActions?: OnCompleteActionStr | OnCompleteActionStr[];
+    /**
+     * Whether this method should be callable when creating the application.
+     * @default 'disallow'
+     */
+    onCreate?: CreateOptions;
+};
+export declare function baremethod<TContract extends Contract>(config?: BareMethodConfig): <TArgs extends DeliberateAny[], TReturn>(target: (this: TContract, ...args: TArgs) => TReturn, ctx: ClassMethodDecoratorContext<TContract>) => (this: TContract, ...args: TArgs) => TReturn;

package/base-contract.d.ts

@@ -0,0 +1,5 @@
+import { uint64 } from './primitives';
+export declare abstract class BaseContract {
+    abstract approvalProgram(): boolean | uint64;
+    clearStateProgram(): boolean | uint64;
+}

package/box.d.ts

@@ -0,0 +1,52 @@
+import { bytes, uint64 } from './primitives';
+export type Box<TValue> = {
+    readonly key: bytes;
+    value: TValue;
+    readonly exists: boolean;
+    get(options: {
+        default: TValue;
+    }): TValue;
+    delete(): boolean;
+    maybe(): readonly [TValue, boolean];
+    readonly length: uint64;
+};
+export type BoxMap<TKey, TValue> = {
+    readonly keyPrefix: bytes;
+    get(key: TKey): TValue;
+    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;
+};
+export type BoxRef = {
+    readonly key: bytes;
+    readonly exists: boolean;
+    value: bytes;
+    get(options: {
+        default: bytes;
+    }): bytes;
+    put(value: bytes): bytes;
+    splice(start: uint64, end: uint64, value: bytes): void;
+    replace(start: uint64, value: bytes): void;
+    extract(start: uint64, length: uint64): bytes;
+    delete(): boolean;
+    create(options: {
+        size: uint64;
+    }): boolean;
+    resize(newSize: uint64): void;
+    maybe(): readonly [bytes, boolean];
+    readonly length: uint64;
+};
+export declare function Box<TValue>(options: {
+    key: bytes | string;
+}): Box<TValue>;
+export declare function BoxMap<TKey, TValue>(options: {
+    keyPrefix: bytes | string;
+}): BoxMap<TKey, TValue>;
+export declare function BoxRef(options: {
+    key: bytes | string;
+}): BoxRef;

package/execution-context.d.ts

@@ -0,0 +1,40 @@
+import { Contract, gtxn, itxn } from '.';
+import { AbiMethodConfig, BareMethodConfig } from './arc4';
+import { OpsNamespace } from './op-types';
+import { bytes, uint64 } from './primitives';
+import { Account, Application, Asset } from './reference';
+export type ExecutionContext = {
+    log(value: bytes): void;
+    application(id?: uint64): Application;
+    asset(id?: uint64): Asset;
+    account(address?: bytes): Account;
+    op: Partial<OpsNamespace>;
+    abiMetadata: {
+        captureMethodConfig<T extends Contract>(contract: T, methodName: string, config?: AbiMethodConfig<T> | BareMethodConfig): void;
+    };
+    gtxn: {
+        Transaction: typeof gtxn.Transaction;
+        PaymentTxn: typeof gtxn.PaymentTxn;
+        KeyRegistrationTxn: typeof gtxn.KeyRegistrationTxn;
+        AssetConfigTxn: typeof gtxn.AssetConfigTxn;
+        AssetTransferTxn: typeof gtxn.AssetTransferTxn;
+        AssetFreezeTxn: typeof gtxn.AssetFreezeTxn;
+        ApplicationTxn: typeof gtxn.ApplicationTxn;
+    };
+    itxn: {
+        submitGroup: typeof itxn.submitGroup;
+        payment: typeof itxn.payment;
+        keyRegistration: typeof itxn.keyRegistration;
+        assetConfig: typeof itxn.assetConfig;
+        assetTransfer: typeof itxn.assetTransfer;
+        assetFreeze: typeof itxn.assetFreeze;
+        applicationCall: typeof itxn.applicationCall;
+    };
+};
+declare global {
+    var puyaTsExecutionContext: ExecutionContext | undefined;
+}
+export declare const ctxMgr: {
+    instance: ExecutionContext;
+    reset(): void;
+};

package/gtxn.d.ts

@@ -0,0 +1,30 @@
+import { uint64 } from './primitives';
+import type * as txnTypes from './transactions';
+declare const isGtxn: unique symbol;
+export interface PaymentTxn extends txnTypes.PaymentTxn {
+    [isGtxn]?: true;
+}
+export interface KeyRegistrationTxn extends txnTypes.KeyRegistrationTxn {
+    [isGtxn]?: true;
+}
+export interface AssetConfigTxn extends txnTypes.AssetConfigTxn {
+    [isGtxn]?: true;
+}
+export interface AssetTransferTxn extends txnTypes.AssetTransferTxn {
+    [isGtxn]?: true;
+}
+export interface AssetFreezeTxn extends txnTypes.AssetFreezeTxn {
+    [isGtxn]?: true;
+}
+export interface ApplicationTxn extends txnTypes.ApplicationTxn {
+    [isGtxn]?: true;
+}
+export type Transaction = PaymentTxn | KeyRegistrationTxn | AssetConfigTxn | AssetTransferTxn | AssetFreezeTxn | ApplicationTxn;
+export declare function Transaction(groupIndex: uint64): Transaction;
+export declare function PaymentTxn(groupIndex: uint64): PaymentTxn;
+export declare function KeyRegistrationTxn(groupIndex: uint64): KeyRegistrationTxn;
+export declare function AssetConfigTxn(groupIndex: uint64): AssetConfigTxn;
+export declare function AssetTransferTxn(groupIndex: uint64): AssetTransferTxn;
+export declare function AssetFreezeTxn(groupIndex: uint64): AssetFreezeTxn;
+export declare function ApplicationTxn(groupIndex: uint64): ApplicationTxn;
+export {};

package/impl/base-32.d.ts

@@ -0,0 +1,2 @@
+export declare const base32ToUint8Array: (value: string) => Uint8Array;
+export declare const uint8ArrayToBase32: (value: Uint8Array) => string;

package/impl/encoding-util.d.ts

@@ -0,0 +1,8 @@
+export declare const uint8ArrayToBigInt: (v: Uint8Array) => bigint;
+export declare const bigIntToUint8Array: (val: bigint, fixedSize?: number | "dynamic") => Uint8Array;
+export declare const utf8ToUint8Array: (value: string) => Uint8Array;
+export declare const uint8ArrayToUtf8: (value: Uint8Array) => string;
+export declare const uint8ArrayToHex: (value: Uint8Array) => string;
+export declare const uint8ArrayToBase64: (value: Uint8Array) => string;
+export declare const uint8ArrayToBase64Url: (value: Uint8Array) => string;
+export { uint8ArrayToBase32 } from './base-32';

package/impl/errors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Raised when an `err` op is encountered, or when the testing VM is asked to do something that would cause
+ * the AVM to fail.
+ */
+export declare class AvmError extends Error {
+    constructor(message: string);
+}
+export declare function avmError(message: string): never;
+/**
+ * Raised when an assertion fails
+ */
+export declare class AssertError extends AvmError {
+    constructor(message: string);
+}
+/**
+ * Raised when testing code errors
+ */
+export declare class InternalError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function internalError(message: string): never;
+/**
+ * Raised when unsupported user code is encountered
+ */
+export declare class CodeError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function codeError(message: string): never;

package/impl/name-of-type.d.ts

@@ -0,0 +1 @@
+export declare const nameOfType: (x: unknown) => string;

package/impl/primitives.d.ts

@@ -0,0 +1,77 @@
+import type { biguint, BigUintCompat, bytes, BytesCompat, uint64, Uint64Compat } from '../index';
+export type StubBigUintCompat = BigUintCompat | BigUintCls | Uint64Cls;
+export type StubBytesCompat = BytesCompat | BytesCls;
+export type StubUint64Compat = Uint64Compat | Uint64Cls;
+export declare function toExternalValue(val: uint64): bigint;
+export declare function toExternalValue(val: biguint): bigint;
+export declare function toExternalValue(val: bytes): Uint8Array;
+export declare function toExternalValue(val: string): string;
+export declare const toBytes: (val: unknown) => bytes;
+export declare const isBytes: (v: unknown) => v is StubBytesCompat;
+export declare const isUint64: (v: unknown) => v is StubUint64Compat;
+export declare const isBigUint: (v: unknown) => v is biguint;
+export declare const checkUint64: (v: bigint) => bigint;
+export declare const checkBigUint: (v: bigint) => bigint;
+export declare const checkBytes: (v: Uint8Array) => Uint8Array;
+export declare abstract class AlgoTsPrimitiveCls {
+    private readonly _type;
+    constructor(t: string);
+    static [Symbol.hasInstance](x: unknown): x is AlgoTsPrimitiveCls;
+    abstract valueOf(): bigint | string | boolean;
+    abstract toBytes(): BytesCls;
+}
+export declare class Uint64Cls extends AlgoTsPrimitiveCls {
+    readonly value: bigint;
+    constructor(value: bigint | number | string);
+    static [Symbol.hasInstance](x: unknown): x is Uint64Cls;
+    static fromCompat(v: StubUint64Compat): Uint64Cls;
+    static getNumber(v: StubUint64Compat): number;
+    valueOf(): bigint;
+    toBytes(isDynamic?: boolean): BytesCls;
+    asAlgoTs(): uint64;
+    asBigInt(): bigint;
+    asNumber(): number;
+}
+export declare class BigUintCls extends AlgoTsPrimitiveCls {
+    readonly value: bigint;
+    constructor(value: bigint);
+    valueOf(): bigint;
+    toBytes(): BytesCls;
+    asAlgoTs(): biguint;
+    asBigInt(): bigint;
+    asNumber(): number;
+    static [Symbol.hasInstance](x: unknown): x is BigUintCls;
+    static fromCompat(v: StubBigUintCompat): BigUintCls;
+}
+export declare class BytesCls extends AlgoTsPrimitiveCls {
+    #private;
+    constructor(v: Uint8Array);
+    get length(): Uint64Cls;
+    toBytes(): BytesCls;
+    at(i: StubUint64Compat): BytesCls;
+    slice(start: StubUint64Compat, end: StubUint64Compat): BytesCls;
+    concat(other: StubBytesCompat): BytesCls;
+    bitwiseAnd(other: StubBytesCompat): BytesCls;
+    bitwiseOr(other: StubBytesCompat): BytesCls;
+    bitwiseXor(other: StubBytesCompat): BytesCls;
+    bitwiseInvert(): BytesCls;
+    equals(other: StubBytesCompat): boolean;
+    private bitwiseOp;
+    valueOf(): string;
+    static [Symbol.hasInstance](x: unknown): x is BytesCls;
+    static fromCompat(v: StubBytesCompat | undefined): BytesCls;
+    static fromInterpolation(template: TemplateStringsArray, replacements: StubBytesCompat[]): BytesCls;
+    static fromHex(hex: string): BytesCls;
+    static fromBase64(b64: string): BytesCls;
+    static fromBase32(b32: string): BytesCls;
+    toUint64(): Uint64Cls;
+    toBigUint(): BigUintCls;
+    toString(): string;
+    asAlgoTs(): bytes;
+    asUint8Array(): Uint8Array;
+}
+export declare const arrayUtil: {
+    arrayAt<T>(arrayLike: T[], index: StubUint64Compat): T;
+    arraySlice(arrayLike: Uint8Array, start: StubUint64Compat, end: StubUint64Compat): Uint8Array;
+    arraySlice<T>(arrayLike: T[], start: StubUint64Compat, end: StubUint64Compat): T[];
+};

package/impl/state.d.ts

@@ -0,0 +1,24 @@
+import { bytes } from '../primitives';
+import { Account } from '../reference';
+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>;
+}