@typesol/cli 0.16.0 → 0.18.0

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,16 +24,42 @@ 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;
     protected readonly helper: Helper | undefined;
     protected readonly scope: TypeScope;
     protected readonly checker: ts.TypeChecker;
+    protected readonly analysis: Analysis;
+    /** Calls already resolved to a helper (a generic one's instance is found by probing its arguments). */
+    private readonly calleeCache;
     /** `file.ts:line` of the statement being lowered. */
     protected where: string | undefined;
     protected readonly profile: boolean;
     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;
     /** `file.ts:line` of a node, for messages. */
     protected location(node: ts.Node): string;
@@ -52,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;
@@ -68,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;
@@ -81,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,4 +1,6 @@
 import ts from "typescript";
+import { calleeName, resolveScalarType, structNameOf } from "../analyze.js";
+import { isScalar, } from "../model.js";
 import { isStable, cString, valueC } from "./shared.js";
 /**
  * State of one function being lowered, and the primitives every layer uses: emitting lines, temporaries,
@@ -21,12 +23,19 @@ 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;
     helper;
     scope;
     checker;
+    analysis;
+    /** Calls already resolved to a helper (a generic one's instance is found by probing its arguments). */
+    calleeCache = new Map();
     /** `file.ts:line` of the statement being lowered. */
     where;
     profile;
@@ -36,13 +45,21 @@ export class EmitterBase {
         this.model = analysis.model;
         // Each function resolves `typesol` names through its own file's imports.
         this.imports = target.imports;
-        this.scope = { imports: target.imports, enums: analysis.model.enums, options: analysis.model.options, dataEnums: analysis.model.dataEnums };
+        this.scope = {
+            imports: target.imports,
+            enums: analysis.model.enums,
+            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;
         if ("accounts" in target) {
             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)
@@ -66,6 +83,102 @@ export class EmitterBase {
             }
         }
     }
