@algorandfoundation/algorand-typescript 1.0.0 → 1.0.1

package/arc-28.d.ts

@@ -7,8 +7,8 @@ import { DeliberateAny } from './internal/typescript-helpers';
  * @param event An ARC4Struct instance, or a plain object with a named type
  *
  * @example
- * class Demo extends Struct<{ a: UintN64 }> {}
- * emit(new Demo({ a: new UintN64(123) }))
+ * class Demo extends Struct<{ a: Uint64 }> {}
+ * emit(new Demo({ a: new Uint64(123) }))
  *
  * @example
  * type Demo = { a: uint64 }
@@ -25,7 +25,7 @@ export declare function emit<TEvent extends Record<string, DeliberateAny>>(event
  * @param eventProps A set of event properties (order is significant)
  *
  * @example
- * emit("Demo", new UintN64(123))
+ * emit("Demo", new Uint64(123))
  *
  * @example
  * const a: uint64 = 123

package/arc4/c2c.d.ts

@@ -1,8 +1,7 @@
 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 { gtxn } from '../gtxn';
+import { AnyFunction, ConstructorFor, InstanceMethod } from '../internal/typescript-helpers';
+import { itxn } from '../itxn';
 import { Contract } from './index';
 /**
  * Defines txn fields that are available for a bare create application call.
@@ -11,7 +10,7 @@ import { Contract } from './index';
  *  - 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'>;
+export type BareCreateApplicationCallFields = Omit<itxn.ApplicationCallFields, 'appId' | 'appArgs'>;
 /**
  * Conditional type which given a group transaction type, returns the equivalent inner transaction
  * params type.
@@ -27,24 +26,24 @@ export type TypedApplicationArg<TArg> = TArg extends gtxn.Transaction ? GtxnToIt
 /**
  * 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;
+export type TypedApplicationArgs<TArgs> = TArgs extends never ? unknown[] : TArgs extends [] ? [] : TArgs extends [infer TArg, ...infer TRest] ? readonly [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>;
+export type TypedApplicationCallFields<TArgs> = Omit<itxn.ApplicationCallFields, 'appArgs'> & (TArgs extends [] ? {
+    readonly args?: TypedApplicationArgs<TArgs>;
 } : {
-    args: TypedApplicationArgs<TArgs>;
+    readonly 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;
+    readonly itxn: itxn.ApplicationCallInnerTxn;
 } : {
-    itxn: ApplicationCallInnerTxn;
-    returnValue: TReturn;
+    readonly itxn: itxn.ApplicationCallInnerTxn;
+    readonly returnValue: TReturn;
 };
 /**
  * Conditional type which maps an ABI method to a factory method for constructing an application call transaction to call that method.
@@ -65,7 +64,7 @@ export type ContractProxy<TContract extends Contract> = CompiledContract & {
      * 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;
+    bareCreate(fields?: BareCreateApplicationCallFields): itxn.ApplicationCallInnerTxn;
 };
 /**
  * Pre compile the target ARC4 contract and return a proxy object for constructing inner transactions to call an instance of that contract.
@@ -73,9 +72,13 @@ export type ContractProxy<TContract extends Contract> = CompiledContract & {
  * @param options Compile contract arguments
  */
 export declare function compileArc4<TContract extends Contract>(contract: ConstructorFor<TContract>, options?: CompileContractOptions): ContractProxy<TContract>;
+export interface AbiCallOptions<TMethod> extends Omit<itxn.ApplicationCallFields, 'appArgs'> {
+    readonly method?: TMethod;
+    readonly args?: TMethod extends InstanceMethod<Contract, infer TParams> ? TypedApplicationArgs<TParams> : unknown[];
+}
+export type AbiCallResponse<TMethod> = TMethod extends InstanceMethod<Contract, infer TParams, infer TResult> ? TypedApplicationCallResponse<TResult> : TypedApplicationCallResponse<unknown>;
 /**
  * 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.
+ * @param options Specify options for the abi call.
  */
-export declare function abiCall<TArgs extends DeliberateAny[], TReturn>(method: InstanceMethod<Contract, TArgs, TReturn>, fields: TypedApplicationCallFields<TArgs>): TypedApplicationCallResponse<TReturn>;
+export declare function abiCall<TMethod>(options: AbiCallOptions<TMethod>): AbiCallResponse<TMethod>;

package/arc4/encoded-types.d.ts

@@ -9,13 +9,9 @@ type UintBitSize = 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64;
  */
 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
+ * Defines supported bit sizes for the UintN and UFixed 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
  */
@@ -28,7 +24,15 @@ declare const TypeProperty: unique symbol;
  * A base type for ARC4 encoded values
  */
 export declare abstract class ARC4Encoded implements BytesBacked {
-    /** @hidden */
+    /**
+     * @hidden
+     *
+     * Since TypeScript is structurally typed, different ARC4Encodeds with compatible
+     * structures will often be assignable to one and another and this is generally
+     * not desirable. The TypeProperty property should be used to declare a literal value
+     * (usually the class name) on each distinct ARC4Encoded class to ensure they are
+     * structurally different.
+     */
     abstract [TypeProperty]?: string;
     /**
      * Retrieve the encoded bytes for this type
@@ -54,76 +58,76 @@ export declare class Str extends ARC4Encoded {
 /**
  * A fixed bit size unsigned int
  */
-export declare class UintN<N extends BitSize> extends ARC4Encoded {
+export declare class Uint<N extends BitSize> extends ARC4Encoded {
     /** @hidden */
-    [TypeProperty]?: `arc4.UintN<${N}>`;
+    [TypeProperty]?: `arc4.Uint<${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
+     * Retrieve the decoded native uint64
      */
-    get native(): NativeForArc4Int<N>;
+    asUint64(): uint64;
+    /**
+     * Retrieve the decoded native biguint
+     */
+    asBigUint(): biguint;
 }
 /**
- * An alias for UintN<8>
+ * An alias for Uint<8>
  */
-export declare class Byte extends UintN<8> {
+export declare class Byte extends Uint<8> {
 }
 /**
- * An alias for UintN<8>
+ * An alias for Uint<8>
  */
-export declare class UintN8 extends UintN<8> {
+export declare class Uint8 extends Uint<8> {
 }
 /**
- * An alias for UintN<16>
+ * An alias for Uint<16>
  */
-export declare class UintN16 extends UintN<16> {
+export declare class Uint16 extends Uint<16> {
 }
 /**
- * An alias for UintN<32>
+ * An alias for Uint<32>
  */
-export declare class UintN32 extends UintN<32> {
+export declare class Uint32 extends Uint<32> {
 }
 /**
- * An alias for UintN<64>
+ * An alias for Uint<64>
  */
-export declare class UintN64 extends UintN<64> {
+export declare class Uint64 extends Uint<64> {
 }
 /**
- * An alias for UintN<128>
+ * An alias for Uint<128>
  */
-export declare class UintN128 extends UintN<128> {
+export declare class Uint128 extends Uint<128> {
 }
 /**
- * An alias for UintN<256>
+ * An alias for Uint<256>
  */
-export declare class UintN256 extends UintN<256> {
+export declare class Uint256 extends Uint<256> {
 }
 /**
  * A fixed bit size, fixed decimal unsigned value
  */
-export declare class UFixedNxM<N extends BitSize, M extends number> extends ARC4Encoded {
+export declare class UFixed<N extends BitSize, M extends number> extends ARC4Encoded {
     /** @hidden */
-    [TypeProperty]?: `arc4.UFixedNxM<${N}x${M}>`;
+    [TypeProperty]?: `arc4.UFixed<${N}x${M}>`;
     /**
-     * Create a new UFixedNxM value
+     * Create a new UFixed 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>;
+    constructor(v?: `${number}.${number}`);
 }
 /**
  * A boolean value
  */
 export declare class Bool extends ARC4Encoded {
     /** @hidden */
-    [TypeProperty]?: `arc4.Bool`;
+    [TypeProperty]?: 'arc4.Bool';
     /**
      * Create a new Bool value
      * @param v The native boolean to initialize this value from
@@ -137,7 +141,7 @@ export declare class Bool extends ARC4Encoded {
 /**
  * A base type for arc4 array types
  */
-declare abstract class Arc4ArrayBase<TItem extends ARC4Encoded> extends ARC4Encoded {
+declare abstract class Arc4ArrayBase<TItem extends ARC4Encoded> extends ARC4Encoded implements ConcatArray<TItem> {
     protected constructor();
     /**
      * Returns the current length of this array
@@ -149,6 +153,30 @@ declare abstract class Arc4ArrayBase<TItem extends ARC4Encoded> extends ARC4Enco
      * @param index The index of the item to retrieve
      */
     at(index: Uint64Compat): TItem;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new Dynamic array with all items from this array
+     */
+    slice(): Array<TItem>;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new DynamicArray with all items up till `end`.
+     * Negative indexes are taken from the end.
+     * @param end An index in which to stop copying items.
+     */
+    slice(end: Uint64Compat): Array<TItem>;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new DynamicArray with items from `start`, up until `end`
+     * Negative indexes are taken from the end.
+     * @param start An index in which to start copying items.
+     * @param end An index in which to stop copying items
+     */
+    slice(start: Uint64Compat, end: Uint64Compat): Array<TItem>;
+    /**
+     * Creates a string by concatenating all the items in the array delimited by the
+     * specified separator (or ',' by default)
+     * @param separator
+     * @deprecated Join is not supported in Algorand TypeScript
+     */
+    join(separator?: string): string;
     /**
      * Returns an iterator for the items in this array
      */
@@ -186,15 +214,15 @@ export declare class StaticArray<TItem extends ARC4Encoded, TLength extends numb
     constructor(...items: TItem[] & {
         length: TLength;
     });
-    /**
-     * 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>;
+    /**
+     * Returns the statically declared length of this array
+     */
+    get length(): uint64;
 }
 /**
  * A dynamic sized array of arc4 items
@@ -217,10 +245,6 @@ export declare class DynamicArray<TItem extends ARC4Encoded> extends Arc4ArrayBa
      * 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
@@ -230,14 +254,18 @@ export declare class DynamicArray<TItem extends ARC4Encoded> extends Arc4ArrayBa
 /**
  * @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>}` : '';
+type ExpandTupleType<T extends readonly 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 {
+export declare class Tuple<const TTuple extends readonly [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
@@ -262,7 +290,7 @@ export declare class Tuple<TTuple extends [ARC4Encoded, ...ARC4Encoded[]]> exten
  */
 export declare class Address extends Arc4ArrayBase<Byte> {
     /** @hidden */
-    [TypeProperty]?: `arc4.Address`;
+    [TypeProperty]?: 'arc4.Address';
     /**
      * Create a new Address instance
      * @param value An Account, base 32 address string, or the address bytes
@@ -278,12 +306,8 @@ export declare class Address extends Arc4ArrayBase<Byte> {
  */
 declare class StructBase<T> extends ARC4Encoded {
     /** @hidden */
-    [TypeProperty]: string;
+    [TypeProperty]?: 'arc4.Struct';
     get native(): T;
-    /**
-     * Returns a deep copy of this struct
-     */
-    copy(): this;
 }
 /**
  * Type alias for the Struct constructor function
@@ -297,7 +321,7 @@ type StructConstructor = {
  *
  * Usage:
  * ```
- * class MyStruct extends Struct<{ x: UintN8, y: Str, z: DynamicBytes }> {}
+ * class MyStruct extends Struct<{ x: Uint8, y: Str, z: DynamicBytes }> { }
  * ```
  */
 export declare const Struct: StructConstructor;
@@ -306,7 +330,7 @@ export declare const Struct: StructConstructor;
  */
 export declare class DynamicBytes extends Arc4ArrayBase<Byte> {
     /** @hidden */
-    [TypeProperty]?: `arc4.DynamicBytes`;
+    [TypeProperty]?: 'arc4.DynamicBytes';
     /**
      * Create a new DynamicBytes instance
      * @param value The bytes or utf8 interpreted string to initialize this type
@@ -325,22 +349,40 @@ export declare class DynamicBytes extends Arc4ArrayBase<Byte> {
 /**
  * A fixed length sequence of bytes
  */
-export declare class StaticBytes<TLength extends number = 0> extends Arc4ArrayBase<Byte> {
+export declare class StaticBytes<TLength extends uint64 = 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
+     * Create a new StaticBytes instance from native fixed sized bytes
+     * @param value The bytes
      */
-    constructor(value?: bytes | string);
+    constructor(value: bytes<TLength>);
+    /**
+     * Create a new StaticBytes instance from native bytes
+     * @param value The bytes
+     */
+    constructor(value: bytes);
+    /**
+     * Create a new StaticBytes instance from a utf8 string
+     * @param value A string
+     */
+    constructor(value: string);
+    /**
+     * Create a new StaticBytes instance of length 0
+     */
+    constructor();
     /**
      * Get the native bytes value
      */
-    get native(): bytes;
+    get native(): bytes<TLength>;
     /**
      * 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;
+    /**
+     * Returns the statically declared length of this byte array
+     */
+    get length(): uint64;
 }
 export {};

package/arc4/index.d.ts

@@ -1,10 +1,10 @@
 import { BaseContract } from '../base-contract';
-import { DeliberateAny, InstanceMethod } from '../internal/typescript-helpers';
+import { AnyFunction, 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';
+export * from './encoded-types';
 /**
  * The base type for all ARC4 contracts in Algorand TypeScript
  */
@@ -15,6 +15,35 @@ export declare class Contract extends BaseContract {
      */
     approvalProgram(): boolean;
 }
+/**
+ * Defines conventional routing method names. When used, methods with these names will be implicitly routed to the corresponding
+ * application lifecycle event.
+ *
+ * @remarks This behaviour is independent of a contract explicitly implementing this interface. The interface is provided simply to improve
+ * the developer experience of using this feature.
+ */
+export interface ConventionalRouting {
+    /**
+     * The function to invoke when closing out of this application
+     */
+    closeOutOfApplication?: AnyFunction;
+    /**
+     * The function to invoke when creating this application
+     */
+    createApplication?: AnyFunction;
+    /**
+     * The function to invoke when deleting this application
+     */
+    deleteApplication?: AnyFunction;
+    /**
+     * The function to invoke when opting in to this application
+     */
+    optInToApplication?: AnyFunction;
+    /**
+     * The function to invoke when updating this application
+     */
+    updateApplication?: AnyFunction;
+}
 /**
  * The possible options for a method being available on application create
  *
@@ -23,6 +52,19 @@ export declare class Contract extends BaseContract {
  * require: This method CAN ONLY be called when the application is being created
  */
 export type CreateOptions = 'allow' | 'disallow' | 'require';
+/**
+ * The possible options for the resource encoding to use for the method
+ *
+ * index: Application, Asset, and Account arguments are included in the transaction's relevant array. The argument value is the uint8 index of the resource in the that array.
+ * value: Application, Asset and Account arguments are passed by their uint64 id (Application and Asset) or bytes[32] address (Account).
+ */
+export type ResourceEncodingOptions = 'index' | 'value';
+/**
+ * The possible options for validation behaviour for this method
+ * args: ABI arguments are validated automatically to ensure they are encoded correctly.
+ * unsafe-disabled: No automatic validation occurs. Arguments can instead be validated manually.
+ */
+export type ValidateEncodingOptions = 'unsafe-disabled' | 'args';
 /**
  * Type alias for a default argument schema
  * @typeParam TContract The type of the contract containing the method this default argument is for
@@ -66,6 +108,23 @@ export type AbiMethodConfig<TContract extends Contract> = {
      * Override the name used to generate the abi method selector
      */
     name?: string;
+    /**
+     * The resource encoding to use for this method. The default is 'value'
+     *
+     * index: Application, Asset, and Account arguments are included in the transaction's relevant array. The argument value is the uint8 index of the resource in the that array.
+     * value: Application, Asset and Account arguments are passed by their uint64 id (Application and Asset) or bytes[32] address (Account).
+     *
+     * The resource must still be 'available' to this transaction but can take advantage of resource sharing within the transaction group.
+     */
+    resourceEncoding?: ResourceEncodingOptions;
+    /**
+     * Controls validation behaviour for this method.
+     *
+     * If "args", then ABI arguments are validated automatically to ensure they are encoded correctly.
+     * If "unsafe-disabled", then no automatic validation occurs. Arguments can instead be validated using the validateEncoding(...) function.
+     * The default behaviour of this option can be controlled with the --validate-abi-args CLI flag.
+     */
+    validateEncoding?: ValidateEncodingOptions;
     /**
      * Specify default arguments that can be populated by clients calling this method.
      *
@@ -79,6 +138,13 @@ export type AbiMethodConfig<TContract extends Contract> = {
  * @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;
+/**
+ * Declares this abi method does not mutate chain state and can be called using a simulate call to the same effect.
+ *
+ * Shorthand for `@abimethod({readonly: true})`
+ * @typeParam TContract the type of the contract this method is a part of
+ */
+export declare function readonly<TContract extends Contract, TArgs extends DeliberateAny[], TReturn>(target: (this: TContract, ...args: TArgs) => TReturn, ctx: ClassMethodDecoratorContext<TContract>): (this: TContract, ...args: TArgs) => TReturn;
 /**
  * Configuration options for a bare method
  */
@@ -106,20 +172,27 @@ export declare function baremethod<TContract extends Contract>(config?: BareMeth
  * @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;
+export declare function methodSelector(methodSignature: InstanceMethod<Contract>): bytes<4>;
 /**
  * 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;
+export declare function methodSelector(methodSignature: string): bytes<4>;
 /**
- * Interpret the provided bytes as an ARC4 encoded type with no validation
+ * Interpret the provided bytes as an ARC4 encoded type
  * @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
+ * @param options Options for how the bytes should be converted
+ * @param options.prefix The prefix (if any), present in the bytes value. This prefix will be validated and removed
+ * @param options.strategy The strategy used for converting bytes.
+ *         `unsafe-cast`: Reinterpret the value as an ARC4 encoded type without validation
+ *         `validate`: Asserts the encoding of the raw bytes matches the expected type
  */
-export declare function interpretAsArc4<T extends ARC4Encoded>(bytes: BytesCompat, prefix?: 'none' | 'log'): T;
+export declare function convertBytes<T extends ARC4Encoded>(bytes: BytesCompat, options: {
+    prefix?: 'none' | 'log';
+    strategy: 'unsafe-cast' | 'validate';
+}): T;
 /**
  * Decode the provided bytes to a native Algorand TypeScript value
  * @param bytes An arc4 encoded bytes value
@@ -130,11 +203,11 @@ export declare function decodeArc4<T>(bytes: BytesCompat, prefix?: 'none' | 'log
  * 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 declare function encodeArc4<const T>(value: T): bytes;
 /**
- * Return the total number of bytes required to store T as ARC4 bytes.
+ * Return the total number of bytes required to store T as 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;
+export declare function sizeOf<T>(): uint64;

package/arc4/index.mjs

@@ -1,3 +1,3 @@
-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-rjo2X8sp.js';
-import '../errors-D124-zqo.js';
+export { A as ARC4Encoded, w as Address, u as Bool, j as Byte, C as Contract, D as DynamicArray, y as DynamicBytes, v as StaticArray, z as StaticBytes, S as Str, x as Struct, T as Tuple, t as UFixed, U as Uint, p as Uint128, l as Uint16, q as Uint256, n as Uint32, o as Uint64, k as Uint8, h as abiCall, a as abimethod, b as baremethod, g as compileArc4, d as convertBytes, e as decodeArc4, f as encodeArc4, m as methodSelector, r as readonly, s as sizeOf } from '../index-C_DRi4sH.js';
+import '../errors-Bg4n2Chz.js';
 //# sourceMappingURL=index.mjs.map

package/arrays.d.ts

@@ -0,0 +1,75 @@
+import { uint64, Uint64Compat } from './primitives';
+/**
+ * A fixed sized array
+ * @typeParam TItem The type of a single item in the array
+ * @typeParam TLength The fixed length of the array
+ */
+export declare class FixedArray<TItem, TLength extends number> implements ConcatArray<TItem> {
+    /**
+     * Create a new FixedArray instance
+     */
+    constructor();
+    /**
+     * Create a new FixedArray instance with the specified items
+     * @param items The initial items for the array
+     */
+    constructor(...items: TItem[] & {
+        length: TLength;
+    });
+    /**
+     * Returns a new array containing all items from _this_ array, and _other_ array
+     * @param items Another array to concat with this one
+     */
+    concat(...items: (TItem | ConcatArray<TItem>)[]): TItem[];
+    /**
+     * Returns the statically declared length of this array
+     */
+    get length(): uint64;
+    /**
+     * Returns the item at the given index.
+     * Negative indexes are taken from the end.
+     * @param index The index of the item to retrieve
+     */
+    at(index: Uint64Compat): TItem;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new Dynamic array with all items from this array
+     */
+    slice(): Array<TItem>;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new DynamicArray with all items up till `end`.
+     * Negative indexes are taken from the end.
+     * @param end An index in which to stop copying items.
+     */
+    slice(end: Uint64Compat): Array<TItem>;
+    /** @deprecated Array slicing is not yet supported in Algorand TypeScript
+     * Create a new DynamicArray with items from `start`, up until `end`
+     * Negative indexes are taken from the end.
+     * @param start An index in which to start copying items.
+     * @param end An index in which to stop copying items
+     */
+    slice(start: Uint64Compat, end: Uint64Compat): Array<TItem>;
+    /**
+     * Returns an iterator for the items in this array
+     */
+    [Symbol.iterator](): IterableIterator<TItem>;
+    /**
+     * Returns an iterator for a tuple of the indexes and items in this array
+     */
+    entries(): ArrayIterator<readonly [uint64, TItem]>;
+    /**
+     * Returns an iterator for the indexes in this array
+     */
+    keys(): IterableIterator<uint64>;
+    /**
+     * Get or set the item at the specified index.
+     * Negative indexes are not supported
+     */
+    [index: uint64]: TItem;
+    /**
+     * Creates a string by concatenating all the items in the array delimited by the
+     * specified separator (or ',' by default)
+     * @param separator
+     * @deprecated Join is not supported in Algorand TypeScript
+     */
+    join(separator?: string): string;
+}

package/base-contract.d.ts

@@ -34,9 +34,9 @@ export type StateTotals = {
 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)
+     * Defaults to value provided on command line (which defaults to current mainnet version)
      */
-    avmVersion?: 10 | 11;
+    avmVersion?: 10 | 11 | 12 | 13;
     /**
      * Override the name of the logic signature when generating build artifacts.
      * Defaults to the class name