@algorandfoundation/algorand-typescript 1.0.0-beta.3 → 1.0.0-beta.30

package/arc-28.d.ts

@@ -1,4 +1,4 @@
-import { DeliberateAny } from './typescript-helpers';
+import { DeliberateAny } from './internal/typescript-helpers';
 /**
  * Emit an arc28 event log using either an ARC4Struct type or a named object type.
  * Object types must have an ARC4 equivalent type.

package/arc4/c2c.d.ts

@@ -0,0 +1,81 @@
+import { CompileContractOptions, CompiledContract } from '../compiled';
+import * as gtxn from '../gtxn';
+import { AnyFunction, ConstructorFor, DeliberateAny, InstanceMethod } from '../internal/typescript-helpers';
+import * as itxn from '../itxn';
+import { ApplicationCallFields, ApplicationCallInnerTxn } from '../itxn';
+import { Contract } from './index';
+/**
+ * Defines txn fields that are available for a bare create application call.
+ *
+ * This is the regular application call fields minus:
+ *  - appId: because the appId is not known when creating an application
+ *  - appArgs: because a bare call cannot have arguments
+ */
+export type BareCreateApplicationCallFields = Omit<ApplicationCallFields, 'appId' | 'appArgs'>;
+/**
+ * Conditional type which given a group transaction type, returns the equivalent inner transaction
+ * params type.
+ */
+export type GtxnToItxnFields<T extends gtxn.Transaction> = T extends gtxn.PaymentTxn ? itxn.PaymentItxnParams : T extends gtxn.KeyRegistrationTxn ? itxn.KeyRegistrationItxnParams : T extends gtxn.AssetConfigTxn ? itxn.AssetConfigItxnParams : T extends gtxn.AssetTransferTxn ? itxn.AssetTransferItxnParams : T extends gtxn.AssetFreezeTxn ? itxn.AssetFreezeItxnParams : T extends gtxn.ApplicationCallTxn ? itxn.ApplicationCallItxnParams : itxn.ItxnParams;
+/**
+ * Conditional type which given an application argument, returns the input type for that argument.
+ *
+ * The input type will usually be the original type apart from group transactions which will be substituted
+ * with their equivalent inner transaction type.
+ */
+export type TypedApplicationArg<TArg> = TArg extends gtxn.Transaction ? GtxnToItxnFields<TArg> : TArg;
+/**
+ * Conditional type which maps a tuple of application arguments to a tuple of input types for specifying those arguments.
+ */
+export type TypedApplicationArgs<TArgs> = TArgs extends [] ? [] : TArgs extends [infer TArg, ...infer TRest] ? [TypedApplicationArg<TArg>, ...TypedApplicationArgs<TRest>] : never;
+/**
+ * Application call fields with `appArgs` replaced with an `args` property that is strongly typed to the actual arguments for the
+ * given application call.
+ */
+export type TypedApplicationCallFields<TArgs> = Omit<ApplicationCallFields, 'appArgs'> & (TArgs extends [] ? {
+    args?: TypedApplicationArgs<TArgs>;
+} : {
+    args: TypedApplicationArgs<TArgs>;
+});
+/**
+ * The response type of a typed application call. Includes the raw itxn result object and the parsed ABI return value if applicable.
+ */
+export type TypedApplicationCallResponse<TReturn> = TReturn extends void ? {
+    itxn: ApplicationCallInnerTxn;
+} : {
+    itxn: ApplicationCallInnerTxn;
+    returnValue: TReturn;
+};
+/**
+ * Conditional type which maps an ABI method to a factory method for constructing an application call transaction to call that method.
+ */
+export type ContractProxyMethod<TMethod> = TMethod extends (...args: infer TArgs) => infer TReturn ? (fields?: TypedApplicationCallFields<TArgs>) => TypedApplicationCallResponse<TReturn> : never;
+/**
+ * Conditional type which maps an ARC4 compatible contract to a proxy object which allows for constructing application call transactions for
+ * all available ABI and bare methods. Also includes the compiled contract result data.
+ */
+export type ContractProxy<TContract extends Contract> = CompiledContract & {
+    /**
+     * Get methods for calling ABI and bare methods on the target contract
+     */
+    call: {
+        [key in keyof TContract as key extends 'approvalProgram' | 'clearStateProgram' ? never : TContract[key] extends AnyFunction ? key : never]: ContractProxyMethod<TContract[key]>;
+    };
+    /**
+     * Create a bare application call itxn to create the contract.
+     * @param fields Specify values for transaction fields which should override the default values.
+     */
+    bareCreate(fields?: BareCreateApplicationCallFields): ApplicationCallInnerTxn;
+};
+/**
+ * Pre compile the target ARC4 contract and return a proxy object for constructing inner transactions to call an instance of that contract.
+ * @param contract An ARC4 contract class
+ * @param options Compile contract arguments
+ */
+export declare function compileArc4<TContract extends Contract>(contract: ConstructorFor<TContract>, options?: CompileContractOptions): ContractProxy<TContract>;
+/**
+ * Invokes the target ABI method using a strongly typed fields object.
+ * @param method An ABI method function reference.
+ * @param fields Specify values for transaction fields.
+ */
+export declare function abiCall<TArgs extends DeliberateAny[], TReturn>(method: InstanceMethod<Contract, TArgs, TReturn>, fields: TypedApplicationCallFields<TArgs>): TypedApplicationCallResponse<TReturn>;

