@typesol/cli 0.17.0 → 0.19.0

package/dist/compiler/anchor-errors.js

@@ -0,0 +1,80 @@
+// Anchor's own error codes (anchor-lang ErrorCode), for `require(condition, AnchorError.X)`.
+export const ANCHOR_ERRORS = {
+    InstructionMissing: 100,
+    InstructionFallbackNotFound: 101,
+    InstructionDidNotDeserialize: 102,
+    InstructionDidNotSerialize: 103,
+    IdlInstructionStub: 1000,
+    IdlInstructionInvalidProgram: 1001,
+    IdlAccountNotEmpty: 1002,
+    EventInstructionStub: 1500,
+    ConstraintMut: 2000,
+    ConstraintHasOne: 2001,
+    ConstraintSigner: 2002,
+    ConstraintRaw: 2003,
+    ConstraintOwner: 2004,
+    ConstraintRentExempt: 2005,
+    ConstraintSeeds: 2006,
+    ConstraintExecutable: 2007,
+    ConstraintState: 2008,
+    ConstraintAssociated: 2009,
+    ConstraintAssociatedInit: 2010,
+    ConstraintClose: 2011,
+    ConstraintAddress: 2012,
+    ConstraintZero: 2013,
+    ConstraintTokenMint: 2014,
+    ConstraintTokenOwner: 2015,
+    ConstraintMintMintAuthority: 2016,
+    ConstraintMintFreezeAuthority: 2017,
+    ConstraintMintDecimals: 2018,
+    ConstraintSpace: 2019,
+    ConstraintAccountIsNone: 2020,
+    ConstraintTokenTokenProgram: 2021,
+    ConstraintMintTokenProgram: 2022,
+    ConstraintAssociatedTokenTokenProgram: 2023,
+    ConstraintMintGroupPointerExtension: 2024,
+    ConstraintMintGroupPointerExtensionAuthority: 2025,
+    ConstraintMintGroupPointerExtensionGroupAddress: 2026,
+    ConstraintMintGroupMemberPointerExtension: 2027,
+    ConstraintMintGroupMemberPointerExtensionAuthority: 2028,
+    ConstraintMintGroupMemberPointerExtensionMemberAddress: 2029,
+    ConstraintMintMetadataPointerExtension: 2030,
+    ConstraintMintMetadataPointerExtensionAuthority: 2031,
+    ConstraintMintMetadataPointerExtensionMetadataAddress: 2032,
+    ConstraintMintCloseAuthorityExtension: 2033,
+    ConstraintMintCloseAuthorityExtensionAuthority: 2034,
+    ConstraintMintPermanentDelegateExtension: 2035,
+    ConstraintMintPermanentDelegateExtensionDelegate: 2036,
+    ConstraintMintTransferHookExtension: 2037,
+    ConstraintMintTransferHookExtensionAuthority: 2038,
+    ConstraintMintTransferHookExtensionProgramId: 2039,
+    RequireViolated: 2500,
+    RequireEqViolated: 2501,
+    RequireKeysEqViolated: 2502,
+    RequireNeqViolated: 2503,
+    RequireKeysNeqViolated: 2504,
+    RequireGtViolated: 2505,
+    RequireGteViolated: 2506,
+    AccountDiscriminatorAlreadySet: 3000,
+    AccountDiscriminatorNotFound: 3001,
+    AccountDiscriminatorMismatch: 3002,
+    AccountDidNotDeserialize: 3003,
+    AccountDidNotSerialize: 3004,
+    AccountNotEnoughKeys: 3005,
+    AccountNotMutable: 3006,
+    AccountOwnedByWrongProgram: 3007,
+    InvalidProgramId: 3008,
+    InvalidProgramExecutable: 3009,
+    AccountNotSigner: 3010,
+    AccountNotSystemOwned: 3011,
+    AccountNotInitialized: 3012,
+    AccountNotProgramData: 3013,
+    AccountNotAssociatedTokenAccount: 3014,
+    AccountSysvarMismatch: 3015,
+    AccountReallocExceedsLimit: 3016,
+    AccountDuplicateReallocs: 3017,
+    DeclaredProgramIdMismatch: 4100,
+    TryingToInitPayerAsProgramAccount: 4101,
+    InvalidNumericConversion: 4102,
+    Deprecated: 5000,
+};

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

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { type Analysis, type TypeScope } from "../analyze.js";
 import type { Reporter } from "../diagnostics.js";
 import { type AccountParam, type Helper, type IdlSeed, type Instruction, type ProgramModel, type ValueType } from "../model.js";
