@typesol/cli 0.16.0 → 0.18.0

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

@@ -12,6 +12,11 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
      * check is a backstop: an empty option aborts with 5108.
      */
     protected unwrap(v: Value, node: ts.Node): Value;
+    /**
+     * `acct?.field` on an optional account, `x.home?.field` on an Option<struct> place: the field as an Option, empty
+     * when the account was left out / the option is empty. (A method call through `?.` is not supported.)
+     */
+    protected optionalChain(node: ts.PropertyAccessExpression): Value;
     protected literal(value: bigint, type: ValueType, node: ts.Node): Value;
     protected expr(node: ts.Expression, hint?: ValueType): Value;
     protected property(node: ts.PropertyAccessExpression): Value;

package/dist/compiler/emit/expressions.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
-import { INT_INFO, unsignedC, sameType, typeName } from "../model.js";
-import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cString, intLiteral, scalarStorageC, optC, valueC } from "./shared.js";
+import { calleeName, resolveValueType } from "../analyze.js";
+import { INT_INFO, unsignedC, optionKey, sameType, typeName } from "../model.js";
+import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cString, intLiteral, scalarStorageC, optC, valueC, vecCount } from "./shared.js";
 import { StorageEmitter } from "./storage.js";
 /**
  * Expressions: literals, operators with checked arithmetic, property reads, conditionals, text and casts.
@@ -51,6 +52,52 @@ export class ExpressionEmitter extends StorageEmitter {
             return { c: `(${t}.v != 0)`, type: inner };
         return { c: `${t}.v`, type: inner };
     }
+    /**
+     * `acct?.field` on an optional account, `x.home?.field` on an Option<struct> place: the field as an Option, empty
+     * when the account was left out / the option is empty. (A method call through `?.` is not supported.)
+     */
+    optionalChain(node) {
+        const base = node.expression;
+        const optAccount = ts.isIdentifier(base) ? this.accounts.get(base.text) : undefined;
+        let present;
+        if (optAccount?.optional)
+            present = `a_${optAccount.name} != NULL`;
+        else {
+            const r = this.ref(base);
+            if (!r || r.type.kind !== "option" || r.type.inner.kind !== "struct")
+                this.fail(node, "?. works on optional accounts and Option<struct> values (other values are never null)");
+            present = `${r.lv}.some`;
+        }
+        // The same access without `?.`, lowered where the base is known to be there.
+        const f = ts.factory;
+        const plain = f.createPropertyAccessExpression(base, node.name);
+        ts.setTextRange(plain, node);
+        plain.parent = node.parent;
+        const t = this.tmp("oc");
+        const declAt = this.lines.length;
+        this.line(`/* ${t} */`);
+        let inner;
+        this.line(`if (${present}) {`);
+        this.block(() => {
+            const v = this.expr(plain);
+            const typed = v.literal !== undefined ? this.literal(v.literal, U64, node) : v;
+            if (typed.type.kind === "option") {
+                inner = typed.type.inner;
+                this.line(`ts_memcpy(&${t}, &${typed.c}, sizeof(${t}));`);
+                return;
+            }
+            if (typed.type.kind !== "int" && typed.type.kind !== "bool" && typed.type.kind !== "pubkey" && typed.type.kind !== "enum")
+                this.fail(node, `?. gives an Option, so the field must be an integer, boolean, Pubkey or enum, not ${typeName(typed.type)}`);
+            inner = typed.type;
+            this.line(`${t}.some = 1;`);
+            this.line(inner.kind === "pubkey" ? `${t}.v = *(${typed.c});` : `${t}.v = ${typed.c};`);
+        });
+        this.line(`}`);
+        const scalar = inner;
+        this.model.options.set(optionKey(scalar), scalar);
+        this.lines[declAt] = `${"  ".repeat(this.indent)}${optC(scalar)} ${t};\n${"  ".repeat(this.indent)}ts_memzero(&${t}, sizeof(${t}));`;
+        return { c: t, type: { kind: "option", inner: scalar } };
+    }
     literal(value, type, node) {
         if (type.kind !== "int")
             this.fail(node, `expected ${typeName(type)}, got an integer literal`);
@@ -62,6 +109,20 @@ export class ExpressionEmitter extends StorageEmitter {
     expr(node, hint) {
         if (ts.isParenthesizedExpression(node))
             return this.expr(node.expression, hint);
+        // `x as T`: an annotation the value must already match (no conversion: use u8(x) etc. for that). Inside a
+        // generic helper it names the instance's type: `return (a + b) as T`.
+        if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+            if (ts.isAsExpression(node) && ts.isTypeReferenceNode(node.type) && ts.isIdentifier(node.type.typeName) && node.type.typeName.text === "const")
+                return this.expr(node.expression, hint);
+            const t = resolveValueType(node.type, this.scope);
+            if (!t || t.kind === "vecArg" || t.kind === "dataEnumArg")
+                this.fail(node.type, "`as` names an integer, boolean, Pubkey, enum, option or string type the value already has");
+            const v = this.expr(node.expression, t);
+            // Not a conversion: `x as u64 | null` does not make an Option of a u64.
+            if (v.literal === undefined && !v.isNull && !sameType(v.type, t))
+                this.fail(node, `this is a ${typeName(v.type)}, not a ${typeName(t)}: \`as\` does not convert (use u64(x) and the like for integers)`);
+            return this.expect(v, t, node.expression);
+        }
         // `x!` on an Option: its value, aborting with 5108 when it is empty (JS would carry the null on).
         if (ts.isNonNullExpression(node)) {
             const v = this.expr(node.expression, hint && hint.kind !== "option" ? { kind: "option", inner: hint } : hint);
@@ -69,6 +130,11 @@ export class ExpressionEmitter extends StorageEmitter {
                 this.fail(node, "! works on Option values; check optional accounts with `x !== null`");
             return this.unwrap(v, node);
         }
+        if (ts.isPropertyAccessExpression(node) && node.questionDotToken)
+            return this.optionalChain(node);
+        const unbanged = this.withoutBang(node);
+        if (unbanged)
+            return this.expr(unbanged, hint);
         this.noOptionalChain(node);
         if (ts.isBigIntLiteral(node)) {
             const value = BigInt(node.text.slice(0, -1).replace(/_/g, ""));
@@ -111,6 +177,8 @@ export class ExpressionEmitter extends StorageEmitter {
         if (ts.isIdentifier(node)) {
             const l = this.lookup(node.text);
             if (l) {
+                if (l.closure)
+                    this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
                 if (l.type.kind === "array")
                     this.fail(node, `"${node.text}" is an array; use .get(i)`);
                 if (l.type.kind === "remaining")
@@ -140,6 +208,8 @@ export class ExpressionEmitter extends StorageEmitter {
             }
             if (this.accounts.has(node.text))
                 this.fail(node, `"${node.text}" is an account; use ${node.text}.key for its address`);
+            if (calleeName(node, this.model.helperDecls, this.checker) || this.model.helpers.has(node.text))
+                this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
             this.fail(node, `unknown name "${node.text}"`);
         }
         if (ts.isPropertyAccessExpression(node))
@@ -202,7 +272,7 @@ export class ExpressionEmitter extends StorageEmitter {
             if (arr?.type.kind === "array")
                 return { c: `${arr.type.len}ULL`, type: U64 };
             if (arr?.type.kind === "vec")
-                return { c: `((uint64_t)${arr.vec.len})`, type: U64 };
+                return { c: vecCount(arr.vec), type: U64 };
             if (ts.isIdentifier(node.expression)) {
                 const l = this.lookup(node.expression.text);
                 if (l?.type.kind === "vecArg")
@@ -231,8 +301,11 @@ export class ExpressionEmitter extends StorageEmitter {
         if (ts.isIdentifier(node.expression)) {
             const a = this.accounts.get(node.expression.text);
             if (a) {
-                this.assertUsable(a, node);
                 const v = `a_${a.name}`;
+                // The address is known before an Init account is created (Anchor seeds use `mint.key()` that way).
+                if (field === "key" && !a.optional)
+                    return { c: `&${v}->key`, type: PUBKEY };
+                this.assertUsable(a, node);
                 if (field === "key")
                     return { c: `&${v}->key`, type: PUBKEY };
                 if (field === "lamports")
@@ -387,7 +460,14 @@ export class ExpressionEmitter extends StorageEmitter {
             this.line(this.textOfInt(typed.type.name, typed.c, t));
             return t;
         }
-        this.fail(node, `only strings, integers and booleans can be joined into text, not ${typeName(typed.type)}`);
+        if (typed.type.kind === "pubkey") {
+            // A Pubkey (or Hash) as base58, as Rust's `{}` prints it.
+            const t = this.tmp("b58");
+            this.line(`TS_Str ${t};`);
+            this.line(`TS_TRY(ts_base58_32((const uint8_t *)(${typed.c}), &${t}));`);
+            return t;
+        }
+        this.fail(node, `only strings, integers, booleans and Pubkeys can be joined into text, not ${typeName(typed.type)}`);
     }
     /** C statement writing the decimal text of an integer into the TS_Str `out`. */
     textOfInt(name, c, out) {

package/dist/compiler/emit/function.js

@@ -1,7 +1,8 @@
 import ts from "typescript";
 import { snakeCase } from "../analyze.js";
 import { decodeAddress } from "../../keys.js";
-import { INT_INFO, isScalar, isWritable, scalarSize, typeName } from "../model.js";
+import { INT_INFO, isScalar, isWritable, scalarSize, typeName, } from "../model.js";
+import { borshIdentical, borshMinSize } from "./borsh.js";
 import { MAX_ACCOUNTS, ATA_PROGRAM_BYTES, cBytes, cString, optC, fieldC, storageDecl, helperSignature } from "./shared.js";
 import { StatementEmitter } from "./statements.js";
 /**
@@ -14,12 +15,12 @@ export class FunctionEmitter extends StatementEmitter {
         this.scopes = [new Map()];
         this.line(`(void)params;`);
         for (const p of h.params)
-            if (p.account && p.account.kind === "account")
+            if (p.account && p.account.kind === "account" && p.account.struct.layout !== "borsh")
                 this.line(`TSS_${p.account.struct.name} *d_${p.name} = (TSS_${p.account.struct.name} *)(a_${p.name}->data + 8);`);
-        for (const stmt of h.node.body.statements)
+        for (const stmt of h.statements)
             this.reporter.guard(() => this.statement(stmt));
         // A helper with a result must return one; falling off the end would leave it unset.
-        const end = h.returns ? `  TS_FAIL(TS_ERR_NO_RETURN, "TypeSOL: ${h.name} ended without returning a value");` : `  return SUCCESS;`;
+        const end = h.returns ? `  TS_FAIL(TS_ERR_NO_RETURN, "TypeSOL: ${h.display} ended without returning a value");` : `  return SUCCESS;`;
         return [`${helperSignature(h)} {`, ...this.hoisted, ...this.lines, end, `}`].join("\n");
     }
     emitInstruction() {
@@ -39,13 +40,17 @@ export class FunctionEmitter extends StatementEmitter {
                 head.push(`  TS_TRY(ts_check_signer(${v}));`);
             if (isWritable(k))
                 head.push(`  TS_TRY(ts_check_writable(${v}));`);
+            // A @layout borsh account only has to hold its smallest Borsh form (unpacking checks the rest).
             if (k.kind === "account")
-                head.push(`  TS_TRY(ts_check_program_account(${v}, params->program_id, TS_DISC_${k.struct.name}, sizeof(TSS_${k.struct.name})));`);
+                head.push(`  TS_TRY(ts_check_program_account(${v}, params->program_id, TS_DISC_${k.struct.name}, ${k.struct.layout === "borsh" ? borshMinSize(k.struct, this.model) : `sizeof(TSS_${k.struct.name})`}));`);
             // A token account created by this instruction is checked where it is created (create/createIfNeeded).
             if (k.kind === "token" && !k.init)
                 head.push(`  TS_TRY(ts_check_token_account(${v}));`);
-            if (k.kind === "mint")
+            // A mint created by this instruction is checked where it is created.
+            if (k.kind === "mint" && !k.init)
                 head.push(`  TS_TRY(ts_check_mint(${v}));`);
+            if (k.kind === "info" && k.systemOwned)
+                head.push(`  if (!ts_key_eq(&${v}->owner, &TS_SYSTEM_PROGRAM_ID)) TS_FAIL(TS_ERR_NOT_SYSTEM_OWNED, "TypeSOL: ${a.name} must be owned by the System Program");`);
             if (k.kind === "system")
                 head.push(`  TS_TRY(ts_check_address(${v}, &TS_SYSTEM_PROGRAM_ID));`);
             if (k.kind === "instructionsSysvar")
@@ -87,7 +92,16 @@ export class FunctionEmitter extends StatementEmitter {
                 head.push(`  TS_TRY(ts_init_zeroed(${v}, params->program_id, TS_DISC_${k.struct.name}, sizeof(TSS_${k.struct.name})));`);
             if (k.kind === "initIfNeeded" && k.struct.vec)
                 this.reporter.fail(a.node, "InitIfNeeded accounts cannot end in a Vec yet");
-            if (k.kind === "account" || k.kind === "init" || k.kind === "zeroed" || k.kind === "initIfNeeded") {
+            if ((k.kind === "account" || k.kind === "init" || k.kind === "initIfNeeded") && k.struct.layout === "borsh") {
+                // Worked on as its fixed-layout struct on the heap, packed back when the instruction returns. The heap is zero at
+                // entry and these are its first allocations (before the body uses it), so a string's padding and a list's
+                // unused slots start as zero: ts_unpack_* only writes what the Borsh bytes hold.
+                const S = k.struct.name;
+                head.push(`  TSS_${S} *d_${a.name} = NULL;`, `  TS_TRY(ts_alloc(sizeof(TSS_${S}), (uint8_t **)&d_${a.name}));`);
+                if (k.kind === "account")
+                    head.push(`  TS_TRY(ts_unpack_${S}(${v}->data + 8, ${v}->data_len - 8, d_${a.name}, NULL));`);
+            }
+            else if (k.kind === "account" || k.kind === "init" || k.kind === "zeroed" || k.kind === "initIfNeeded") {
                 head.push(`  TSS_${k.struct.name} *d_${a.name} = (TSS_${k.struct.name} *)(${v}->data + 8);`);
                 if (k.struct.vec) {
                     head.push(`  uint64_t entry_${a.name} = ${v}->data_len;`, `  (void)entry_${a.name};`);
@@ -189,6 +203,17 @@ export class FunctionEmitter extends StatementEmitter {
                 }
                 head.push(`  }`);
             }
+            else if (a.type.kind === "vecArg" && a.type.elem.kind === "string") {
+                // Borsh Vec<String>: u32 count, then each string's u32 length and UTF-8 bytes. Kept as views of the
+                // instruction data in a heap array of TS_Str (each string at least 4 bytes, so the count is bounded first).
+                const v = `arg_${a.name}`;
+                const items = `vs_${a.name}`;
+                const i = `vi_${a.name}`;
+                need("4");
+                head.push(`  TS_VecArg ${v};`, `  ${v}.len = (uint32_t)ts_read_le(${at}, 4);`, `  off += 4;`);
+                need(`(uint64_t)${v}.len * 4`);
+                head.push(`  TS_Str *${items};`, `  TS_TRY(ts_alloc((uint64_t)${v}.len * sizeof(TS_Str), (uint8_t **)&${items}));`, `  for (uint64_t ${i} = 0; ${i} < ${v}.len; ${i}++) {`, `    if (params->data_len < off + 4) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`, `    uint32_t n = (uint32_t)ts_read_le(params->data + off, 4);`, `    off += 4;`, `    if (params->data_len - off < n) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`, `    if (!ts_utf8_valid(params->data + off, n)) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: invalid UTF-8 in a string argument");`, `    ${items}[${i}] = ts_str(params->data + off, n);`, `    off += n;`, `  }`, `  ${v}.ptr = (const uint8_t *)${items};`);
+            }
             else if (a.type.kind === "vecArg") {
                 const elem = a.type.elem;
                 const size = this.fieldBytes(elem);
@@ -204,6 +229,21 @@ export class FunctionEmitter extends StatementEmitter {
                         head.push(`  for (uint64_t ${i} = 0; ${i} < arg_${a.name}.len; ${i}++) {`, ...checks, `  }`);
                 }
             }
+            else if (a.type.kind === "structRef" && this.model.structs.get(a.type.struct).layout === "borsh") {
+                // A @layout borsh struct: Borsh-decoded into its fixed-layout struct, as its accounts are.
+                const S = a.type.struct;
+                const v = `arg_${a.name}`;
+                const used = `used_${a.name}`;
+                head.push(`  TSS_${S} *${v};`, `  TS_TRY(ts_alloc(sizeof(TSS_${S}), (uint8_t **)&${v}));`, `  uint64_t ${used} = 0;`, `  if (ts_unpack_${S}(${at}, params->data_len - off, ${v}, &${used}) != SUCCESS) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: invalid ${S} argument");`, `  off += ${used};`);
+                // Strings from outside are checked as UTF-8 (account data was checked when it was written).
+                for (const f of this.model.structs.get(S).fields) {
+                    const bad = `TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: invalid UTF-8 in a string argument")`;
+                    if (f.type.kind === "fstring")
+                        head.push(`  if (!ts_utf8_valid(${v}->${f.name}.bytes, ${v}->${f.name}.len)) ${bad};`);
+                    else if (f.type.kind === "vec" && f.type.elem.kind === "fstring")
+                        head.push(`  for (uint64_t i = 0; i < ${v}->${f.name}.len; i++)`, `    if (!ts_utf8_valid(${v}->${f.name}.items[i].bytes, ${v}->${f.name}.items[i].len)) ${bad};`);
+                }
+            }
             else if (a.type.kind === "structRef" || a.type.kind === "arrayArg") {
                 // Fixed layouts are Borsh-identical: copy to the heap, then check bools, enums, options and strings.
                 const v = `arg_${a.name}`;
@@ -234,8 +274,17 @@ export class FunctionEmitter extends StatementEmitter {
                             head.push(`    if (!ts_utf8_valid(${lv}.ptr, ${lv}.len)) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: invalid UTF-8 in a string argument");`);
                             continue;
                         }
+                        if (!isScalar(f.type) && borshIdentical(f.type, this.model)) {
+                            // A struct or array whose Borsh bytes are its fixed layout: copied, then checked (bools, enums).
+                            const lv = `${v}.v.${variant.name}.${f.name}`;
+                            const size = this.fieldBytes(f.type);
+                            head.push(`    if (params->data_len < off + ${size}) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
+                            head.push(`    ts_memcpy(&${lv}, params->data + off, ${size});`, `    off += ${size};`);
+                            head.push(...this.validation(lv, f.type, "    "));
+                            continue;
+                        }
                         if (!isScalar(f.type))
-                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys, enums and strings`);
+                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys, enums, strings and fixed-size structs and arrays of those`);
                         const size = scalarSize(f.type);
                         head.push(`    if (params->data_len < off + ${size}) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
                         head.push(`    ts_memcpy(&${v}.v.${variant.name}.${f.name}, params->data + off, ${size});`, `    off += ${size};`);
@@ -273,7 +322,14 @@ export class FunctionEmitter extends StatementEmitter {
             this.reporter.guard(() => this.statement(stmt, true));
         for (const name of this.pendingInit) {
             const k = this.accounts.get(name).kind;
-            const how = k.kind === "token" ? `${name}.${k.init === "create" ? "create" : "createIfNeeded"}(payer)` : `${name}.create(payer, seeds)`;
+            const a = this.accounts.get(name);
+            const how = k.kind === "token" && a.constraints.ata
+                ? `${name}.${k.init === "create" ? "create" : "createIfNeeded"}(payer)`
+                : k.kind === "token"
+                    ? `${name}.${k.init === "create" ? "create" : "createIfNeeded"}(payer, seeds | null, mint, authority)`
+                    : k.kind === "mint"
+                        ? `${name}.${k.init === "create" ? "create" : "createIfNeeded"}(payer, seeds | null, decimals, authority, freezeAuthority | null)`
+                        : `${name}.create(payer, seeds)`;
             this.reporter.error(this.accounts.get(name).node, `Init account "${name}" is never created; call ${how}`);
         }
         const end = ix.returns
@@ -285,13 +341,25 @@ export class FunctionEmitter extends StatementEmitter {
     epilogue() {
         if (!this.ix)
             return [];
-        return this.ix.accounts
-            .filter((a) => a.constraints.closeTo)
+        // @layout borsh accounts go back to their Borsh bytes (unless closed, or never created).
+        const packs = this.ix.accounts
+            .filter((a) => (a.kind.kind === "account" ? a.kind.mut : a.kind.kind === "init" || a.kind.kind === "initIfNeeded"))
+            .filter((a) => a.kind.struct.layout === "borsh")
             .map((a) => {
-            const line = `TS_TRY(ts_close(a_${a.name}, a_${a.constraints.closeTo}));`;
-            const optional = this.optionalIn(line);
-            return optional.length ? `if (${optional.map((n) => `a_${n} != NULL`).join(" && ")}) ${line}` : line;
+            const v = `a_${a.name}`;
+            const S = a.kind.struct.name;
+            return `if (${a.optional ? `${v} != NULL && ` : ""}${v}->data_len >= 8 && ts_key_eq(&${v}->owner, params->program_id)) TS_TRY(ts_pack_${S}(d_${a.name}, ${v}->data + 8, ${v}->data_len - 8, NULL));`;
         });
+        return [
+            ...packs,
+            ...this.ix.accounts
+                .filter((a) => a.constraints.closeTo)
+                .map((a) => {
+                const line = `TS_TRY(ts_close(a_${a.name}, a_${a.constraints.closeTo}));`;
+                const optional = this.optionalIn(line);
+                return optional.length ? `if (${optional.map((n) => `a_${n} != NULL`).join(" && ")}) ${line}` : line;
+            }),
+        ];
     }
     constraintChecks(ix) {
         const out = [];

package/dist/compiler/emit/program.js

@@ -1,5 +1,6 @@
-import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature } from "./shared.js";
+import { MAX_ACCOUNTS, cBytes, scalarStorageC, optC, storageDecl, helperSignature, fixedVecC } from "./shared.js";
 import { FunctionEmitter } from "./function.js";
+import { emitBorshCodecs } from "./borsh.js";
 /**
  * The whole C translation unit: type declarations (structs, options, enums, events), every helper and instruction
  * (lowered by FunctionEmitter), and the entry point that dispatches on the instruction discriminator.
@@ -8,17 +9,26 @@ export function emitProgram(analysis, opts = {}) {
     const { model, reporter } = analysis;
     // Bodies first: they register events, string-literal errors and PDA descriptions.
     const helperBodies = [];
-    for (const h of model.helpers.values()) {
-        const body = reporter.guard(() => new FunctionEmitter(analysis, h, opts).emitHelper());
-        if (body)
-            helperBodies.push(body, "");
-    }
+    const emittedHelpers = new Set();
+    // Generic helpers' instances appear while bodies are lowered: emit until none is left.
+    const emitHelpers = () => {
+        for (const h of model.helpers.values()) {
+            if (emittedHelpers.has(h.name))
+                continue;
+            emittedHelpers.add(h.name);
+            const body = reporter.guard(() => new FunctionEmitter(analysis, h, opts).emitHelper());
+            if (body)
+                helperBodies.push(body, "");
+        }
+    };
+    emitHelpers();
     const ixBodies = [];
     for (const ix of model.instructions) {
         const body = reporter.guard(() => new FunctionEmitter(analysis, ix, opts).emitInstruction());
         if (body)
             ixBodies.push(body, "");
     }
+    emitHelpers();
     const out = [];
     out.push(`/* Generated by TypeSOL from ${analysis.sourceFile.fileName.split("/").pop()}. Do not edit. */`);
     // `const HEAP_SIZE_KIB = 64n`: a larger heap, which clients request with ComputeBudget requestHeapFrame.
@@ -43,6 +53,13 @@ export function emitProgram(analysis, opts = {}) {
             emitStruct(model.structs.get(t.name));
         if (t.kind === "array" || t.kind === "vec")
             deps(t.elem);
+        if (t.kind === "vec" && t.cap !== undefined) {
+            const name = fixedVecC(t);
+            if (emitted.has(name))
+                return;
+            emitted.add(name);
+            out.push(`typedef struct __attribute__((packed)) {`, `  uint32_t len;`, `  ${storageDecl(t.elem, `items[${t.cap}]`)};`, `} ${name};`, "");
+        }
         if (t.kind === "option" && t.inner.kind === "struct") {
             const key = `opt:${t.inner.name}`;
             if (emitted.has(key))
@@ -99,6 +116,7 @@ export function emitProgram(analysis, opts = {}) {
     for (const k of model.constants.values())
         if (typeof k.value === "object")
             out.push(`static const SolPubkey TSK_${k.name} = {${cBytes(k.value.pubkey)}};`);
+    out.push(...emitBorshCodecs(model));
     const helpers = [...model.helpers.values()];
     for (const h of helpers)
         out.push(helperSignature(h) + ";");

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

@@ -39,11 +39,17 @@ export interface Ref {
     /** Field path from the account root, when it is a plain chain of fields. */
     path?: string[];
     /** For a Vec: the u32 length lvalue, the fixed-part size expression, and whether it may be resized here. */
+    /**
+     * A Vec place: `len` the u32 length (an lvalue), `items` the element array. A trailing Vec grows the account
+     * (`fixed` bytes before it); a FixedVec (`cap`) has room for `cap` elements and never resizes.
+     */
     vec?: {
         len: string;
+        items: string;
         fixed: string;
         elemSize: number;
         resizable: boolean;
+        cap?: number;
     };
 }
 export interface Local {
@@ -59,6 +65,14 @@ export interface Local {
     /** For struct / data-enum references: the storage paths they alias (e.g. "book.asks[]"), and the declaration. */
     paths?: string[];
     decl?: ts.VariableDeclaration;
+    /** A local closure (`const f = (…) => …` reading the enclosing function's variables), expanded where it is called. */
+    closure?: Closure;
+}
+/** A closure and the scopes it was declared in (its free names resolve there, wherever it is called). */
+export interface Closure {
+    node: ts.ArrowFunction | ts.FunctionExpression;
+    name: string;
+    scopes: Map<string, Local>[];
 }
 export declare const cBytes: (bytes: number[]) => string;
 /** C expressions that nothing in a TypeSOL expression can change: temporaries, locals, arguments, account keys, constants. */
@@ -88,3 +102,9 @@ export interface EmitOptions {
     /** Log a marker and the remaining compute units before every statement (`typesol build --profile`). */
     profile?: boolean;
 }
+/** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
+export declare function fixedVecC(t: FieldType & {
+    kind: "vec";
+}): string;
+/** The element count of a Vec place to read: a FixedVec's stored length is clamped to its capacity. */
+export declare function vecCount(v: NonNullable<Ref["vec"]>): string;

package/dist/compiler/emit/shared.js

@@ -1,4 +1,4 @@
-import { INT_INFO, isWritable, optionKey, } from "../model.js";
+import { INT_INFO, fixedVecName, isWritable, optionKey, } from "../model.js";
 // Types, limits and C type helpers shared by the emitter modules.
 /** Maximum accounts the generated entrypoint deserializes. */
 export const MAX_ACCOUNTS = 32;
@@ -89,6 +89,10 @@ export function fieldC(t) {
         case "pubkey":
         case "enum":
             return scalarStorageC(t);
+        case "vec":
+            if (t.cap !== undefined)
+                return fixedVecC(t);
+            throw new Error("unreachable: a Vec is never an element");
         default:
             throw new Error(`unreachable: no element C type for ${t.kind}`);
     }
@@ -115,6 +119,8 @@ export function storageDecl(t, name) {
         case "array":
             return storageDecl(t.elem, `${name}[${t.len}]`);
         case "vec":
+            if (t.cap !== undefined)
+                return `${fixedVecC(t)} ${name}`;
             // Borsh Vec as a trailing flexible array: u32 length, then the elements.
             return `uint32_t ${name}__len;
   ${storageDecl(t.elem, `${name}[]`)}`;
@@ -175,8 +181,14 @@ export function accountMismatch(have, want) {
 export function helperSignature(h) {
     const params = ["TsParams *params"];
     for (const p of h.params) {
-        if (p.account)
+        if (p.account) {
             params.push(`TsAccount *a_${p.name}`);
+            if (p.account.kind === "account" && p.account.struct.layout === "borsh")
+                params.push(`TSS_${p.account.struct.name} *d_${p.name}`);
+            // A writable account with a growable Vec: its length at instruction entry, for push / pop / clear.
+            if (p.account.kind === "account" && p.account.mut && p.account.struct.vec)
+                params.push(`uint64_t entry_${p.name}`);
+        }
         else if (p.type.kind === "signerSeeds")
             params.push(`const SolSignerSeed *p_${p.name}`, `int p_${p.name}__n`);
         else if (p.type.kind === "pubkey")
@@ -187,6 +199,14 @@ export function helperSignature(h) {
             params.push(`${valueC(p.type)} p_${p.name}`);
     }
     if (h.returns)
-        params.push(h.returns.kind === "struct" ? `TSS_${h.returns.name} *ret` : `${scalarC(h.returns)} *ret`);
+        params.push(h.returns.kind === "struct" ? `TSS_${h.returns.name} *ret` : h.returns.kind === "string" ? `TS_Str *ret` : `${scalarC(h.returns)} *ret`);
     return `static uint64_t fn_${h.name}(${params.join(", ")})`;
 }
+/** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
+export function fixedVecC(t) {
+    return `TSF_${fixedVecName(t)}`;
+}
+/** The element count of a Vec place to read: a FixedVec's stored length is clamped to its capacity. */
+export function vecCount(v) {
+    return v.cap === undefined ? `((uint64_t)${v.len})` : `((uint64_t)(${v.len} < ${v.cap} ? ${v.len} : ${v.cap}))`;
+}

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { type Value, type Closure } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
  * Statements: variables, assignment, control flow and return.
@@ -23,6 +24,26 @@ export declare abstract class StatementEmitter extends CpiEmitter {
      * inside the loop so its checked-arithmetic temporaries are recomputed every iteration.
      */
     protected loop(cond: ts.Expression | undefined, body: ts.Statement, step: ts.Expression | undefined): void;
+    /**
+     * Expand a closure where it is called: the arguments are evaluated here, in order, into the parameters (scalars,
+     * Pubkeys and strings by value, structs by reference, as JS passes objects); the body then runs with the names it
+     * was declared with, so a block around the call that declares the same name does not change what it reads, and
+     * writes to captured `let`s are seen by the enclosing function. Returns the result (undefined for no value).
+     */
+    protected expandClosure(c: Closure, args: readonly ts.Expression[], node: ts.Node): Value | undefined;
+    /**
+     * `xs.forEach / some / every / find / findIndex / reduce / includes / indexOf` on a Vec, FixedArray, FixedVec or Vec
+     * argument: an index loop (the length read each step, as `for … of`), the callback (an arrow written at the call)
+     * expanded with each element as `xs.get(i)` gives it (structs by reference) and, if it takes one, the index.
+     * `find` gives an Option of the element (scalar elements), `findIndex` / `indexOf` an i64 (-1 when absent).
+     */
+    protected listMethod(node: ts.CallExpression, method: string): Value | undefined;
+    /** `return` inside an expanded closure: the value goes to the closure's result, then past its body. */
+    protected closureReturn(stmt: ts.ReturnStatement, frame: (typeof this.inlineFrames)[number]): void;
+    /** Store a closure's result (fixing its type on the first one) and jump past the rest of its body. */
+    protected closureResult(value: Value, at: ts.Expression, frame: (typeof this.inlineFrames)[number]): void;
+    /** `do { … } while (cond)`: the body once, then the test; `continue` goes to the test. */
+    protected doLoop(stmt: ts.DoStatement): void;
     protected body(stmt: ts.Statement): void;
     protected variable(list: ts.VariableDeclarationList, topLevel?: boolean): void;
     /**