package/arc4/encoded-types.d.ts

@@ -1,51 +1,143 @@
-import { biguint, BigUintCompat, bytes, BytesBacked, BytesCompat, StringCompat, uint64, Uint64Compat } from '../primitives';
+import { biguint, BigUintCompat, bytes, BytesBacked, StringCompat, uint64, Uint64Compat } from '../primitives';
 import { Account } from '../reference';
+/**
+ * Defines UintN bit sizes which are compatible with the uint64 type
+ */
 type UintBitSize = 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64;
+/**
+ * Defines UintN bit sizes which are only compatible with the biguint type
+ */
 type BigUintBitSize = 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256 | 264 | 272 | 280 | 288 | 296 | 304 | 312 | 320 | 328 | 336 | 344 | 352 | 360 | 368 | 376 | 384 | 392 | 400 | 408 | 416 | 424 | 432 | 440 | 448 | 456 | 464 | 472 | 480 | 488 | 496 | 504 | 512;
+/**
+ * Defines supported bit sizes for the UintN and UFixedNxM types
+ */
 export type BitSize = UintBitSize | BigUintBitSize;
+/**
+ * Conditional type which returns the native equivalent type for a given UintN bit size
+ */
 type NativeForArc4Int<N extends BitSize> = N extends UintBitSize ? uint64 : biguint;
+/**
+ * Conditional type which returns the compat type relevant to a given UintN bit size
+ */
 type CompatForArc4Int<N extends BitSize> = N extends UintBitSize ? Uint64Compat : BigUintCompat;
+/**
+ * @hidden
+ */
 declare const TypeProperty: unique symbol;
+/**
+ * A base type for ARC4 encoded values
+ */
 export declare abstract class ARC4Encoded implements BytesBacked {
+    /** @hidden */
     abstract [TypeProperty]?: string;
+    /**
+     * Retrieve the encoded bytes for this type
+     */
     get bytes(): bytes;
 }
+/**
+ * A utf8 encoded string prefixed with its length expressed as a 2 byte uint
+ */
 export declare class Str extends ARC4Encoded {
-    #private;
+    /** @hidden */
     [TypeProperty]?: 'arc4.Str';
+    /**
+     * Create a new Str instance
+     * @param s The native string to initialize this Str from
+     */
     constructor(s?: StringCompat);
+    /**
+     * Retrieve the decoded native string
+     */
     get native(): string;
 }