-import { type Value, type Local, type EmitOptions } from "./shared.js";
+import { type Value, type Ref, type Local, type Closure, type EmitOptions } from "./shared.js";
 /**
  * State of one function being lowered, and the primitives every layer uses: emitting lines, temporaries,
  * scopes, evaluation-order snapshots and account lookups.
@@ -24,6 +24,17 @@ export declare abstract class EmitterBase {
     protected readonly pendingInit: Set<string>;
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     protected readonly bumps: Map<string, string>;
+    /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
+    protected inlineFrames: {
+        label: string;
+        result: string;
+        type?: ValueType;
+        declAt: number;
+        pad: string;
+        node: ts.Node;
+    }[];
+    /** Closures being expanded (a closure calling itself cannot be expanded). */
+    protected readonly inlining: Set<ts.Node>;
     /** Enclosing loops, innermost last; each has a `continue` label. */
     protected readonly loops: string[];
     protected readonly ix: Instruction | undefined;
@@ -39,6 +50,14 @@ export declare abstract class EmitterBase {
     constructor(analysis: Analysis, target: Instruction | Helper, opts?: EmitOptions);
     /** The helper a call runs: a function, a const arrow function (top-level or local), or a generic one's instance. */
     protected helperOf(node: ts.CallExpression): Helper | undefined;
+    /**
+     * The functions passed for a helper's function parameters: named functions only (a helper, or a local function that
+     * captures nothing). A closure can only run where it is declared, so it cannot be passed.
+     */
+    private fnArgsOf;
+    /** A struct written as a type argument (`pick<Point>(…)`). */
+    private structArg;
+    private fixedStruct;
     /** A generic call's type arguments: written out (`max<u64>(a, b)`), or the types of the arguments in `T` positions. */
     private typeArgsOf;
     protected line(s: string): void;
@@ -59,11 +78,17 @@ export declare abstract class EmitterBase {
     protected block(fn: () => void): void;
     protected fail(node: ts.Node, message: string): never;
     protected exportName(node: ts.Expression): string | undefined;
+    /**
+     * `acct!.field` on an optional account: the same access without `!` (using the account checks that it was passed,
+     * failing with 3020 otherwise). Returns undefined for anything else.
+     */
+    protected withoutBang(node: ts.Expression): ts.PropertyAccessExpression | undefined;
     protected accountParam(node: ts.Expression, what: string): AccountParam;
     protected assertUsable(a: AccountParam, node: ts.Node): void;
     protected abstract expect(v: Value, want: ValueType | undefined, node: ts.Node): Value;
     protected abstract literal(value: bigint, type: ValueType, node: ts.Node): Value;
     protected abstract expr(node: ts.Expression, hint?: ValueType): Value;
+    protected abstract ref(node: ts.Expression): Ref | undefined;
     protected abstract call(node: ts.CallExpression, topLevel: boolean): Value | undefined;
     protected abstract isRemaining(node: ts.Expression): boolean;
     protected abstract handle(node: ts.Expression): string | undefined;
@@ -75,6 +100,7 @@ export declare abstract class EmitterBase {
     protected abstract recordPda(account: AccountParam, idl: IdlSeed[] | undefined): void;
     protected abstract create(node: ts.CallExpression, target: AccountParam, topLevel: boolean, ifNeeded?: boolean): Value;
     protected abstract createAta(node: ts.CallExpression, target: AccountParam, topLevel: boolean): Value | undefined;
+    protected abstract createToken(node: ts.CallExpression, target: AccountParam, topLevel: boolean): Value;
     protected abstract systemTransfer(node: ts.CallExpression): undefined;
     protected abstract createAccount(node: ts.CallExpression, system: AccountParam): undefined;
     protected abstract tokenOp(node: ts.CallExpression, program: AccountParam, method: string): undefined;
@@ -88,4 +114,6 @@ export declare abstract class EmitterBase {
         program: string;
     }): undefined;
     protected abstract epilogue(): string[];
+    protected abstract expandClosure(c: Closure, args: readonly ts.Expression[], node: ts.Node): Value | undefined;
+    protected abstract listMethod(node: ts.CallExpression, method: string): Value | undefined;
 }

package/dist/compiler/emit/base.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { calleeName, resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType, structNameOf } from "../analyze.js";
 import { isScalar, } from "../model.js";
 import { isStable, cString, valueC } from "./shared.js";
 /**
@@ -23,6 +23,10 @@ export class EmitterBase {
     pendingInit = new Set();
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     bumps = new Map();
+    /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
+    inlineFrames = [];
+    /** Closures being expanded (a closure calling itself cannot be expanded). */
+    inlining = new Set();
     /** Enclosing loops, innermost last; each has a `continue` label. */
     loops = [];
     ix;
@@ -47,6 +51,7 @@ export class EmitterBase {
             options: analysis.model.options,
             dataEnums: analysis.model.dataEnums,
             typeArgs: "accounts" in target ? undefined : target.typeArgs,
+            structArgs: "accounts" in target ? undefined : target.structArgs,
         };
         this.checker = analysis.checker;
         this.analysis = analysis;
@@ -54,7 +59,7 @@ export class EmitterBase {
             this.ix = target;
             for (const a of target.accounts) {
                 this.accounts.set(a.name, a);
-                if (a.kind.kind === "init" || a.kind.kind === "initIfNeeded" || (a.kind.kind === "token" && a.kind.init))
+                if (a.kind.kind === "init" || a.kind.kind === "initIfNeeded" || ((a.kind.kind === "token" || a.kind.kind === "mint") && a.kind.init))
                     this.pendingInit.add(a.name);
             }
             for (const a of target.args)
@@ -86,23 +91,59 @@ export class EmitterBase {
         if (cached !== undefined)
             return cached ?? undefined;
         const callee = node.expression;
-        const name = calleeName(callee, this.model.helperDecls, this.checker) ?? (this.lookup(callee.text) ? undefined : callee.text);
+        // A function parameter of this helper instance: the function it was given.
+        const passed = this.helper?.fnArgs?.get(callee.text);
+        const name = passed ?? calleeName(callee, this.model.helperDecls, this.checker) ?? (this.lookup(callee.text) ? undefined : callee.text);
         const g = name ? this.model.generics.get(name) : undefined;
         let h = name ? this.model.helpers.get(name) : undefined;
         if (g)
-            h = this.analysis.instantiate(g, this.typeArgsOf(node, g));
+            h = this.analysis.instantiate(g, g.typeParams.length ? this.typeArgsOf(node, g) : [], this.fnArgsOf(node, g));
         else if (h && node.typeArguments)
             this.fail(node, `${h.display} takes no type arguments`);
         this.calleeCache.set(node, h ?? null);
         return h;
     }
+    /**
+     * The functions passed for a helper's function parameters: named functions only (a helper, or a local function that
+     * captures nothing). A closure can only run where it is declared, so it cannot be passed.
+     */
+    fnArgsOf(node, g) {
+        return g.fnParams.map((i) => {
+            const arg = node.arguments[i];
+            const pname = g.node.parameters[i].name.text;
+            if (!arg || !ts.isIdentifier(arg))
+                this.fail(arg ?? node, `pass ${g.display}'s ${pname} a named function (declare it: const f = (…) => …)`);
+            const passed = this.helper?.fnArgs?.get(arg.text);
+            if (passed)
+                return passed;
+            if (this.lookup(arg.text)?.closure)
+                this.fail(arg, `${arg.text} reads the variables of the function around it, so it can only be called there, not passed to ${g.display}`);
+            const name = calleeName(arg, this.model.helperDecls, this.checker) ?? arg.text;
+            if (this.model.generics.has(name))
+                this.fail(arg, `${arg.text} is generic or takes functions itself: pass a plain function`);
+            if (!this.model.helpers.has(name))
+                this.fail(arg, `${arg.text} is not a function of this program`);
+            return name;
+        });
+    }
+    /** A struct written as a type argument (`pick<Point>(…)`). */
+    structArg(t) {
+        const name = structNameOf(t, this.scope);
+        return name && this.model.structs.has(name) ? this.fixedStruct(name, t) : undefined;
+    }
+    fixedStruct(name, at) {
+        const s = this.model.structs.get(name);
+        if (s.size === undefined || s.vec)
+            this.fail(at, `${name} has variable-size fields; type parameters stand for fixed-size structs`);
+        return { kind: "struct", name };
+    }
     /** A generic call's type arguments: written out (`max<u64>(a, b)`), or the types of the arguments in `T` positions. */
     typeArgsOf(node, g) {
         const usage = `write ${g.display}<u64>(…) with the types`;
         if (node.typeArguments) {
             if (node.typeArguments.length !== g.typeParams.length)
                 this.fail(node, `${g.display} takes ${g.typeParams.length} type argument(s)`);
-            return node.typeArguments.map((t) => resolveScalarType(t, this.scope) ?? this.fail(t, "type arguments are integers, boolean, Pubkey or enums"));
+            return node.typeArguments.map((t) => resolveScalarType(t, this.scope) ?? this.structArg(t) ?? this.fail(t, "type arguments are integers, boolean, Pubkey, enums or fixed-size structs"));
         }
         return g.typeParams.map((tp) => {
             for (const [i, p] of g.node.parameters.entries()) {
@@ -116,10 +157,22 @@ export class EmitterBase {
                 this.hoisted.length = saved.hoisted;
                 this.temp = saved.temp;
                 this.reporter.diagnostics.length = saved.diagnostics;
+                if (probe?.type.kind === "structRef")
+                    return this.fixedStruct(probe.type.struct, arg);
+                if (!probe) {
+                    // A struct place (`p.a`) is not a value: type it as a reference, again without emitting anything.
+                    const r = this.reporter.guard(() => this.ref(arg));
+                    this.lines.length = saved.lines;
+                    this.hoisted.length = saved.hoisted;
+                    this.temp = saved.temp;
+                    this.reporter.diagnostics.length = saved.diagnostics;
+                    if (r?.type.kind === "struct")
+                        return this.fixedStruct(r.type.name, arg);
+                }
                 if (!probe || probe.literal !== undefined || probe.isNull)
                     continue;
                 if (!isScalar(probe.type))
-                    this.fail(arg, `${tp} stands for an integer, boolean, Pubkey or enum, not ${probe.type.kind}`);
+                    this.fail(arg, `${tp} stands for an integer, boolean, Pubkey, enum or struct, not ${probe.type.kind}`);
                 const t = probe.type;
                 return t.kind === "pubkey" ? (t.hash ? { kind: "pubkey", hash: true } : { kind: "pubkey" }) : t;
             }
@@ -196,7 +249,7 @@ export class EmitterBase {
         if ((ts.isPropertyAccessExpression(node) || ts.isCallExpression(node) || ts.isElementAccessExpression(node)) && node.questionDotToken)
             this.fail(node, "optional chaining (?.) is not supported; check `x !== null` first");
         if (ts.isNonNullExpression(node))
-            this.fail(node, "the ! assertion works on Option values only; check `x !== null` so TypeScript narrows it");
+            this.fail(node, "the ! assertion works on Option values and optional accounts only; check `x !== null` so TypeScript narrows it");
     }
     lookup(name) {
         for (let i = this.scopes.length - 1; i >= 0; i--) {
@@ -219,7 +272,25 @@ export class EmitterBase {
     exportName(node) {
         return ts.isIdentifier(node) ? this.imports.get(node.text) : undefined;
     }
+    /**
+     * `acct!.field` on an optional account: the same access without `!` (using the account checks that it was passed,
+     * failing with 3020 otherwise). Returns undefined for anything else.
+     */
+    withoutBang(node) {
+        if (!ts.isPropertyAccessExpression(node) || !ts.isNonNullExpression(node.expression))
+            return undefined;
+        const inner = node.expression.expression;
+        if (!ts.isIdentifier(inner) || !this.accounts.get(inner.text)?.optional)
+            return undefined;
+        const plain = ts.factory.createPropertyAccessExpression(inner, node.name);
+        ts.setTextRange(plain, node);
+        plain.parent = node.parent;
+        return plain;
+    }
     accountParam(node, what) {
+        // `acct!` on an optional account: the account (its use checks it was passed).
+        if (ts.isNonNullExpression(node) && ts.isIdentifier(node.expression) && this.accounts.get(node.expression.text)?.optional)
+            return this.accountParam(node.expression, what);
         if (!ts.isIdentifier(node))
             this.fail(node, `${what} must be an account parameter`);
         const a = this.accounts.get(node.text);
@@ -236,7 +307,7 @@ export class EmitterBase {
             ? "create"
             : a.kind.kind === "initIfNeeded"
                 ? "createIfNeeded"
-                : a.kind.kind === "token" && a.kind.init
+                : (a.kind.kind === "token" || a.kind.kind === "mint") && a.kind.init
                     ? a.kind.init === "create"
                         ? "create"
                         : "createIfNeeded"

package/dist/compiler/emit/borsh.js

@@ -45,16 +45,16 @@ export function borshMinSize(s, model) {
     let n = 0;
     for (const f of s.fields) {
         const t = f.type;
-        if (t.kind === "fstring" || t.kind === "vec")
+        if (t.kind === "fstring" || t.kind === "vec" || t.kind === "string")
             n += 4;
-        else if (t.kind === "option")
+        else if (t.kind === "option" || t.kind === "dataEnum")
             n += 1;
         else
             n += fixedBytes(t, model);
     }
     return n;
 }
-const DESER = `TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account data is not a valid Borsh value")`;
+const DESER = `TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: bytes are not a valid Borsh value")`;
 const SER = `TS_FAIL(TS_ERR_DID_NOT_SERIALIZE, "TypeSOL: account data too small for the value")`;
 /** C for `ts_unpack_<S>` and `ts_pack_<S>` of every `@layout borsh` struct. */
 export function emitBorshCodecs(model) {
@@ -84,7 +84,7 @@ export function emitBorshCodecs(model) {
         };
         // Bounds: the caller checked `len >= MIN` (the smallest Borsh form). Fixed-size pieces then always fit; only a
         // String / Vec / Option payload is checked, against what is left after the fields that follow it still need.
-        const minOf = (t) => (t.kind === "fstring" || t.kind === "vec" ? 4 : t.kind === "option" ? 1 : fixedBytes(t, model));
+        const minOf = (t) => t.kind === "fstring" || t.kind === "vec" || t.kind === "string" ? 4 : t.kind === "option" || t.kind === "dataEnum" ? 1 : fixedBytes(t, model);
         const minAfter = s.fields.map((_, i) => s.fields.slice(i + 1).reduce((n, f) => n + minOf(f.type), 0));
         const need = (n, rest, pad) => `${pad}if (${n} > len - at - ${rest}) ${DESER};`;
         const room = (n, rest, pad) => `${pad}if (${n} > cap - at - ${rest}) ${SER};`;
@@ -149,6 +149,43 @@ export function emitBorshCodecs(model) {
                         `${pad}}`,
                     ];
                 }
+                case "string": {
+                    // A view of the bytes it was read from (arguments only), checked as UTF-8 as Borsh String deserialization does.
+                    const l = tmp("n");
+                    return [
+                        `${pad}uint32_t ${l} = (uint32_t)ts_read_le(src + at, 4);`,
+                        `${pad}at += 4;`,
+                        need(l, rest, pad),
+                        `${pad}if (!ts_utf8_valid(src + at, ${l})) ${DESER};`,
+                        `${pad}${lv} = ts_str(src + at, ${l});`,
+                        `${pad}at += ${l};`,
+                    ];
+                }
+                case "dataEnum": {
+                    const e = model.dataEnums.get(t.name);
+                    const tag = tmp("tag");
+                    const lines = [
+                        `${pad}uint8_t ${tag} = src[at++];`,
+                        `${pad}if (${tag} >= ${e.variants.length}) ${DESER};`,
+                        `${pad}${lv}.tag = ${tag};`,
+                        `${pad}switch (${tag}) {`,
+                    ];
+                    e.variants.forEach((v, i) => {
+                        lines.push(`${pad}case ${i}: {`);
+                        for (const f of v.fields) {
+                            const flv = `${lv}.v.${v.name}.${f.name}`;
+                            if (f.type.kind === "string") {
+                                lines.push(`${pad}  if (4 > len - at - ${rest}) ${DESER};`, ...unpackVar(f.type, flv, rest, `${pad}  `));
+                                continue;
+                            }
+                            const n = fixedBytes(f.type, model);
+                            lines.push(need(String(n), rest, `${pad}  `), `${pad}  ts_memcpy(&${flv}, src + at, ${n});`, `${pad}  at += ${n};`, ...validate(f.type, flv, `${pad}  `));
+                        }
+                        lines.push(`${pad}  break;`, `${pad}}`);
+                    });
+                    lines.push(`${pad}}`);
+                    return lines;
+                }
                 default:
                     throw new Error(`unreachable: ${t.kind} in a Borsh account`);
             }
@@ -199,6 +236,35 @@ export function emitBorshCodecs(model) {
                         `${pad}}`,
                     ];
                 }
+                case "string": {
+                    const l = tmp("n");
+                    return [
+                        `${pad}uint32_t ${l} = (uint32_t)${lv}.len;`,
+                        room(`4 + (uint64_t)${l}`, rest, pad),
+                        `${pad}ts_write_le(dst + at, ${l}, 4);`,
+                        `${pad}ts_memcpy(dst + at + 4, ${lv}.ptr, ${l});`,
+                        `${pad}at += 4 + (uint64_t)${l};`,
+                    ];
+                }
+                case "dataEnum": {
+                    const e = model.dataEnums.get(t.name);
+                    const lines = [room("1", rest, pad), `${pad}dst[at++] = ${lv}.tag;`, `${pad}switch (${lv}.tag) {`];
+                    e.variants.forEach((v, i) => {
+                        lines.push(`${pad}case ${i}: {`);
+                        for (const f of v.fields) {
+                            const flv = `${lv}.v.${v.name}.${f.name}`;
+                            if (f.type.kind === "string") {
+                                lines.push(...packVar(f.type, flv, rest, `${pad}  `));
+                                continue;
+                            }
+                            const n = fixedBytes(f.type, model);
+                            lines.push(room(String(n), rest, `${pad}  `), `${pad}  ts_memcpy(dst + at, &${flv}, ${n});`, `${pad}  at += ${n};`);
+                        }
+                        lines.push(`${pad}  break;`, `${pad}}`);
+                    });
+                    lines.push(`${pad}}`);
+                    return lines;
+                }
                 default:
                     throw new Error(`unreachable: ${t.kind} in a Borsh account`);
             }
@@ -226,7 +292,7 @@ export function emitBorshCodecs(model) {
             i++;
         }
         const min = borshMinSize(s, model);
-        out.push(`/* ${s.name} as Borsh (Anchor's account layout) <-> its fixed-layout struct. */`, `__attribute__((noinline)) static uint64_t ts_unpack_${s.name}(const uint8_t *src, uint64_t len, TSS_${s.name} *out) {`, `  if (len < ${min}) ${DESER};`, `  uint64_t at = 0;`, ...unpackLines, `  return SUCCESS;`, `}`, `__attribute__((noinline)) static uint64_t ts_pack_${s.name}(const TSS_${s.name} *in, uint8_t *dst, uint64_t cap) {`, `  if (cap < ${min}) ${SER};`, `  uint64_t at = 0;`, ...packLines, `  return SUCCESS;`, `}`, "");
+        out.push(`/* ${s.name} as Borsh (Anchor's account layout) <-> its fixed-layout struct. */`, `__attribute__((noinline)) static uint64_t ts_unpack_${s.name}(const uint8_t *src, uint64_t len, TSS_${s.name} *out, uint64_t *used) {`, `  if (len < ${min}) ${DESER};`, `  uint64_t at = 0;`, ...unpackLines, `  if (used) *used = at;`, `  return SUCCESS;`, `}`, `__attribute__((noinline)) static uint64_t ts_pack_${s.name}(const TSS_${s.name} *in, uint8_t *dst, uint64_t cap, uint64_t *written) {`, `  if (cap < ${min}) ${SER};`, `  uint64_t at = 0;`, ...packLines, `  if (written) *written = at;`, `  return SUCCESS;`, `}`, "");
     }
     return out;
 }

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

@@ -2,9 +2,6 @@ import ts from "typescript";
 import { type ErrorDef, type FieldType, type Helper } from "../model.js";
 import { type Value, type Ref } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
-/**
- * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
- */
 export declare abstract class CallEmitter extends ExpressionEmitter {
     protected call(node: ts.CallExpression, topLevel: boolean): Value | undefined;
     protected vecMethod(node: ts.CallExpression, method: string, v: Ref): Value | undefined;
@@ -32,6 +29,8 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
     protected loadForeign(node: ts.CallExpression): Value;
     /** `loadAccount<T>(acct)` / `loadAccountMut<T>(acct)`: checked view of a program account. */
     protected loadAccount(node: ts.CallExpression, mut: boolean): Value;
+    /** Whether a helper (or one it calls) grows a Vec, which needs the instruction's SystemProgram for rent. */
+    private helperGrows;
     protected callHelper(node: ts.CallExpression, h: Helper): Value | undefined;
     /** One helper argument: a C argument list fragment (accounts, seeds, references) or a value to settle. */
     protected helperArg(h: Helper, p: Helper["params"][number], n: ts.Expression): Value | string;