@typesol/cli 0.17.0 → 0.19.0

package/dist/compiler/emit/calls.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
-import { resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType } from "../analyze.js";
+import { ANCHOR_ERRORS } from "../anchor-errors.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, INT_NAMES, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
 import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, } from "./shared.js";
@@ -7,6 +8,8 @@ import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
  */
+/** List methods taking a callback (or a value) that expand into a loop. */
+const LIST_METHODS = new Set(["forEach", "some", "every", "find", "findIndex", "reduce", "includes", "indexOf"]);
 export class CallEmitter extends ExpressionEmitter {
     call(node, topLevel) {
         const callee = node.expression;
@@ -126,14 +129,26 @@ export class CallEmitter extends ExpressionEmitter {
             }
             case "mulDiv":
             case "mulDivCeil": {
-                // a * b / c with a 128-bit intermediate (u64), rounding down or up; aborts if the result does not fit.
+                // a * b / c with a double-width intermediate (128-bit for u64, 256-bit for u128), rounding down or up;
+                // aborts if the result does not fit. All three are u64, or all u128 (literals take the others' type).
                 if (args.length !== 3)
-                    this.fail(node, `${builtin}(a, b, c) takes three u64 values`);
-                const [x, y, z] = this.lowerInOrder(args, [U64, U64, U64]);
+                    this.fail(node, `${builtin}(a, b, c) takes three u64 or three u128 values`);
+                const vals = [];
+                for (const a of args) {
+                    const mark = this.lines.length;
+                    const v = this.expr(a);
+                    for (let j = 0; j < vals.length; j++)
+                        vals[j] = this.settle(vals[j], mark);
+                    vals.push(v);
+                }
+                const typed = vals.find((v) => v.literal === undefined);
+                const wide = typed?.type.kind === "int" && typed.type.name === "u128";
+                const ty = wide ? { kind: "int", name: "u128" } : U64;
+                const [x, y, z] = vals.map((v, i) => this.expect(v.literal !== undefined ? this.literal(v.literal, ty, args[i]) : v, ty, args[i]));
                 const t = this.tmp("md");
-                this.line(`uint64_t ${t};`);
-                this.line(`TS_TRY(ts_mul_div(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
-                return { c: t, type: U64 };
+                this.line(`${wide ? "unsigned __int128" : "uint64_t"} ${t};`);
+                this.line(`TS_TRY(ts_mul_div${wide ? "_u128" : ""}(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
+                return { c: t, type: ty };
             }
             case "isqrt": {
                 if (args.length !== 1)
@@ -219,7 +234,18 @@ export class CallEmitter extends ExpressionEmitter {
                 this.line(`TS_TRY(ts_t22_transfer_fee(${m}, ${amt.c}, &${t}));`);
                 return { c: t, type: U64 };
             }
+            case "isTransferring": {
+                // TransferHookAccount (15) on a Token-2022 token account: set only while Token-2022 runs a transfer of it.
+                if (args.length !== 1)
+                    this.fail(node, "isTransferring(tokenAccount) takes the source token account");
+                const m = this.anyAccount(args[0], "the token account");
+                this.line(`TS_TRY(ts_t22_layout(${m}, 2));`);
+                const off = this.tmp("eo");
+                this.line(`uint64_t ${off}, ${off}l;`);
+                return { c: `(ts_t22_ext(${m}, 15, &${off}, &${off}l) && ${off}l >= 1 && ${m}->data[${off}] != 0)`, type: BOOL };
+            }
             case "transferHookProgram":
+            case "transferHookAuthority":
             case "permanentDelegate":
             case "mintCloseAuthority": {
                 // Token-2022 mint extensions holding an optional Pubkey: TransferHook (14, program at +32),
@@ -228,7 +254,7 @@ export class CallEmitter extends ExpressionEmitter {
                     this.fail(node, `${builtin}(mint) takes the mint`);
                 const m = this.anyAccount(args[0], "the mint");
                 this.line(`TS_TRY(ts_t22_layout(${m}, 1));`);
-                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
+                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "transferHookAuthority" ? [14, 0] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
                 this.model.options.set("pubkey", PUBKEY);
                 const t = this.tmp("ext");
                 this.line(`${optC(PUBKEY)} ${t};`);
@@ -434,11 +460,22 @@ export class CallEmitter extends ExpressionEmitter {
         }
         if (builtin)
             this.fail(callee, `${builtin} cannot be called here`);
+        if (ts.isIdentifier(callee)) {
+            const local = this.lookup(callee.text);
+            if (local?.closure)
+                return this.expandClosure(local.closure, node.arguments, node);
+        }
         const helper = this.helperOf(node);
         if (helper)
             return this.callHelper(node, helper);
         if (ts.isPropertyAccessExpression(callee)) {
             const method = callee.name.text;
+            // xs.some(…) and friends on a Vec, FixedArray, FixedVec or Vec argument: a loop with the callback expanded in it.
+            if (LIST_METHODS.has(method)) {
+                const l = ts.isIdentifier(callee.expression) ? this.lookup(callee.expression.text) : undefined;
+                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(callee.expression))
+                    return this.listMethod(node, method);
+            }
             // Vec<T> instruction arguments are read-only views.
             if (ts.isIdentifier(callee.expression)) {
                 const l = this.lookup(callee.expression.text);
@@ -446,6 +483,10 @@ export class CallEmitter extends ExpressionEmitter {
                     if (method !== "get" || args.length !== 1)
                         this.fail(node, "Vec arguments are read-only: use .get(i) and .length");
                     const elem = l.type.elem;
+                    if (elem.kind === "string") {
+                        const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
+                        return { c: `(((const TS_Str *)${l.c}.ptr)[${idx}])`, type: STRING };
+                    }
                     if (!isScalar(elem))
                         this.fail(node, `read a field of the element: ${callee.expression.text}.get(i).field`);
                     const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
@@ -506,8 +547,10 @@ export class CallEmitter extends ExpressionEmitter {
                 // Program accounts used through their methods (systemProgram.transfer, tokenProgram.*…) may be optional.
                 if (target?.optional)
                     this.assertUsable(target, callee.expression);
-                if (target?.kind.kind === "token" && target.kind.init && method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
-                    return this.createAta(node, target, topLevel);
+                if ((target?.kind.kind === "token" || target?.kind.kind === "mint") &&
+                    target.kind.init &&
+                    method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
+                    return target.kind.kind === "token" && target.constraints.ata ? this.createAta(node, target, topLevel) : this.createToken(node, target, topLevel);
                 if (target?.kind.kind === "init" && method === "create")
                     return this.create(node, target, topLevel);
                 if (target?.kind.kind === "initIfNeeded" && method === "createIfNeeded")
@@ -574,7 +617,7 @@ export class CallEmitter extends ExpressionEmitter {
             if (info.cap !== undefined)
                 return; // a FixedVec has its room already
             if (!info.resizable || !v.account)
-                this.fail(node, "only Vecs of declared Mut<...> / Init<...> accounts can grow or shrink");
+                this.fail(node, "only Vecs of Mut<...> / Init<...> accounts can grow or shrink");
             this.line(`TS_TRY(ts_resize(params, ${payer}, a_${v.account.name}, 8 + ${info.fixed} + (${newLen}) * ${info.elemSize}, entry_${v.account.name}));`);
         };
         switch (method) {
@@ -899,8 +942,37 @@ export class CallEmitter extends ExpressionEmitter {
         }
         return { c: `((TSS_${s.name} *)(${h}->data + 8))`, type: { kind: "structRef", struct: s.name, writable: mut } };
     }
+    /** Whether a helper (or one it calls) grows a Vec, which needs the instruction's SystemProgram for rent. */
+    helperGrows(body, seen = new Set()) {
+        if (seen.has(body))
+            return false;
+        seen.add(body);
+        let found = false;
+        const visit = (n) => {
+            if (found)
+                return;
+            if (ts.isCallExpression(n)) {
+                // Vec.push(value, payer) grows the account; FixedVec.push(value) does not.
+                if (ts.isPropertyAccessExpression(n.expression) && n.expression.name.text === "push" && n.arguments.length === 2)
+                    found = true;
+                else if (ts.isIdentifier(n.expression)) {
+                    const name = calleeName(n.expression, this.model.helperDecls, this.checker);
+                    const callee = name ? (this.model.generics.get(name)?.node ?? this.model.helpers.get(name)?.node) : undefined;
+                    if (callee && this.helperGrows(callee, seen))
+                        found = true;
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(body);
+        return found;
+    }
     callHelper(node, h) {
-        if (node.arguments.length !== h.params.length)
+        if (this.ix && !this.ix.accounts.some((a) => a.kind.kind === "system" && !a.optional) && h.params.some((p) => p.account) && this.helperGrows(h.node))
+            this.fail(node, `${h.display}() grows a Vec (push): the instruction needs a SystemProgram parameter to top up rent`);
+        // Function arguments were bound when the helper was instantiated: they have no C parameter.
+        const argNodes = h.fnArgIndexes ? node.arguments.filter((_, i) => !h.fnArgIndexes.includes(i)) : node.arguments;
+        if (argNodes.length !== h.params.length)
             this.fail(node, `${h.display}() takes ${h.params.length} argument(s)`);
         // Arguments are evaluated left to right: settle earlier ones when a later one runs statements.
         // A helper that takes accounts may change account data, so account text it gets is copied first.
@@ -908,7 +980,7 @@ export class CallEmitter extends ExpressionEmitter {
         const values = [];
         const pieces = [];
         h.params.forEach((p, i) => {
-            const n = node.arguments[i];
+            const n = argNodes[i];
             const mark = this.lines.length;
             const raw = this.helperArg(h, p, n);
             for (let j = 0; j < values.length; j++)
@@ -922,8 +994,8 @@ export class CallEmitter extends ExpressionEmitter {
         });
         // A helper that takes a writable struct account may replace anything stored in it (see assertNotAliased).
         for (const [i, p] of h.params.entries())
-            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(node.arguments[i]))
-                this.assertNotAliased([node.arguments[i].text], node, h.display);
+            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(argNodes[i]))
+                this.assertNotAliased([argNodes[i].text], node, h.display);
         const args = ["params", ...pieces.map((x) => (typeof x === "number" ? (values[x].type.kind === "pubkey" ? `*(${values[x].c})` : values[x].c) : x))];
         if (!h.returns) {
             this.line(`TS_TRY(fn_${h.name}(${args.join(", ")}));`);
@@ -937,6 +1009,11 @@ export class CallEmitter extends ExpressionEmitter {
             this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
             return { c: `(&${t})`, type: { kind: "structRef", struct: h.returns.name, writable: true } };
         }
+        if (h.returns.kind === "string") {
+            this.line(`TS_Str ${t};`);
+            this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
+            return { c: t, type: STRING };
+        }
         this.line(`${scalarC(h.returns)} ${t};`);
         this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
         return h.returns.kind === "pubkey" ? { c: `(&${t})`, type: h.returns } : { c: t, type: h.returns };
@@ -951,6 +1028,8 @@ export class CallEmitter extends ExpressionEmitter {
             // A @layout borsh account goes with the struct it is being worked on as.
             if (p.account.kind === "account" && p.account.struct.layout === "borsh")
                 return `a_${acct.name}, d_${acct.name}`;
+            if (p.account.kind === "account" && p.account.mut && p.account.struct.vec)
+                return `a_${acct.name}, entry_${acct.name}`;
             return `a_${acct.name}`;
         }
         switch (p.type.kind) {
@@ -1013,6 +1092,13 @@ export class CallEmitter extends ExpressionEmitter {
         this.fail(n, "pass signer([...seeds with the bump]) or a SignerSeeds parameter");
     }
     errorRef(node) {
+        // `AnchorError.X`: one of Anchor's own codes (not one of this program's errors, so not in the IDL).
+        if (ts.isPropertyAccessExpression(node) && this.exportName(node.expression) === "AnchorError") {
+            const code = ANCHOR_ERRORS[node.name.text];
+            if (code === undefined)
+                this.fail(node.name, `AnchorError has no ${node.name.text}`);
+            return { code, name: node.name.text, msg: node.name.text };
+        }
         if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
             const def = this.model.errorEnums.get(node.expression.text)?.get(node.name.text);
             if (def)

package/dist/compiler/emit/cpi.d.ts

@@ -26,6 +26,26 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected describeSeed(el: ts.Expression): IdlSeed | undefined;
     protected recordPda(account: AccountParam, idl: IdlSeed[] | undefined): void;
     protected create(node: ts.CallExpression, target: AccountParam, topLevel: boolean, ifNeeded?: boolean): Value;
+    /**
+     * `vault.create(payer, seeds | null, mint, authority)` on `Init<TokenAccount>` and `mint.create(payer, seeds | null,
+     * decimals, authority, freezeAuthority | null)` on `Init<Mint>` (Anchor's `init` with `token::` / `mint::`
+     * constraints): a PDA of this program (or, with `null`, a new keypair account that signs), created owned by the
+     * instruction's token program and initialized. `createIfNeeded` on `InitIfNeeded<…>` does that unless the account
+     * exists, and then checks it is that PDA, owned by the token program, and has that mint and owner / those
+     * authorities and decimals (Anchor's init_if_needed checks). create returns the bump (0 for a keypair),
+     * createIfNeeded whether it created the account.
+     */
+    protected createToken(node: ts.CallExpression, target: AccountParam, topLevel: boolean): Value;
+    /**
+     * The extensions in `mint.create(…, { … })` (Anchor's `extensions::…` constraints): their values are evaluated now,
+     * in source order; the returned lines (each extension's Token-2022 initializer, mint writable, before
+     * InitializeMint2) run after the account is created, sized for exactly these extensions.
+     */
+    protected mintExtensions(lit: ts.ObjectLiteralExpression, tp: string, acct: string, ifNeeded?: boolean): {
+        space: number;
+        lines: string[];
+        checks: string[];
+    };
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`
      * (Anchor's `init` / `init_if_needed` with `associated_token::…`). create always calls the ATA program's Create, which
@@ -47,6 +67,7 @@ export declare abstract class CpiEmitter extends CallEmitter {
     }, tail?: {
         from: string;
         to: string;
+        asPassed?: boolean;
     }): void;
     protected signerSeeds(node: ts.Expression | undefined, authority: AccountParam, at: ts.Node): {
         name: string;
@@ -87,6 +108,12 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected bubblegumOp(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
     /** Bubblegum V2 (trees on mpl-account-compression with mpl-noop; optional Metaplex Core collections). */
     protected bubblegumV2(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
+    /** Object literal properties by name, refusing others. */
+    protected literalProps(o: ts.ObjectLiteralExpression, allowed: string[], what: string): Map<string, ts.Expression>;
+    /** Vec<Creator> (address, verified, share) from a literal list; shares add up to 100 when literal. */
+    protected bubblegumCreators(creators: ts.Expression | undefined): MplField[];
+    /** UpdateArgs: every field optional (left out or null: unchanged). */
+    protected bubblegumUpdateArgs(n: ts.Expression): MplField[];
     /** `acct.key` of an account parameter, as an expression to serialize. */
     protected keyOf(n: ts.Expression): ts.Expression;
     /**
@@ -117,6 +144,10 @@ export declare abstract class CpiEmitter extends CallEmitter {
         authority: string;
         program: string;
     }): undefined;
+    /** emit<T> of a @layout borsh struct: built like account data, then packed as Anchor serializes it. */
+    private emitBorshEvent;
+    /** Discriminator + `body`, logged (emit) or self-invoked (emitCpi). */
+    private sendEvent;
     /** Structs reachable through the fields of struct `name` (not including itself unless it recurses). */
     protected nestedStructs(name: string): Set<string>;
     /** Structs whose IDL description is the fixed layout: account data, arguments, and everything nested in them. */