+/**
+ * A fixed bit size unsigned int
+ */
 export declare class UintN<N extends BitSize> extends ARC4Encoded {
+    /** @hidden */
     [TypeProperty]?: `arc4.UintN<${N}>`;
+    /**
+     * Create a new UintN instance
+     * @param v The native uint64 or biguint value to initialize this UintN from
+     */
     constructor(v?: CompatForArc4Int<N>);
+    /**
+     * Retrieve the decoded native uint64 or biguint
+     */
     get native(): NativeForArc4Int<N>;
 }
+/**
+ * An alias for UintN<8>
+ */
 export declare class Byte extends UintN<8> {
 }
+/**
+ * An alias for UintN<8>
+ */
 export declare class UintN8 extends UintN<8> {
 }
+/**
+ * An alias for UintN<16>
+ */
 export declare class UintN16 extends UintN<16> {
 }
+/**
+ * An alias for UintN<32>
+ */
 export declare class UintN32 extends UintN<32> {
 }
+/**
+ * An alias for UintN<64>
+ */
 export declare class UintN64 extends UintN<64> {
 }
+/**
+ * An alias for UintN<128>
+ */
 export declare class UintN128 extends UintN<128> {
 }
+/**
+ * An alias for UintN<256>
+ */
 export declare class UintN256 extends UintN<256> {
 }
+/**
+ * A fixed bit size, fixed decimal unsigned value
+ */
 export declare class UFixedNxM<N extends BitSize, M extends number> extends ARC4Encoded {
+    /** @hidden */
     [TypeProperty]?: `arc4.UFixedNxM<${N}x${M}>`;
-    constructor(v: `${number}.${number}`);
+    /**
+     * Create a new UFixedNxM value
+     * @param v A string representing the integer and fractional portion of the number
+     */
+    constructor(v?: `${number}.${number}`);
+    /**
+     * Retrieve the decoded native uint64 or biguint where the returned integer represents the fixed decimal value * (10 ^ M)
+     */
     get native(): NativeForArc4Int<N>;
 }
+/**
+ * A boolean value
+ */
 export declare class Bool extends ARC4Encoded {
+    /** @hidden */
     [TypeProperty]?: `arc4.Bool`;
+    /**
+     * Create a new Bool value
+     * @param v The native boolean to initialize this value from
+     */
     constructor(v?: boolean);
+    /**
+     * Get the decoded native boolean for this value
+     */
     get native(): boolean;
 }
