@algorandfoundation/puya-ts 1.0.0-alpha.4

package/README.md

@@ -0,0 +1,11 @@
+# Algorand TypeScript
+
+Algorand TypeScript is a partial implementation of the TypeScript programming language that runs on the Algorand Virtual Machine (AVM). It includes a statically typed framework for development of Algorand smart contracts and logic signatures, with TypeScript interfaces to underlying AVM functionality that works with standard TypeScript tooling.
+
+It maintains the syntax and semantics of TypeScript such that a developer who knows TypeScript can make safe assumptions
+about the behaviour of the compiled code when running on the AVM. Algorand TypeScript is also executable TypeScript that can be run
+and debugged on a Node.js virtual machine with transpilation to EcmaScript and run from automated tests.
+
+Algorand TypeScript is compiled for execution on the AVM by PuyaTs, a TypeScript frontend for the [Puya](https://github.com/algorandfoundation/puya) optimising compiler that ensures the resulting AVM bytecode execution semantics that match the given TypeScript code. PuyaTs produces output that is directly compatible with AlgoKit typed clients to make deployment and calling easy.
+
+[Documentation](./docs/README.md)

package/awst/index.d.ts

@@ -0,0 +1,4 @@
+export * as awst from './nodes';
+export * as wtypes from './wtypes';
+export * from './util';
+export type ConstantValue = bigint | Uint8Array | boolean | string;

package/awst/intrinsic-factory.d.ts

@@ -0,0 +1,35 @@
+import type * as awst from './nodes';
+import type { Expression } from './nodes';
+import type { SourceLocation } from './source-location';
+export declare const intrinsicFactory: {
+    bytesConcat({ left, right, sourceLocation, }: {
+        left: awst.Expression;
+        right: awst.Expression;
+        sourceLocation: SourceLocation;
+    }): awst.IntrinsicCall;
+    err({ sourceLocation, comment }: {
+        sourceLocation: SourceLocation;
+        comment: string | null;
+    }): awst.IntrinsicCall;
+    assert({ sourceLocation, comment, condition }: {
+        sourceLocation: SourceLocation;
+        comment: string | null;
+        condition: Expression;
+    }): awst.IntrinsicCall;
+    bytesLen({ value, sourceLocation }: {
+        value: awst.Expression;
+        sourceLocation: SourceLocation;
+    }): awst.IntrinsicCall;
+    bitLen({ value, sourceLocation }: {
+        value: awst.Expression;
+        sourceLocation: SourceLocation;
+    }): awst.IntrinsicCall;
+    itob({ value, sourceLocation }: {
+        value: awst.Expression;
+        sourceLocation: SourceLocation;
+    }): awst.IntrinsicCall;
+    btoi({ value, sourceLocation }: {
+        value: awst.Expression;
+        sourceLocation: SourceLocation;
+    }): awst.IntrinsicCall;
+};

package/awst/json-serialize-awst.d.ts

@@ -0,0 +1,17 @@
+import type { RootNode } from './nodes';
+export declare class SnakeCaseSerializer<T> {
+    private readonly spaces;
+    constructor(spaces?: number);
+    serialize(obj: T): string;
+    protected serializerFunction(key: string, value: unknown): unknown;
+}
+export declare class AwstSerializer extends SnakeCaseSerializer<RootNode[]> {
+    private options?;
+    constructor(options?: {
+        sourcePaths?: "absolute" | "relative";
+        programDirectory?: string;
+    } | undefined);
+    private b85;
+    protected serializerFunction(key: string, value: unknown): unknown;
+}
+export declare function jsonSerializeAwst(awst: RootNode[]): string;

package/awst/models.d.ts

@@ -0,0 +1,85 @@
+import type { ContractClassPType } from '../awst_build/ptypes';
+import type { Props } from '../typescript-helpers';
+import type { SourceLocation } from './source-location';
+export declare enum OnCompletionAction {
+    NoOp = 0,
+    OptIn = 1,
+    CloseOut = 2,
+    ClearState = 3,
+    UpdateApplication = 4,
+    DeleteApplication = 5
+}
+export declare enum ARC4CreateOption {
+    Allow = 1,
+    Require = 2,
+    Disallow = 3
+}
+declare class ModelBase {
+    #private;
+}
+export declare class ARC4BareMethodConfig extends ModelBase {
+    readonly sourceLocation: SourceLocation | undefined;
+    readonly allowedCompletionTypes: OnCompletionAction[];
+    readonly create: ARC4CreateOption;
+    readonly isBare: true;
+    constructor(props: Omit<Props<ARC4BareMethodConfig>, 'isBare'>);
+}
+export type DefaultArgumentSource = {
+    source: 'constant';
+    value: string | bigint | number | boolean | Uint8Array;
+} | {
+    source: 'global-state';
+    memberName: string;
+} | {
+    source: 'local-state';
+    memberName: string;
+} | {
+    source: 'abi-method';
+    memberName: string;
+};
+export declare class ARC4ABIMethodConfig extends ModelBase {
+    readonly sourceLocation: SourceLocation | undefined;
+    readonly name: string;
+    readonly isBare: false;
+    readonly create: ARC4CreateOption;
+    readonly readonly: boolean;
+    readonly allowedCompletionTypes: OnCompletionAction[];
+    readonly defaultArgs: Record<string, DefaultArgumentSource>;
+    readonly structs: Record<string, ARC32StructDef>;
+    constructor(props: Omit<Props<ARC4ABIMethodConfig>, 'isBare'>);
+}
+export interface ARC32StructDef {
+    name: string;
+    elements: [...[string, string][]];
+}
+export declare class ContractReference extends ModelBase {
+    constructor({ className, moduleName }: {
+        className: string;
+        moduleName: string;
+    });
+    readonly className: string;
+    readonly moduleName: string;
+    get id(): string;
+    toString(): string;
+    static fromPType(contractPType: ContractClassPType): ContractReference;
+}
+export declare class LogicSigReference extends ModelBase {
+    constructor({ name, moduleName }: {
+        name: string;
+        moduleName: string;
+    });
+    readonly name: string;
+    readonly moduleName: string;
+    get id(): string;
+    toString(): string;
+}
+export type CompilationSet = ReadonlyArray<ContractReference | LogicSigReference>;
+export declare enum TransactionKind {
+    pay = 1,
+    keyreg = 2,
+    acfg = 3,
+    axfer = 4,
+    afrz = 5,
+    appl = 6
+}
+export {};

package/awst/node-factory.d.ts

@@ -0,0 +1,90 @@
+import type { Props } from '../typescript-helpers';
+import type { Expression, Statement } from './nodes';
+import { AssignmentExpression, AssignmentStatement, BigUIntBinaryOperation, Block, BoolConstant, BooleanBinaryOperation, BytesComparisonExpression, BytesConstant, BytesEncoding, CheckedMaybe, concreteNodes, Copy, ExpressionStatement, IntegerConstant, IntrinsicCall, MethodDocumentation, Not, NumericComparisonExpression, SingleEvaluation, StringConstant, TupleExpression, TupleItemExpression, UInt64BinaryOperation, VoidConstant } from './nodes';
+import type { SourceLocation } from './source-location';
+import type { WType } from './wtypes';
+type ConcreteNodes = typeof concreteNodes;
+declare const explicitNodeFactory: {
+    voidConstant(props: {
+        sourceLocation: SourceLocation;
+    }): VoidConstant;
+    bytesConstant(props: {
+        value: Uint8Array;
+        encoding?: BytesEncoding;
+        sourceLocation: SourceLocation;
+        wtype?: WType;
+    }): BytesConstant;
+    stringConstant(props: {
+        value: string;
+        sourceLocation: SourceLocation;
+    }): StringConstant;
+    uInt64Constant(props: {
+        value: bigint;
+        tealAlias?: string;
+        sourceLocation: SourceLocation;
+    }): IntegerConstant;
+    bigUIntConstant(props: {
+        value: bigint;
+        sourceLocation: SourceLocation;
+    }): IntegerConstant;
+    not(props: {
+        expr: Expression;
+        sourceLocation: SourceLocation;
+    }): Not;
+    uInt64BinaryOperation(props: Omit<Props<UInt64BinaryOperation>, "wtype">): UInt64BinaryOperation;
+    bigUIntBinaryOperation(props: Omit<Props<BigUIntBinaryOperation>, "wtype">): BigUIntBinaryOperation;
+    numericComparisonExpression(props: Omit<Props<NumericComparisonExpression>, "wtype">): NumericComparisonExpression;
+    bytesComparisonExpression(props: Omit<Props<BytesComparisonExpression>, "wtype">): BytesComparisonExpression;
+    boolConstant(props: {
+        value: boolean;
+        sourceLocation: SourceLocation;
+    }): BoolConstant;
+    singleEvaluation({ source }: {
+        source: Expression;
+    }): SingleEvaluation;
+    expressionStatement({ expr }: {
+        expr: Expression;
+    }): ExpressionStatement;
+    block({ sourceLocation, comment, label }: {
+        sourceLocation: SourceLocation;
+        comment?: string;
+        label?: string;
+    }, ...statements: Array<Statement | Statement[]>): Block;
+    booleanBinaryOperation(props: Omit<Props<BooleanBinaryOperation>, "wtype">): BooleanBinaryOperation;
+    assignmentExpression({ target, value, sourceLocation, }: {
+        target: AssignmentExpression["target"];
+        value: Expression;
+        sourceLocation: SourceLocation;
+    }): AssignmentExpression;
+    assignmentStatement({ target, value, sourceLocation, }: {
+        target: AssignmentStatement["target"];
+        value: Expression;
+        sourceLocation: SourceLocation;
+    }): AssignmentStatement;
+    tupleExpression(props: Omit<Props<TupleExpression>, "wtype">): TupleExpression;
+    methodDocumentation(props?: {
+        description?: string | null;
+        args?: Map<string, string>;
+        returns?: string | null;
+    }): MethodDocumentation;
+    intrinsicCall(props: Omit<Props<IntrinsicCall>, "comment"> & {
+        comment?: string | null;
+    }): IntrinsicCall;
+    copy({ value, sourceLocation }: {
+        value: Expression;
+        sourceLocation: SourceLocation;
+    }): Copy;
+    checkedMaybe({ expr, comment }: {
+        expr: Expression;
+        comment: string;
+    }): CheckedMaybe;
+    tupleItemExpression(props: Omit<Props<TupleItemExpression>, "wtype">): TupleItemExpression;
+};
+type ExplicitNodeFactory = typeof explicitNodeFactory;
+type DefaultNodeFactory<TKey extends keyof ConcreteNodes> = (...args: ConstructorParameters<ConcreteNodes[TKey]>) => InstanceType<ConcreteNodes[TKey]>;
+export type NodeFactory = {
+    [key in keyof ConcreteNodes]: FactoryMethod<key>;
+};
+type FactoryMethod<TKey extends keyof ConcreteNodes> = TKey extends keyof ExplicitNodeFactory ? ExplicitNodeFactory[TKey] : DefaultNodeFactory<TKey>;
+export declare const nodeFactory: NodeFactory;
+export {};