@typesol/cli 0.22.0 → 0.23.0

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { type AccountParam, type FieldType, type Helper, type IntName, type ParamKind, type ScalarType, type ValueType } from "../model.js";
+import { type AccountParam, type FieldType, type Helper, type IntName, type ParamKind, type ScalarType, type StructDef, type ValueType } from "../model.js";
 /** Maximum accounts the generated entrypoint deserializes. */
 export declare const MAX_ACCOUNTS = 32;
 export declare const MAX_SEEDS = 15;
@@ -46,16 +46,27 @@ export interface Ref {
     vec?: {
         len: string;
         items: string;
+        /** The account's size without this Vec's elements (so with `n` of them: 8 + fixed + n × elemSize). */
         fixed: string;
         elemSize: number;
         resizable: boolean;
         cap?: number;
+        /** Growable Vecs stored after this one move when it grows or shrinks: where its elements end, and their paths. */
+        tail?: {
+            end: string;
+            dataEnd: string;
+            paths: string[];
+        };
     };
 }
 export interface Local {
     c: string;
+    /** A value, or a local FixedArray / FixedVec (`fixedArray<T, N>(…)`, `const ys = xs.map(…)`) held in place. */
     type: ValueType | (FieldType & {
         kind: "array";
+    }) | (FieldType & {
+        kind: "vec";
+        cap: number;
     });
     mutable: boolean;
     /** Pubkey held as a `const SolPubkey *` (helper parameters) rather than a value. */
@@ -70,7 +81,8 @@ export interface Local {
 }
 /** 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;
+    /** The function expanded: a closure, or a helper expanded where it is called because it was given one. */
+    node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration;
     name: string;
     scopes: Map<string, Local>[];
 }
@@ -102,6 +114,24 @@ export interface EmitOptions {
     /** Log a marker and the remaining compute units before every statement (`typesol build --profile`). */
     profile?: boolean;
 }
+/** C type of a growable Vec stored after the first one of struct `s`: `{ uint32_t len; T items[]; }`. */
+export declare function laterVecC(s: string, field: string): string;
+/** The account size of struct `s` with every growable Vec empty, as C (8-byte discriminator not included). */
+export declare function emptySizeC(s: StructDef): string;
+/**
+ * Where growable Vec `k` of a struct at `base` (a C lvalue of type TSS_<S>) starts, as C: its length and elements.
+ * The first is a member of the struct; each further one starts right after the previous one's elements.
+ */
+export declare function vecPlace(s: StructDef, base: string, k: number): {
+    len: string;
+    items: string;
+    end: string;
+};
+/**
+ * C lines checking that an account's size matches its growable Vecs' lengths (`d`: its TSS_<S> pointer, `a`: its
+ * TsAccount). One Vec: ts_check_vec_len; more: each length read only once the bytes before it are known to exist.
+ */
+export declare function vecLenCheck(s: StructDef, a: string, d: string, pad?: string): string[];
 /** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
 export declare function fixedVecC(t: FieldType & {
     kind: "vec";

package/dist/compiler/emit/shared.js

@@ -202,6 +202,49 @@ export function helperSignature(h) {
         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 type of a growable Vec stored after the first one of struct `s`: `{ uint32_t len; T items[]; }`. */