-declare abstract class Arc4ReadonlyArray<TItem extends ARC4Encoded> extends ARC4Encoded {
+/**
+ * A base type for arc4 array types
+ */
+declare abstract class Arc4ArrayBase<TItem extends ARC4Encoded> extends ARC4Encoded {
     protected constructor();
     /**
      * Returns the current length of this array
@@ -75,17 +167,46 @@ declare abstract class Arc4ReadonlyArray<TItem extends ARC4Encoded> extends ARC4
      */
     [index: uint64]: TItem;
 }
-export declare class StaticArray<TItem extends ARC4Encoded, TLength extends number> extends Arc4ReadonlyArray<TItem> {
+/**
+ * A fixed sized array of arc4 items
+ * @typeParam TItem The type of a single item in the array
+ * @typeParam TLength The fixed length of the array
+ */
+export declare class StaticArray<TItem extends ARC4Encoded, TLength extends number> extends Arc4ArrayBase<TItem> {
+    /** @hidden */
     [TypeProperty]?: `arc4.StaticArray<${TItem[typeof TypeProperty]}, ${TLength}>`;
+    /**
+     * Create a new StaticArray instance
+     */
     constructor();
+    /**
+     * Create a new StaticArray instance with the specified items
+     * @param items The initial items for the array
+     */
     constructor(...items: TItem[] & {
         length: TLength;
     });
-    constructor(...items: TItem[]);
+    /**
+     * Returns a copy of this array
+     */
     copy(): StaticArray<TItem, TLength>;
+    /**
+     * Returns a new array containing all items from _this_ array, and _other_ array
+     * @param other Another array to concat with this one
+     */
+    concat(other: Arc4ArrayBase<TItem>): DynamicArray<TItem>;
 }
-export declare class DynamicArray<TItem extends ARC4Encoded> extends Arc4ReadonlyArray<TItem> {
+/**
+ * A dynamic sized array of arc4 items
+ * @typeParam TItem The type of a single item in the array
+ */
+export declare class DynamicArray<TItem extends ARC4Encoded> extends Arc4ArrayBase<TItem> {
+    /** @hidden */
     [TypeProperty]?: `arc4.DynamicArray<${TItem[typeof TypeProperty]}>`;
+    /**
+     * Create a new DynamicArray with the specified items
+     * @param items The initial items for the array
+     */
     constructor(...items: TItem[]);
     /**
      * Push a number of items into this array
@@ -96,52 +217,134 @@ export declare class DynamicArray<TItem extends ARC4Encoded> extends Arc4Readonl
      * Pop a single item from this array
      */
     pop(): TItem;
+    /**
+     * Returns a copy of this array
+     */
     copy(): DynamicArray<TItem>;
+    /**
+     * Returns a new array containing all items from _this_ array, and _other_ array
+     * @param other Another array to concat with this one
+     */
+    concat(other: Arc4ArrayBase<TItem>): DynamicArray<TItem>;
 }
+/**
+ * @hidden
+ */
 type ExpandTupleType<T extends ARC4Encoded[]> = T extends [infer T1 extends ARC4Encoded, ...infer TRest extends ARC4Encoded[]] ? TRest extends [] ? `${T1[typeof TypeProperty]}` : `${T1[typeof TypeProperty]},${ExpandTupleType<TRest>}` : '';
+/**
+ * An arc4 encoded tuple of values
+ * @typeParam TTuple A type representing the native tuple of item types
+ */
 export declare class Tuple<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> extends ARC4Encoded {
+    /** @hidden */
     [TypeProperty]?: `arc4.Tuple<${ExpandTupleType<TTuple>}>`;
+    /**
+     * Create a new Tuple with the default zero values for items
+     */
+    constructor();
+    /**
+     * Create a new Tuple with the specified items
+     * @param items The tuple items
+     */
     constructor(...items: TTuple);
+    /**
+     * Returns the item at the specified index
+     * @param index The index of the item to get. Must be a positive literal representing a tuple index
+     */
     at<TIndex extends keyof TTuple>(index: TIndex): TTuple[TIndex];
+    /**
+     * Returns the length of this tuple
+     */
     get length(): TTuple['length'] & uint64;
+    /**
+     * Returns the decoded native tuple (with arc4 encoded items)
+     */
     get native(): TTuple;
 }
-export declare class Address extends Arc4ReadonlyArray<Byte> {
+/**
+ * A 32 byte Algorand Address
+ */
+export declare class Address extends Arc4ArrayBase<Byte> {
+    /** @hidden */
     [TypeProperty]?: `arc4.Address`;
+    /**
+     * Create a new Address instance
+     * @param value An Account, base 32 address string, or the address bytes
+     */
     constructor(value?: Account | string | bytes);
+    /**
+     * Returns an Account instance for this Address
+     */
     get native(): Account;
 }
-type StructConstraint = Record<string, ARC4Encoded>;
-declare class StructBase extends ARC4Encoded {
+/**
+ * The base type for arc4 structs
+ */
+declare class StructBase<T> extends ARC4Encoded {
+    /** @hidden */
     [TypeProperty]: string;
+    get native(): T;
+    /**
+     * Returns a deep copy of this struct
+     */
+    copy(): this;
 }
-type StructConstructor = new <T extends StructConstraint>(initial: T) => StructBase & T;
+/**
+ * Type alias for the Struct constructor function
+ * @typeParam T The shape of the arc4 struct
+ */
+type StructConstructor = {
+    new <T extends Record<string, ARC4Encoded>>(initial: T): StructBase<T> & T;
+};
+/**
+ * The base type of arc4 structs
+ *
+ * Usage:
+ * ```
+ * class MyStruct extends Struct<{ x: UintN8, y: Str, z: DynamicBytes }> {}
+ * ```
+ */
 export declare const Struct: StructConstructor;
-export declare class DynamicBytes extends Arc4ReadonlyArray<Byte> {
+/**
+ * A variable length sequence of bytes prefixed with its length expressed as a 2 byte uint
+ */
+export declare class DynamicBytes extends Arc4ArrayBase<Byte> {
+    /** @hidden */
     [TypeProperty]?: `arc4.DynamicBytes`;
+    /**
+     * Create a new DynamicBytes instance
+     * @param value The bytes or utf8 interpreted string to initialize this type
+     */
     constructor(value?: bytes | string);
+    /**
+     * Get the native bytes value (excludes the length prefix)
+     */
     get native(): bytes;
+    /**
+     * Returns a dynamic bytes object containing all bytes from _this_ and _other_
+     * @param other Another array of bytes to concat with this one
+     */
+    concat(other: Arc4ArrayBase<Byte>): DynamicBytes;
 }
-export declare class StaticBytes<TLength extends number = 0> extends Arc4ReadonlyArray<Byte> {
+/**
+ * A fixed length sequence of bytes
+ */
+export declare class StaticBytes<TLength extends number = 0> extends Arc4ArrayBase<Byte> {
+    /** @hidden */
     [TypeProperty]?: `arc4.StaticBytes<${TLength}>`;
+    /**
+     * Create a new StaticBytes instance
+     * @param value THe bytes or utf8 interpreted string to initialize this type
+     */
     constructor(value?: bytes | string);
+    /**
+     * Get the native bytes value
+     */
     get native(): bytes;
+    /**
+     * Returns a dynamic bytes object containing all bytes from _this_ and _other_
+     * @param other Another array of bytes to concat with this one
+     */
+    concat(other: Arc4ArrayBase<Byte>): DynamicBytes;
 }
-/**
- * Interpret the provided bytes as an ARC4 encoded type with no validation
- * @param bytes An arc4 encoded bytes value
- * @param prefix The prefix (if any), present in the bytes value. This prefix will be validated and removed
- */
-export declare function interpretAsArc4<T extends ARC4Encoded>(bytes: BytesCompat, prefix?: 'none' | 'log'): T;
-/**
- * Decode the provided bytes to a native Algorand TypeScript value
- * @param bytes An arc4 encoded bytes value
- * @param prefix The prefix (if any), present in the bytes value. This prefix will be validated and removed
- */
-export declare function decodeArc4<T>(bytes: BytesCompat, prefix?: 'none' | 'log'): T;
-/**
- * Encode the provided Algorand TypeScript value as ARC4 bytes
- * @param value Any native Algorand TypeScript value with a supported ARC4 encoding
- */
-export declare function encodeArc4<T>(value: T): bytes;
 export {};

package/arc4/index.d.ts

@@ -1,25 +1,51 @@
 import { BaseContract } from '../base-contract';
-import { bytes } from '../primitives';
-import { DeliberateAny } from '../typescript-helpers';
+import { DeliberateAny, InstanceMethod } from '../internal/typescript-helpers';
+import { OnCompleteActionStr } from '../on-complete-action';
+import { bytes, BytesCompat, uint64 } from '../primitives';
+import { ARC4Encoded } from './encoded-types';
 export * from './encoded-types';
+export * from './c2c';
+/**
+ * The base type for all ARC4 contracts in Algorand TypeScript
+ */
 export declare class Contract extends BaseContract {
+    /**
+     * Default implementation of an ARC4 approval program, routes transactions to ABI or bare methods based on application
+     * args and on completion actions
+     */
     approvalProgram(): boolean;
 }
+/**
+ * The possible options for a method being available on application create
+ *
+ * allow: This method CAN be called when the application is being created, but it is not required
+ * disallow: This method CANNOT be called when the application is being created
+ * require: This method CAN ONLY be called when the application is being created
+ */
 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
-}
+/**
+ * Type alias for a default argument schema
+ * @typeParam TContract The type of the contract containing the method this default argument is for
+ */
 export type DefaultArgument<TContract extends Contract> = {
+    /**
+     * A compile time constant value to be used as a default
+     */
     constant: string | boolean | number | bigint;
 } | {
+    /**
+     * Retrieve the default value from a member of this contract. The member can be
+     *
+     * LocalState: The value is retrieved from the calling user's local state before invoking this method
+     * GlobalState: The value is retrieved from the specified global state key before invoking this method
+     * Method: Any readonly abimethod with no arguments can be used as a source
+     */
     from: keyof TContract;
 };
+/**
+ * Configuration options for an abi method
+ * @typeParam TContract the type of the contract this method is a part of
+ */
 export type AbiMethodConfig<TContract extends Contract> = {
     /**
      * Which on complete action(s) are allowed when invoking this method.
@@ -40,9 +66,22 @@ export type AbiMethodConfig<TContract extends Contract> = {
      * Override the name used to generate the abi method selector
      */
     name?: string;
+    /**
+     * Specify default arguments that can be populated by clients calling this method.
+     *
+     * A map of parameter names to the default argument source
+     */
     defaultArguments?: Record<string, DefaultArgument<TContract>>;
 };
+/**
+ * Declares the decorated method as an abimethod that is called when the first transaction arg matches the method selector
+ * @param config The config for this abi method
+ * @typeParam TContract the type of the contract this method is a part of
+ */
 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;
+/**
+ * Configuration options for a bare method
+ */
 export type BareMethodConfig = {
     /**
      * Which on complete action(s) are allowed when invoking this method.
@@ -55,11 +94,47 @@ export type BareMethodConfig = {
      */
     onCreate?: CreateOptions;
 };
+/**
+ * Declares the decorated method as a baremethod that can only be called with no transaction args
+ * @param config The config for this bare method
+ * @typeParam TContract the type of the contract this method is a part of
+ */
 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;
 /**
  * Returns the ARC4 method selector for a given ARC4 method signature. The method selector is the first
  * 4 bytes of the SHA512/256 hash of the method signature.
- * @param methodSignature An ARC4 method signature. Eg. `hello(string)string`. Must be a compile time constant.
+ * @param methodSignature An ARC4 contract method reference. (Eg. `MyContract.prototype.myMethod`)
+ * @returns The ARC4 method selector. Eg. `02BECE11`
+ */
+export declare function methodSelector(methodSignature: InstanceMethod<Contract>): bytes;
+/**
+ * Returns the ARC4 method selector for a given ARC4 method signature. The method selector is the first
+ * 4 bytes of the SHA512/256 hash of the method signature.
+ * @param methodSignature An ARC4 method signature string (Eg. `hello(string)string`.  Must be a compile time constant)
  * @returns The ARC4 method selector. Eg. `02BECE11`
  */
 export declare function methodSelector(methodSignature: string): bytes;
+/**
+ * Interpret the provided bytes as an ARC4 encoded type with no validation
+ * @param bytes An arc4 encoded bytes value
+ * @param prefix The prefix (if any), present in the bytes value. This prefix will be validated and removed
+ */
+export declare function interpretAsArc4<T extends ARC4Encoded>(bytes: BytesCompat, prefix?: 'none' | 'log'): T;
+/**
+ * Decode the provided bytes to a native Algorand TypeScript value
+ * @param bytes An arc4 encoded bytes value
+ * @param prefix The prefix (if any), present in the bytes value. This prefix will be validated and removed
+ */
+export declare function decodeArc4<T>(bytes: BytesCompat, prefix?: 'none' | 'log'): T;
+/**
+ * Encode the provided Algorand TypeScript value as ARC4 bytes
+ * @param value Any native Algorand TypeScript value with a supported ARC4 encoding
+ */
+export declare function encodeArc4<const T>(value: T): bytes;
+/**
+ * Return the total number of bytes required to store T as ARC4 bytes.
+ *
+ * T must represent a type with a fixed length encoding scheme.
+ * @typeParam T Any native or arc4 type with a fixed encoding size.
+ */
+export declare function arc4EncodedLength<T>(): uint64;

package/arc4/index.mjs

@@ -1,5 +1,3 @@
-export { d as ARC4Encoded, I as Address, F as Bool, u as Byte, h as Contract, H as DynamicArray, K as DynamicBytes, O as OnCompleteAction, G as StaticArray, L as StaticBytes, S as Str, J as Struct, T as Tuple, E as UFixedNxM, t as UintN, z as UintN128, w as UintN16, D as UintN256, x as UintN32, y as UintN64, v as UintN8, j as abimethod, r as baremethod, P as decodeArc4, Q as encodeArc4, M as interpretAsArc4, s as methodSelector } from '../index-ki5AN0aM.js';
-import '../op-Mj11EGRt.js';
-import 'node:buffer';
-import 'node:util';
+export { A as ARC4Encoded, t as Address, r as Bool, h as Byte, C as Contract, D as DynamicArray, v as DynamicBytes, s as StaticArray, w as StaticBytes, S as Str, u as Struct, T as Tuple, q as UFixedNxM, U as UintN, o as UintN128, k as UintN16, p as UintN256, l as UintN32, n as UintN64, j as UintN8, y as abiCall, a as abimethod, g as arc4EncodedLength, b as baremethod, x as compileArc4, e as decodeArc4, f as encodeArc4, d as interpretAsArc4, m as methodSelector } from '../index-C_qZ2M7-.js';
+import '../errors-D124-zqo.js';
 //# sourceMappingURL=index.mjs.map

package/arc4/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/base-contract.d.ts

@@ -1,14 +1,19 @@
-import { Contract } from './arc4';
+import { ConstructorFor } from './internal/typescript-helpers';
 import { uint64 } from './primitives';
-import { ConstructorFor } from './typescript-helpers';
+import { NumberRange } from './util';
+/**
+ * The base type for all Algorand TypeScript contracts
+ */
 export declare abstract class BaseContract {
+    /**
+     * The program to be run when the On Completion Action is != ClearState (3)
+     */
     abstract approvalProgram(): boolean | uint64;
+    /**
+     * The program to be run when the On Completion Action is == ClearState (3)
+     */
     clearStateProgram(): boolean | uint64;
 }
-type NumberRange = {
-    from: number;
-    to: number;
-};
 /**
  * Options class to manually define the total amount of global and local state contract will use.
  *
@@ -17,13 +22,16 @@ type NumberRange = {
  * to reserve additional state storage for future contract updates, since the Algorand protocol
  * doesn't allow increasing them after creation.
  */
-type StateTotals = {
+export type StateTotals = {
     globalUints?: number;
     globalBytes?: number;
     localUints?: number;
     localBytes?: number;
 };
-type ContractOptions = {
+/**
+ * Additional configuration options for a contract
+ */
+export type ContractOptions = {
     /**
      * Determines which AVM version to use, this affects what operations are supported.
      * Defaults to value provided supplied on command line (which defaults to current mainnet version)
@@ -66,6 +74,4 @@ type ContractOptions = {
  * The contract decorator can be used to specify additional configuration options for a smart contract
  * @param options An object containing the configuration options
  */
-export declare const ContractOptionsSymbol: unique symbol;
-export declare function contract(options: ContractOptions): <T extends ConstructorFor<Contract>>(contract: T, ctx: ClassDecoratorContext) => T;
-export {};
+export declare function contract(options: ContractOptions): <T extends ConstructorFor<BaseContract>>(contract: T, ctx: ClassDecoratorContext) => never;