+    /** The helper a call runs: a function, a const arrow function (top-level or local), or a generic one's instance. */
+    helperOf(node) {
+        if (!ts.isIdentifier(node.expression))
+            return undefined;
+        const cached = this.calleeCache.get(node);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        const callee = node.expression;
+        // 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, 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.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()) {
+                const arg = node.arguments[i];
+                if (!arg || !p.type || !ts.isTypeReferenceNode(p.type) || !ts.isIdentifier(p.type.typeName) || p.type.typeName.text !== tp || p.type.typeArguments)
+                    continue;
+                // Type the argument without emitting it: it is lowered again, once, by the call.
+                const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
+                const probe = this.reporter.guard(() => this.expr(arg));
+                this.lines.length = saved.lines;
+                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, enum or struct, not ${probe.type.kind}`);
+                const t = probe.type;
+                return t.kind === "pubkey" ? (t.hash ? { kind: "pubkey", hash: true } : { kind: "pubkey" }) : t;
+            }
+            return this.fail(node, `cannot tell what ${tp} is from literal arguments; ${usage}`);
+        });
+    }
     line(s) {
         // Runtime failures name the TypeScript line they come from: "TypeSOL: arithmetic overflow (vault.ts:42)".
         if (this.where)
@@ -136,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--) {
@@ -159,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);
@@ -176,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.d.ts

@@ -0,0 +1,13 @@
+import type { FieldType, ProgramModel, StructDef } from "../model.js";
+/**
+ * Accounts declared `@layout borsh` are stored as Anchor stores them (Borsh: a String or Vec takes 4 + its length, an
+ * empty Option one byte, and the fields after them move). An instruction unpacks such an account into the usual
+ * fixed-layout struct on the heap (`ts_unpack_<S>`, checking it as Borsh deserialization would), runs on that, and
+ * packs it back when it returns (`ts_pack_<S>`), so every language feature works on it unchanged.
+ */
+/** A field type whose Borsh bytes are its fixed-layout bytes: scalars, Pubkeys, unit enums, arrays and structs of them. */
+export declare function borshIdentical(t: FieldType, model: Pick<ProgramModel, "structs">): boolean;
+/** The fewest bytes a Borsh `S` can take (every String and Vec empty, every Option None). */
+export declare function borshMinSize(s: StructDef, model: Pick<ProgramModel, "structs">): number;
+/** C for `ts_unpack_<S>` and `ts_pack_<S>` of every `@layout borsh` struct. */
+export declare function emitBorshCodecs(model: ProgramModel): string[];

package/dist/compiler/emit/borsh.js

@@ -0,0 +1,298 @@
+/**
+ * Accounts declared `@layout borsh` are stored as Anchor stores them (Borsh: a String or Vec takes 4 + its length, an
+ * empty Option one byte, and the fields after them move). An instruction unpacks such an account into the usual
+ * fixed-layout struct on the heap (`ts_unpack_<S>`, checking it as Borsh deserialization would), runs on that, and
+ * packs it back when it returns (`ts_pack_<S>`), so every language feature works on it unchanged.
+ */
+/** A field type whose Borsh bytes are its fixed-layout bytes: scalars, Pubkeys, unit enums, arrays and structs of them. */
+export function borshIdentical(t, model) {
+    switch (t.kind) {
+        case "int":
+        case "bool":
+        case "pubkey":
+        case "enum":
+            return true;
+        case "array":
+            return borshIdentical(t.elem, model);
+        case "struct": {
+            const s = model.structs.get(t.name);
+            return !!s && s.layout !== "borsh" && s.fields.every((f) => borshIdentical(f.type, model));
+        }
+        default:
+            return false;
+    }
+}
+/** Bytes of a Borsh-identical type. */
+function fixedBytes(t, model) {
+    switch (t.kind) {
+        case "int":
+            return Number(t.name.slice(1)) / 8;
+        case "bool":
+        case "enum":
+            return 1;
+        case "pubkey":
+            return 32;
+        case "array":
+            return fixedBytes(t.elem, model) * t.len;
+        case "struct":
+            return model.structs.get(t.name).size;
+        default:
+            throw new Error(`unreachable: ${t.kind} has no fixed Borsh size`);
+    }
+}
+/** The fewest bytes a Borsh `S` can take (every String and Vec empty, every Option None). */
+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" || t.kind === "string")
+            n += 4;
+        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: 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) {
+    const out = [];
+    for (const s of model.structs.values()) {
+        if (s.layout !== "borsh" || s.size === undefined)
+            continue;
+        let k = 0;
+        const tmp = (p) => `${p}${k++}`;
+        // Bools and enum tags inside a Borsh-identical value: invalid ones fail, as Borsh deserialization does.
+        const validate = (t, lv, pad) => {
+            switch (t.kind) {
+                case "bool":
+                    return [`${pad}if (${lv} > 1) ${DESER};`];
+                case "enum":
+                    return [`${pad}if (${lv} >= ${model.enums.get(t.name).variants.length}) ${DESER};`];
+                case "array": {
+                    const i = tmp("i");
+                    const inner = validate(t.elem, `${lv}[${i}]`, `${pad}  `);
+                    return inner.length ? [`${pad}for (uint64_t ${i} = 0; ${i} < ${t.len}; ${i}++) {`, ...inner, `${pad}}`] : [];
+                }
+                case "struct":
+                    return model.structs.get(t.name).fields.flatMap((f) => validate(f.type, `${lv}.${f.name}`, pad));
+                default:
+                    return [];
+            }
+        };
+        // 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" || 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};`;
+        // A String / Vec / Option field, `rest` bytes of later fields still to come.
+        const unpackVar = (t, lv, rest, pad) => {
+            switch (t.kind) {
+                case "fstring": {
+                    const l = tmp("n");
+                    // Strings were checked as UTF-8 when they came in (arguments) and are only stored whole: not checked again.
+                    return [
+                        `${pad}uint32_t ${l} = (uint32_t)ts_read_le(src + at, 4);`,
+                        `${pad}at += 4;`,
+                        `${pad}if (${l} > ${t.cap}) ${DESER};`,
+                        need(l, rest, pad),
+                        `${pad}${lv}.len = ${l};`,
+                        `${pad}ts_memcpy(${lv}.bytes, src + at, ${l});`,
+                        `${pad}at += ${l};`,
+                    ];
+                }
+                case "vec": {
+                    const l = tmp("n");
+                    const head = [
+                        `${pad}uint32_t ${l} = (uint32_t)ts_read_le(src + at, 4);`,
+                        `${pad}at += 4;`,
+                        `${pad}if (${l} > ${t.cap}) ${DESER};`,
+                        `${pad}${lv}.len = ${l};`,
+                    ];
+                    if (borshIdentical(t.elem, model)) {
+                        const n = fixedBytes(t.elem, model);
+                        const i = tmp("i");
+                        const check = validate(t.elem, `${lv}.items[${i}]`, `${pad}  `);
+                        return [
+                            ...head,
+                            need(`(uint64_t)${l} * ${n}`, rest, pad),
+                            `${pad}ts_memcpy(${lv}.items, src + at, (uint64_t)${l} * ${n});`,
+                            `${pad}at += (uint64_t)${l} * ${n};`,
+                            ...(check.length ? [`${pad}for (uint64_t ${i} = 0; ${i} < ${l}; ${i}++) {`, ...check, `${pad}}`] : []),
+                        ];
+                    }
+                    // Strings: each element's length prefix is checked as it is reached.
+                    const i = tmp("i");
+                    return [
+                        ...head,
+                        `${pad}for (uint64_t ${i} = 0; ${i} < ${l}; ${i}++) {`,
+                        need("4", rest, `${pad}  `),
+                        ...unpackVar(t.elem, `${lv}.items[${i}]`, rest, `${pad}  `),
+                        `${pad}}`,
+                    ];
+                }
+                case "option": {
+                    const tag = tmp("tag");
+                    const n = fixedBytes(t.inner, model);
+                    return [
+                        `${pad}uint8_t ${tag} = src[at++];`,
+                        `${pad}if (${tag} > 1) ${DESER};`,
+                        `${pad}${lv}.some = ${tag};`,
+                        `${pad}if (${tag}) {`,
+                        need(String(n), rest, `${pad}  `),
+                        `${pad}  ts_memcpy(&${lv}.v, src + at, ${n});`,
+                        `${pad}  at += ${n};`,
+                        ...validate(t.inner, `${lv}.v`, `${pad}  `),
+                        `${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`);
+            }
+        };
+        const packVar = (t, lv, rest, pad) => {
+            switch (t.kind) {
+                case "fstring": {
+                    const l = tmp("n");
+                    return [
+                        `${pad}uint32_t ${l} = ${lv}.len > ${t.cap} ? ${t.cap} : ${lv}.len;`,
+                        room(`4 + (uint64_t)${l}`, rest, pad),
+                        `${pad}ts_write_le(dst + at, ${l}, 4);`,
+                        `${pad}ts_memcpy(dst + at + 4, ${lv}.bytes, ${l});`,
+                        `${pad}at += 4 + (uint64_t)${l};`,
+                    ];
+                }
+                case "vec": {
+                    const l = tmp("n");
+                    if (borshIdentical(t.elem, model)) {
+                        const n = fixedBytes(t.elem, model);
+                        return [
+                            `${pad}uint32_t ${l} = ${lv}.len > ${t.cap} ? ${t.cap} : ${lv}.len;`,
+                            room(`4 + (uint64_t)${l} * ${n}`, rest, pad),
+                            `${pad}ts_write_le(dst + at, ${l}, 4);`,
+                            `${pad}ts_memcpy(dst + at + 4, ${lv}.items, (uint64_t)${l} * ${n});`,
+                            `${pad}at += 4 + (uint64_t)${l} * ${n};`,
+                        ];
+                    }
+                    const i = tmp("i");
+                    return [
+                        `${pad}uint32_t ${l} = ${lv}.len > ${t.cap} ? ${t.cap} : ${lv}.len;`,
+                        room("4", rest, pad),
+                        `${pad}ts_write_le(dst + at, ${l}, 4);`,
+                        `${pad}at += 4;`,
+                        `${pad}for (uint64_t ${i} = 0; ${i} < ${l}; ${i}++) {`,
+                        ...packVar(t.elem, `${lv}.items[${i}]`, rest, `${pad}  `),
+                        `${pad}}`,
+                    ];
+                }
+                case "option": {
+                    const n = fixedBytes(t.inner, model);
+                    return [
+                        room(`(uint64_t)(${lv}.some ? ${1 + n} : 1)`, rest, pad),
+                        `${pad}dst[at++] = ${lv}.some ? 1 : 0;`,
+                        `${pad}if (${lv}.some) {`,
+                        `${pad}  ts_memcpy(dst + at, &${lv}.v, ${n});`,
+                        `${pad}  at += ${n};`,
+                        `${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`);
+            }
+        };
+        // Runs of Borsh-identical fields are contiguous in both layouts: one copy each.
+        const unpackLines = [];
+        const packLines = [];
+        for (let i = 0; i < s.fields.length;) {
+            const f = s.fields[i];
+            if (borshIdentical(f.type, model)) {
+                let j = i;
+                let bytes = 0;
+                while (j < s.fields.length && borshIdentical(s.fields[j].type, model))
+                    bytes += fixedBytes(s.fields[j++].type, model);
+                unpackLines.push(`  ts_memcpy(&out->${f.name}, src + at, ${bytes});`, `  at += ${bytes};`);
+                for (const g of s.fields.slice(i, j))
+                    unpackLines.push(...validate(g.type, `out->${g.name}`, "  "));
+                // A pack can be short of room only after a String / Vec / Option grew; the start always fits (cap >= MIN).
+                packLines.push(...(i > 0 ? [room(String(bytes), minAfter[j - 1], "  ")] : []), `  ts_memcpy(dst + at, &in->${f.name}, ${bytes});`, `  at += ${bytes};`);
+                i = j;
+                continue;
+            }
+            unpackLines.push(...unpackVar(f.type, `out->${f.name}`, minAfter[i], "  "));
+            packLines.push(...packVar(f.type, `in->${f.name}`, minAfter[i], "  "));
+            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, 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;