+export function laterVecC(s, field) {
+    return `TSW_${s}__${field}`;
+}
+/** The account size of struct `s` with every growable Vec empty, as C (8-byte discriminator not included). */
+export function emptySizeC(s) {
+    const n = s.vecs?.length ?? 0;
+    return n > 1 ? `(sizeof(TSS_${s.name}) + ${4 * (n - 1)})` : `sizeof(TSS_${s.name})`;
+}
+/**
+ * Where growable Vec `k` of a struct at `base` (a C lvalue of type TSS_<S>) starts, as C: its length and elements.
+ * The first is a member of the struct; each further one starts right after the previous one's elements.
+ */
+export function vecPlace(s, base, k) {
+    const vs = s.vecs;
+    const first = vs[0];
+    let end = `((uint8_t *)${base}.${first.name} + (uint64_t)${base}.${first.name}__len * ${first.elemSize})`;
+    let place = { len: `${base}.${first.name}__len`, items: `${base}.${first.name}`, end };
+    for (let j = 1; j <= k; j++) {
+        const v = vs[j];
+        const h = `((${laterVecC(s.name, v.name)} *)${end})`;
+        end = `((uint8_t *)${h}->items + (uint64_t)${h}->len * ${v.elemSize})`;
+        place = { len: `${h}->len`, items: `${h}->items`, end };
+    }
+    return place;
+}
+/**
+ * C lines checking that an account's size matches its growable Vecs' lengths (`d`: its TSS_<S> pointer, `a`: its
+ * TsAccount). One Vec: ts_check_vec_len; more: each length read only once the bytes before it are known to exist.
+ */
+export function vecLenCheck(s, a, d, pad = "  ") {
+    const vs = s.vecs ?? [];
+    if (vs.length === 1)
+        return [`${pad}TS_TRY(ts_check_vec_len(${a}, sizeof(TSS_${s.name}), ${d}->${vs[0].name}__len, TS_ELEM_${s.name}));`];
+    const o = `${d.replace(/\W/g, "")}__vo`;
+    const lines = [`${pad}{`, `${pad}  uint64_t ${o} = sizeof(TSS_${s.name}) + (uint64_t)${d}->${vs[0].name}__len * ${vs[0].elemSize};`];
+    for (const v of vs.slice(1)) {
+        lines.push(`${pad}  if (${a}->data_len < 8 + ${o} + 4) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account size does not match its Vec lengths");`);
+        lines.push(`${pad}  ${o} += 4 + (uint64_t)((${laterVecC(s.name, v.name)} *)(${a}->data + 8 + ${o}))->len * ${v.elemSize};`);
+    }
+    lines.push(`${pad}  if (${a}->data_len != 8 + ${o}) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account size does not match its Vec lengths");`, `${pad}}`);
+    return lines;
+}
 /** C typedef name of a FixedVec<T, N>: `{ uint32_t len; T items[N]; }`. */
 export function fixedVecC(t) {
     return `TSF_${fixedVecName(t)}`;

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { type FieldType } from "../model.js";
 import { type Value, type Closure } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
@@ -17,6 +18,40 @@ export declare abstract class StatementEmitter extends CpiEmitter {
      * As in JS, the length is read again before every step, so a body that pushes or pops sees the new length.
      */
     protected forOf(stmt: ts.ForOfStatement): void;
+    /** `xs.map(…)` / `xs.filter(…)` (or a chain of them): a list built element by element, not stored anywhere yet. */
+    protected isPipeline(e: ts.Expression): e is ts.CallExpression;
+    /** The list under a chain of map / filter calls, and the calls in the order they run. */
+    protected pipelineStages(e: ts.Expression): {
+        base: ts.Expression;
+        stages: {
+            kind: "map" | "filter";
+            fn: ts.ArrowFunction | ts.FunctionExpression;
+        }[];
+    };
+    /**
+     * Run `body` for each element of a list, or of a chain of `map` / `filter` calls on one (`xs.filter(f).map(g)`):
+     * one index loop over the list (its length read every step, as `for … of`), each callback expanded in it. A
+     * filter skips to the next element, a map binds its result, so a chain builds no list. `body` gets the element (as
+     * `list.get(i)` gives it, structs by reference, or the mapped value) and its index in the chain's output (after a
+     * filter, the count of elements it let through, as JS gives callbacks).
+     */
+    protected eachElement(list: ts.Expression, at: ts.Node, names: {
+        index: string;
+        ci: string;
+        next?: string;
+        alwaysNext?: boolean;
+    }, body: (element: ts.Expression, index: ts.Expression) => void): void;
+    /**
+     * `const ys = xs.map(…)` / `xs.filter(…)`: the chain's elements in a local FixedVec, as big as the list it starts
+     * from (a FixedArray's length, a FixedVec's capacity) or as annotated (`const ys: FixedVec<u64, 16> = …`, needed
+     * when it starts from a Vec). It lives on the stack, so it holds at most 2 KiB; one more element than it holds aborts.
+     */
+    protected localList(d: ts.VariableDeclaration, init: ts.CallExpression, c: string): FieldType & {
+        kind: "vec";
+        cap: number;
+    };
+    /** The element type of a Vec, FixedArray, FixedVec or Vec argument. */
+    protected listElem(list: ts.Expression): FieldType;
     /** Whether `e` is the remaining accounts (or a const bound to them). */
     protected isRemaining(e: ts.Expression): boolean;
     /**

package/dist/compiler/emit/statements.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { MAX_RETURN_DATA, resolveValueType, structNameOf } from "../analyze.js";
+import { MAX_RETURN_DATA, resolveScalarType, resolveValueType, structNameOf, typesolName } from "../analyze.js";
 import { INT_INFO, isWritable, optionKey, scalarSize, typeName } from "../model.js";
-import { U64, BOOL, cString, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
+import { U64, BOOL, cString, fixedVecC, optC, scalarC, scalarStorageC, valueC } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
  * Statements: variables, assignment, control flow and return.
@@ -259,37 +259,196 @@ export class StatementEmitter extends CpiEmitter {
             n.parent = stmt;
             return n;
         };
-        const indexId = place(f.createIdentifier(index));
-        const length = place(f.createPropertyAccessExpression(stmt.expression, "length"));
-        const get = place(f.createCallExpression(place(f.createPropertyAccessExpression(stmt.expression, "get")), undefined, [indexId]));
-        // The element's declaration: the source's own name (so aliasing checks find its uses) bound to list.get(i).
-        const decl = f.createVariableDeclaration(d.name, undefined, undefined, get);
-        ts.setTextRange(decl, d);
-        decl.parent = list;
-        const declList = { ...list, flags: ts.NodeFlags.Const, declarations: [decl] };
+        void place;
         const ci = this.tmp("of_i");
         const label = this.tmp("ts_continue_");
+        this.eachElement(stmt.expression, stmt, { index, ci, next: label, alwaysNext: true }, (element) => {
+            // The element's declaration: the source's own name (so aliasing checks find its uses) bound to the element.
+            const decl = f.createVariableDeclaration(d.name, undefined, undefined, element);
+            ts.setTextRange(decl, d);
+            decl.parent = list;
+            const declList = { ...list, flags: ts.NodeFlags.Const, declarations: [decl] };
+            this.variable(declList);
+            this.loops.push(label);
+            this.line(`{`);
+            this.block(() => this.body(stmt.statement));
+            this.line(`}`);
+            this.loops.pop();
+        });
+    }
+    /** `xs.map(…)` / `xs.filter(…)` (or a chain of them): a list built element by element, not stored anywhere yet. */
+    isPipeline(e) {
+        return ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && (e.expression.name.text === "map" || e.expression.name.text === "filter");
+    }
+    /** The list under a chain of map / filter calls, and the calls in the order they run. */
+    pipelineStages(e) {
+        const stages = [];
+        let base = e;
+        while (this.isPipeline(base)) {
+            const access = base.expression;
+            const kind = access.name.text;
+            if (base.arguments.length !== 1)
+                this.fail(base, `${kind}() takes one argument: the callback`);
+            const fn = base.arguments[0];
+            if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn))
+                this.fail(fn, `pass ${kind} an arrow function written here: xs.${kind}((x) => …)`);
+            if (fn.parameters.length > 2)
+                this.fail(fn.parameters[2], `${kind}'s callback takes the element and its index`);
+            stages.unshift({ kind, fn });
+            base = access.expression;
+        }
+        if (stages.length) {
+            const l = ts.isIdentifier(base) ? this.lookup(base.text) : undefined;
+            if (!(l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(base)))
+                this.fail(base, "map and filter work on a Vec, FixedArray or FixedVec");
+        }
+        return { base, stages };
+    }
+    /**
+     * Run `body` for each element of a list, or of a chain of `map` / `filter` calls on one (`xs.filter(f).map(g)`):
+     * one index loop over the list (its length read every step, as `for … of`), each callback expanded in it. A
+     * filter skips to the next element, a map binds its result, so a chain builds no list. `body` gets the element (as
+     * `list.get(i)` gives it, structs by reference, or the mapped value) and its index in the chain's output (after a
+     * filter, the count of elements it let through, as JS gives callbacks).
+     */
+    eachElement(list, at, names, body) {
+        const f = ts.factory;
+        const place = (n) => {
+            ts.setTextRange(n, at);
+            n.parent = at;
+            return n;
+        };
+        const { base, stages } = this.pipelineStages(list);
+        const { index, ci } = names;
+        const indexId = place(f.createIdentifier(index));
+        const length = place(f.createPropertyAccessExpression(base, "length"));
+        const get = place(f.createCallExpression(place(f.createPropertyAccessExpression(base, "get")), undefined, [indexId]));
+        const next = names.next ?? (stages.some((s) => s.kind === "filter") ? this.tmp("ts_next_") : undefined);
         this.line(`{`);
         this.block(() => {
             this.line(`uint64_t ${ci} = 0;`);
             this.scopes.at(-1).set(index, { c: ci, type: U64, mutable: false });
+            const counters = stages
+                .filter((st) => st.kind === "filter")
+                .map(() => {
+                const k = this.tmp("lm_k");
+                this.line(`uint64_t ${k} = 0;`);
+                return k;
+            });
             this.line(`while (1) {`);
             this.block(() => {
-                const n = this.expect(this.expr(length, U64), U64, stmt.expression);
+                const n = this.expect(this.expr(length, U64), U64, base);
                 this.line(`if (!(${ci} < ${n.c})) break;`);
-                this.variable(declList);
-                this.loops.push(label);
-                this.line(`{`);
-                this.block(() => this.body(stmt.statement));
-                this.line(`}`);
-                this.loops.pop();
-                this.line(`${label}:;`);
+                let element = get;
+                let idx = indexId;
+                let k = 0;
+                for (const st of stages) {
+                    const closure = { node: st.fn, name: `${st.kind}'s callback`, scopes: [...this.scopes] };
+                    const v = this.expandClosure(closure, [element, idx].slice(0, st.fn.parameters.length), st.fn);
+                    if (st.kind === "filter") {
+                        if (!v)
+                            this.fail(st.fn, "filter's callback returns a boolean");
+                        const b = this.expect(v, BOOL, st.fn);
+                        this.line(`if (!(${b.c})) goto ${next};`);
+                        const id = `__lk${this.temp++}`;
+                        const ic = this.tmp("lm_ki");
+                        this.line(`uint64_t ${ic} = ${counters[k++]}++;`);
+                        this.scopes.at(-1).set(id, { c: ic, type: U64, mutable: false });
+                        idx = place(f.createIdentifier(id));
+                    }
+                    else {
+                        if (!v)
+                            this.fail(st.fn, "map's callback returns the new element");
+                        const mv = v.literal !== undefined ? this.literal(v.literal, U64, st.fn) : v;
+                        if (!["int", "bool", "pubkey", "enum"].includes(mv.type.kind))
+                            this.fail(st.fn, `map's callback returns integers, booleans, Pubkeys or enums (the new list's elements), not ${typeName(mv.type)}`);
+                        const id = `__lv${this.temp++}`;
+                        const mc = this.tmp("lm_v");
+                        this.line(mv.type.kind === "pubkey" ? `SolPubkey ${mc} = *(${mv.c});` : `${valueC(mv.type)} ${mc} = ${mv.c};`);
+                        this.scopes.at(-1).set(id, { c: mc, type: mv.type, mutable: false });
+                        element = place(f.createIdentifier(id));
+                    }
+                }
+                body(element, idx);
+                if (next && (names.alwaysNext || counters.length))
+                    this.line(`${next}:;`);
                 this.line(`${ci}++;`);
             });
             this.line(`}`);
         });
         this.line(`}`);
     }
+    /**
+     * `const ys = xs.map(…)` / `xs.filter(…)`: the chain's elements in a local FixedVec, as big as the list it starts
+     * from (a FixedArray's length, a FixedVec's capacity) or as annotated (`const ys: FixedVec<u64, 16> = …`, needed
+     * when it starts from a Vec). It lives on the stack, so it holds at most 2 KiB; one more element than it holds aborts.
+     */
+    localList(d, init, c) {
+        const { base, stages } = this.pipelineStages(init);
+        let cap;
+        let annotatedElem;
+        if (d.type) {
+            const t = d.type;
+            const args = ts.isTypeReferenceNode(t) ? (t.typeArguments ?? []) : [];
+            const n = args[1] && ts.isLiteralTypeNode(args[1]) && ts.isNumericLiteral(args[1].literal) ? Number(args[1].literal.text) : NaN;
+            const elemNode = args[0];
+            const sn = elemNode && structNameOf(elemNode, this.scope);
+            annotatedElem = elemNode
+                ? (resolveScalarType(elemNode, this.scope) ?? (sn && this.model.structs.has(sn) ? { kind: "struct", name: sn } : undefined))
+                : undefined;
+            if (!ts.isTypeReferenceNode(t) || typesolName(t, this.scope.imports) !== "FixedVec" || !annotatedElem || !Number.isInteger(n) || n < 1)
+                this.fail(t, "annotate the new list as FixedVec<T, N> (N a literal)");
+            cap = n;
+        }
+        else {
+            const r = this.reporter.guard(() => this.ref(base));
+            const l = ts.isIdentifier(base) ? this.lookup(base.text) : undefined;
+            if (r?.type.kind === "array")
+                cap = r.type.len;
+            else if (r?.type.kind === "vec" && r.type.cap !== undefined)
+                cap = r.type.cap;
+            if (cap === undefined || l?.type.kind === "vecArg")
+                this.fail(init, "this list has no fixed size: annotate the new one with its capacity, const ys: FixedVec<T, N> = …");
+        }
+        // The element type: the last map's result, else the list's own elements (known once the loop is emitted).
+        const declAt = this.lines.length;
+        this.line(`/* ${c} */`);
+        let elem = stages.some((st) => st.kind === "map") ? undefined : this.listElem(base);
+        const cap0 = cap;
+        this.eachElement(init, init, { index: `__ml${this.temp++}`, ci: this.tmp("ml_i") }, (element) => {
+            if (!elem) {
+                const v = this.expr(element);
+                elem = v.type;
+            }
+            const target = annotatedElem ?? elem;
+            const sub = { lv: `${c}.items[${c}.len]`, type: target, writable: true };
+            this.line(`if (${c}.len >= ${cap0}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: the new list is full");`);
+            const vt = this.storageValueType(target);
+            if (vt)
+                this.line(this.writeStorage(sub, this.ownedString(this.expect(this.expr(element, vt), vt, element)).c) + ";");
+            else
+                this.writeAggregate(sub, element);
+            this.line(`${c}.len++;`);
+        });
+        const t = { kind: "vec", elem: annotatedElem ?? elem, cap: cap0 };
+        const bytes = 4 + this.fieldBytes(t.elem) * cap0;
+        if (bytes > 2048)
+            this.fail(init, `the new list takes ${bytes} bytes; locals live on the 4 KiB stack, so keep it under 2 KiB (a smaller FixedVec<T, N>)`);
+        this.model.localVecs.set(fixedVecC(t), t);
+        const pad = "  ".repeat(this.indent);
+        this.lines[declAt] = `${pad}${fixedVecC(t)} ${c};\n${pad}ts_memzero(&${c}, sizeof(${c}));`;
+        return t;
+    }
+    /** The element type of a Vec, FixedArray, FixedVec or Vec argument. */
+    listElem(list) {
+        const l = ts.isIdentifier(list) ? this.lookup(list.text) : undefined;
+        if (l?.type.kind === "vecArg")
+            return l.type.elem;
+        const r = this.ref(list);
+        if (r && (r.type.kind === "array" || r.type.kind === "vec"))
+            return r.type.elem;
+        this.fail(list, "expected a Vec, FixedArray or FixedVec");
+    }
     /** Whether `e` is the remaining accounts (or a const bound to them). */
     isRemaining(e) {
         if (ts.isCallExpression(e) && this.exportName(e.expression) === "remainingAccounts")
@@ -337,6 +496,11 @@ export class StatementEmitter extends CpiEmitter {
                 this.fail(p, "closure parameters are plain names");
             const arg = args[i];
             const name = p.name.text;
+            // A function parameter (of a helper expanded here): the function given, expanded where the body calls it.
+            if (p.type && ts.isFunctionTypeNode(p.type)) {
+                params.set(name, { c: "", type: BOOL, mutable: false, closure: this.closureOf(arg) });
+                return;
+            }
             const c2 = `l_${name}_${this.temp++}`;
             const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
             if (!annotated && this.looksLikeStructPlace(arg)) {
@@ -378,6 +542,8 @@ export class StatementEmitter extends CpiEmitter {
             this.line(`{`);
             this.block(() => {
                 const body = fn.body;
+                if (!body)
+                    this.fail(fn, `${c.name} has no body`);
                 if (ts.isBlock(body))
                     body.statements.forEach((s) => this.reporter.guard(() => this.statement(s)));
                 else {
@@ -434,9 +600,7 @@ export class StatementEmitter extends CpiEmitter {
             this.fail(cb, `pass ${method} an arrow function written here: xs.${method}((x) => …)`);
         const fn = cb;
         const index = `__lm${this.temp++}`;
-        const indexId = place(f.createIdentifier(index));
-        const length = place(f.createPropertyAccessExpression(list, "length"));
-        const element = place(f.createCallExpression(place(f.createPropertyAccessExpression(list, "get")), undefined, [indexId]));
+        void place;
         const I64 = { kind: "int", name: "i64" };
         // The result, declared before the loop.
         const res = this.tmp("lm");
@@ -482,69 +646,58 @@ export class StatementEmitter extends CpiEmitter {
         }
         const findDecl = method === "find" ? this.lines.length - 1 : -1;
         const ci = this.tmp("lm_i");
-        this.line(`{`);
-        this.block(() => {
-            this.line(`uint64_t ${ci} = 0;`);
-            this.scopes.at(-1).set(index, { c: ci, type: U64, mutable: false });
-            this.line(`while (1) {`);
-            this.block(() => {
-                const n = this.expect(this.expr(length, U64), U64, list);
-                this.line(`if (!(${ci} < ${n.c})) break;`);
-                if (valueForm) {
-                    const eq = place(f.createBinaryExpression(element, ts.SyntaxKind.EqualsEqualsEqualsToken, place(f.createIdentifier(needle))));
-                    const hit = this.expect(this.expr(eq, BOOL), BOOL, node);
-                    this.line(`if (${hit.c}) {`);
-                    this.line(method === "includes" ? `  ${res} = true;` : `  ${res} = (int64_t)${ci};`);
-                    this.line(`  break;`);
-                    this.line(`}`);
+        this.eachElement(list, node, { index, ci }, (element, indexId) => {
+            if (valueForm) {
+                const eq = place(f.createBinaryExpression(element, ts.SyntaxKind.EqualsEqualsEqualsToken, place(f.createIdentifier(needle))));
+                const hit = this.expect(this.expr(eq, BOOL), BOOL, node);
+                this.line(`if (${hit.c}) {`);
+                this.line(method === "includes" ? `  ${res} = true;` : `  ${res} = (int64_t)${this.expr(indexId, U64).c};`);
+                this.line(`  break;`);
+                this.line(`}`);
+            }
+            else {
+                const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes] };
+                const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
+                if (accId)
+                    this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
+                const all = method === "reduce" ? [accId, element, indexId] : [element, indexId];
+                const v = this.expandClosure(closure, all.slice(0, fn.parameters.length), cb);
+                if (method === "forEach") {
+                    if (v)
+                        this.fail(cb, "forEach's callback returns nothing");
+                }
+                else if (method === "reduce") {
+                    if (!v)
+                        this.fail(cb, "reduce's callback returns the new accumulator");
+                    const nv = this.expect(v, accType, cb);
+                    this.line(accType.kind === "pubkey" ? `${res} = *(${nv.c});` : `${res} = ${nv.c};`);
                 }
                 else {
-                    const closure = { node: fn, name: `${method}'s callback`, scopes: [...this.scopes] };
-                    const accId = method === "reduce" ? place(f.createIdentifier(`__acc${this.temp++}`)) : undefined;
-                    if (accId)
-                        this.scopes.at(-1).set(accId.text, { c: res, type: accType, mutable: true });
-                    const all = method === "reduce" ? [accId, element, indexId] : [element, indexId];
-                    const v = this.expandClosure(closure, all.slice(0, fn.parameters.length), cb);
-                    if (method === "forEach") {
-                        if (v)
-                            this.fail(cb, "forEach's callback returns nothing");
-                    }
-                    else if (method === "reduce") {
-                        if (!v)
-                            this.fail(cb, "reduce's callback returns the new accumulator");
-                        const nv = this.expect(v, accType, cb);
-                        this.line(accType.kind === "pubkey" ? `${res} = *(${nv.c});` : `${res} = ${nv.c};`);
-                    }
-                    else {
-                        if (!v)
-                            this.fail(cb, `${method}'s callback returns a boolean`);
-                        const b = this.expect(v, BOOL, cb);
-                        if (method === "some")
-                            this.line(`if (${b.c}) { ${res} = true; break; }`);
-                        if (method === "every")
-                            this.line(`if (!(${b.c})) { ${res} = false; break; }`);
-                        if (method === "findIndex")
-                            this.line(`if (${b.c}) { ${res} = (int64_t)${ci}; break; }`);
-                        if (method === "find") {
-                            this.line(`if (${b.c}) {`);
-                            this.block(() => {
-                                const e = this.expr(element);
-                                elemType = e.type;
-                                if (!["int", "bool", "pubkey", "enum"].includes(e.type.kind))
-                                    this.fail(node, "find returns an Option of the element, so the elements must be integers, booleans, Pubkeys or enums; use findIndex");
-                                this.line(`${res}.some = 1;`);
-                                this.line(e.type.kind === "pubkey" ? `${res}.v = *(${e.c});` : `${res}.v = ${e.c};`);
-                                this.line(`break;`);
-                            });
-                            this.line(`}`);
-                        }
+                    if (!v)
+                        this.fail(cb, `${method}'s callback returns a boolean`);
+                    const b = this.expect(v, BOOL, cb);
+                    if (method === "some")
+                        this.line(`if (${b.c}) { ${res} = true; break; }`);
+                    if (method === "every")
+                        this.line(`if (!(${b.c})) { ${res} = false; break; }`);
+                    if (method === "findIndex")
+                        this.line(`if (${b.c}) { ${res} = (int64_t)${this.expr(indexId, U64).c}; break; }`);
+                    if (method === "find") {
+                        this.line(`if (${b.c}) {`);
+                        this.block(() => {
+                            const e = this.expr(element);
+                            elemType = e.type;
+                            if (!["int", "bool", "pubkey", "enum"].includes(e.type.kind))
+                                this.fail(node, "find returns an Option of the element, so the elements must be integers, booleans, Pubkeys or enums; use findIndex");
+                            this.line(`${res}.some = 1;`);
+                            this.line(e.type.kind === "pubkey" ? `${res}.v = *(${e.c});` : `${res}.v = ${e.c};`);
+                            this.line(`break;`);
+                        });
+                        this.line(`}`);
                     }
                 }
-                this.line(`${ci}++;`);
-            });
-            this.line(`}`);
+            }
         });
-        this.line(`}`);
         if (method === "find") {
             const inner = elemType;
             this.model.options.set(optionKey(inner), inner);
@@ -650,6 +803,11 @@ export class StatementEmitter extends CpiEmitter {
                 this.scopes.at(-1).set(name, { c, type: t, mutable });
                 continue;
             }
+            if (this.isPipeline(init)) {
+                const t = this.localList(d, init, c);
+                this.scopes.at(-1).set(name, { c, type: t, mutable });
+                continue;
+            }
             if (fn === "loadAccount" || fn === "loadAccountMut" || fn === "loadForeign") {
                 if (mutable)
                     this.fail(d, "bind loaded accounts with const");

package/dist/compiler/emit/storage.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { resolveScalarType } from "../analyze.js";
 import { INT_INFO, isScalar, isWritable, sameType, scalarSize, typeName } from "../model.js";
-import { U64, BOOL, PUBKEY, STRING, optC, fieldC, fixedVecC, storageDecl, vecCount } from "./shared.js";
+import { U64, BOOL, PUBKEY, STRING, optC, fieldC, fixedVecC, storageDecl, vecCount, vecPlace, emptySizeC } from "./shared.js";
 import { EmitterBase } from "./base.js";
 /**
  * Places in account data and locals: references, reads and writes, Vec/array indexing, aliasing rules and
@@ -258,6 +258,8 @@ export class StorageEmitter extends EmitterBase {
             const l = this.lookup(node.text);
             if (l && l.type.kind === "array")
                 return { lv: l.c, type: l.type, writable: !l.readonly };
+            if (l && l.type.kind === "vec")
+                return this.withFixedVec({ lv: l.c, type: l.type, writable: true });
             // A struct loaded from a remaining account.
             if (l && l.type.kind === "structRef")
                 return { lv: `(*${l.c})`, type: { kind: "struct", name: l.type.struct }, writable: l.type.writable };
@@ -278,15 +280,35 @@ export class StorageEmitter extends EmitterBase {
                     const r = { lv: `d_${a.name}->${f.name}`, type: f.type, writable: isWritable(a.kind), account: a, path: [f.name] };
                     if (f.type.kind === "vec" && f.type.cap !== undefined)
                         r.vec = this.fixedVec(r.lv, f.type.elem, f.type.cap);
-                    else if (f.type.kind === "vec")
+                    else if (f.type.kind === "vec") {
                         // Growing needs the account's length at instruction entry: instructions have it, helpers get it passed.
-                        r.vec = {
-                            len: `d_${a.name}->${f.name}__len`,
-                            items: r.lv,
-                            fixed: `sizeof(TSS_${a.kind.struct.name})`,
-                            elemSize: a.kind.struct.vec.elemSize,
-                            resizable: isWritable(a.kind),
-                        };
+                        const s = a.kind.struct;
+                        const k = s.vecs.findIndex((v) => v.name === f.name);
+                        if (s.vecs.length === 1)
+                            r.vec = {
+                                len: `d_${a.name}->${f.name}__len`,
+                                items: r.lv,
+                                fixed: `sizeof(TSS_${s.name})`,
+                                elemSize: s.vec.elemSize,
+                                resizable: isWritable(a.kind),
+                            };
+                        else {
+                            const base = `(*d_${a.name})`;
+                            const at = vecPlace(s, base, k);
+                            const others = s.vecs.map((v, j) => (j === k ? "" : ` + (uint64_t)${vecPlace(s, base, j).len} * ${v.elemSize}`)).join("");
+                            r.lv = at.items;
+                            r.vec = {
+                                len: at.len,
+                                items: at.items,
+                                fixed: `(${emptySizeC(s)}${others})`,
+                                elemSize: s.vecs[k].elemSize,
+                                resizable: isWritable(a.kind),
+                                tail: k < s.vecs.length - 1
+                                    ? { end: at.end, dataEnd: `(a_${a.name}->data + a_${a.name}->data_len)`, paths: s.vecs.slice(k + 1).map((v) => `${a.name}.${v.name}[]`) }
+                                    : undefined,
+                            };
+                        }
+                    }
                     return r;
                 }
             }
@@ -330,8 +352,12 @@ export class StorageEmitter extends EmitterBase {
                     this.fail(node.name, `${s.name} has no field "${field}"`);
                 const r = { ...base, lv: `${base.lv}.${f.name}`, type: f.type, path: base.path && [...base.path, f.name], vec: undefined };
                 // Vecs of loaded accounts can be read and updated in place but not resized (no entry length known).
-                if (f.type.kind === "vec" && f.type.cap === undefined)
-                    r.vec = { len: `${base.lv}.${f.name}__len`, items: r.lv, fixed: `sizeof(TSS_${s.name})`, elemSize: s.vec.elemSize, resizable: false };
+                if (f.type.kind === "vec" && f.type.cap === undefined) {
+                    const k = s.vecs.findIndex((v) => v.name === f.name);
+                    const at = s.vecs.length === 1 ? { len: `${base.lv}.${f.name}__len`, items: r.lv } : vecPlace(s, base.lv, k);
+                    r.lv = at.items;
+                    r.vec = { len: at.len, items: at.items, fixed: emptySizeC(s), elemSize: s.vecs[k].elemSize, resizable: false };
+                }
                 return this.withFixedVec(r);
             }
             return undefined;
@@ -671,8 +697,8 @@ export class StorageEmitter extends EmitterBase {
             const l = this.lookup(node.text);
             if (!l)
                 this.fail(node, `"${node.text}" is not a local variable`);
-            if (l.type.kind === "array")
-                this.fail(node, `use ${node.text}.set(i, v) to change array elements`);
+            if (l.type.kind === "array" || l.type.kind === "vec")
+                this.fail(node, `use ${node.text}.set(i, v) to change list elements`);
             if (!l.mutable)
                 this.fail(node, `"${node.text}" is const or an argument and cannot be reassigned`);
             if (l.type.kind === "pubkey")