@typesol/cli 0.15.0 → 0.16.0

package/dist/compiler/emit/cpi.js

@@ -371,7 +371,98 @@ export class CpiEmitter extends CallEmitter {
         };
         const value = (n, t) => (put) => this.serialize(this.expect(this.expr(n, t), t, n), n, put);
         const optKey = { kind: "option", inner: PUBKEY };
+        const U16 = { kind: "int", name: "u16" };
+        const I16 = { kind: "int", name: "i16" };
+        const byte = (k) => (put) => {
+            const t = this.tmp("b");
+            this.line(`uint8_t ${t} = ${k};`);
+            put(`&${t}`, "1", 1);
+        };
+        /** Token-2022's OptionalNonZeroPubkey: 32 bytes, all zero for none. */
+        const nonZeroKey = (n) => (put) => {
+            this.model.options.set("pubkey", PUBKEY);
+            const v = this.expect(this.expr(n, optKey), optKey, n);
+            const t = this.tmp("nzk");
+            this.line(`SolPubkey ${t};`);
+            this.line(`{ ${optC(PUBKEY)} o = ${v.c}; if (o.some) ${t} = o.v; else ts_memzero(&${t}, 32); }`);
+            put(`&${t}`, "32", 32);
+        };
+        const token2022Only = () => {
+            if (program.kind.kind === "tokenProgram" && program.kind.flavor === "token")
+                this.fail(node, `${method} is a Token-2022 extension; use Token2022Program or TokenInterface`);
+        };
+        const mintOnly = (n, usage) => {
+            token2022Only();
+            if (a.length !== n)
+                this.fail(node, usage);
+            return anyAcct(a[0], "the mint", true);
+        };
+        const none = { name: "NULL", count: 0 };
         switch (method) {
+            case "initializeTransferFeeConfig": {
+                const mint = mintOnly(5, "initializeTransferFeeConfig(mint, configAuthority | null, withdrawAuthority | null, basisPoints, maximumFee)");
+                this.model.options.set("pubkey", PUBKEY);
+                // Arguments in source order, as JS evaluates them: the basis points are checked when they are read.
+                const bps = (put) => {
+                    const v = this.expect(this.expr(a[3], U16), U16, a[3]);
+                    this.line(`if (${v.c} > 10000) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: transfer fee above 10000 basis points");`);
+                    this.serialize(v, a[3], put);
+                };
+                simple(26, [byte(0), value(a[1], optKey), value(a[2], optKey), bps, value(a[4], U64)], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeMintCloseAuthority": {
+                const mint = mintOnly(2, "initializeMintCloseAuthority(mint, closeAuthority | null)");
+                this.model.options.set("pubkey", PUBKEY);
+                simple(25, [value(a[1], optKey)], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeNonTransferableMint": {
+                const mint = mintOnly(1, "initializeNonTransferableMint(mint)");
+                simple(32, [], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializePermanentDelegate": {
+                const mint = mintOnly(2, "initializePermanentDelegate(mint, delegate)");
+                simple(35, [value(a[1], PUBKEY)], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeDefaultAccountState": {
+                const mint = mintOnly(2, "initializeDefaultAccountState(mint, frozen)");
+                const frozen = this.expect(this.expr(a[1], BOOL), BOOL, a[1]);
+                const st = this.tmp("st");
+                this.line(`uint8_t ${st} = (${frozen.c}) ? 2 : 1;`); // AccountState::Frozen / Initialized
+                simple(28, [byte(0), (put) => put(`&${st}`, "1", 1)], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeMetadataPointer":
+            case "initializeGroupPointer":
+            case "initializeGroupMemberPointer":
+            case "initializeTransferHook": {
+                const tag = { initializeMetadataPointer: 39, initializeGroupPointer: 40, initializeGroupMemberPointer: 41, initializeTransferHook: 36 }[method];
+                const second = {
+                    initializeMetadataPointer: "metadataAddress",
+                    initializeGroupPointer: "groupAddress",
+                    initializeGroupMemberPointer: "memberAddress",
+                    initializeTransferHook: "programId",
+                }[method];
+                const mint = mintOnly(3, `${method}(mint, authority | null, ${second} | null)`);
+                simple(tag, [byte(0), nonZeroKey(a[1]), nonZeroKey(a[2])], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeInterestBearingMint": {
+                const mint = mintOnly(3, "initializeInterestBearingMint(mint, rateAuthority | null, rate)");
+                simple(33, [byte(0), nonZeroKey(a[1]), value(a[2], I16)], [[mint, true, false]], none);
+                return undefined;
+            }
+            case "initializeImmutableOwner": {
+                token2022Only();
+                if (a.length !== 1)
+                    this.fail(node, "initializeImmutableOwner(account)");
+                const acct = anyAcct(a[0], "the token account", true);
+                simple(22, [], [[acct, true, false]], none);
+                return undefined;
+            }
             case "approve": {
                 arity(4);
                 const src = want(a[0], "token", true, "the source");
@@ -448,7 +539,7 @@ export class CpiEmitter extends CallEmitter {
                 return undefined;
             }
         }
-        this.fail(node.expression, `token programs support transfer, transferChecked, mintTo, burn, closeAccount, approve, revoke, setAuthority, freezeAccount, thawAccount, syncNative, initializeMint2, initializeAccount3 and initializeMetadata, not ${method}`);
+        this.fail(node.expression, `token programs support transfer, transferChecked, mintTo, burn, closeAccount, approve, revoke, setAuthority, freezeAccount, thawAccount, syncNative, initializeMint2, initializeAccount3, initializeMetadata and the Token-2022 extension initializers (initializeTransferFeeConfig, initializeMintCloseAuthority, initializeNonTransferableMint, initializePermanentDelegate, initializeDefaultAccountState, initializeMetadataPointer, initializeGroupPointer, initializeGroupMemberPointer, initializeTransferHook, initializeInterestBearingMint, initializeImmutableOwner), not ${method}`);
     }
     ataOp(node, program, method) {
         if (method !== "create" && method !== "createIdempotent")
@@ -474,8 +565,12 @@ export class CpiEmitter extends CallEmitter {
         if (method !== "createV3")
             this.fail(node.expression, "the Token Metadata program supports createV3");
         const a = node.arguments;
-        if (a.length !== 11 && a.length !== 12)
-            this.fail(node, "createV3(metadata, mint, mintAuthority, payer, updateAuthority, systemProgram, name, symbol, uri, sellerFeeBasisPoints, isMutable, signerSeeds?)");
+        const usage = "createV3(metadata, mint, mintAuthority, payer, updateAuthority, systemProgram, name, symbol, uri, sellerFeeBasisPoints, isMutable, { creators?, collection? }?, signerSeeds?)";
+        // An object literal after isMutable carries the optional creators / collection; signerSeeds stays last.
+        const extras = a[11] && ts.isObjectLiteralExpression(a[11]) ? a[11] : undefined;
+        const seedsArg = extras ? a[12] : a[11];
+        if (a.length < 11 || a.length > (extras ? 13 : 12))
+            this.fail(node, usage);
         const [metadata, mint, mintAuth, payer, updateAuth, sys] = a.slice(0, 6).map((n, i) => this.accountParam(n, `account #${i + 1}`));
         if (!isWritable(metadata.kind))
             this.fail(a[0], "the metadata account must be Mut<AccountInfo>");
@@ -483,11 +578,82 @@ export class CpiEmitter extends CallEmitter {
             this.fail(a[3], "the payer must be a Mut<Signer>");
         if (sys.kind.kind !== "system")
             this.fail(a[5], "pass the SystemProgram parameter");
-        const [name, symbol, uri] = a.slice(6, 9).map((n) => this.expect(this.expr(n, STRING), STRING, n).c);
-        const fee = this.expect(this.expr(a[9], { kind: "int", name: "u16" }), { kind: "int", name: "u16" }, a[9]);
-        const mutable = this.expect(this.expr(a[10], BOOL), BOOL, a[10]);
-        const seeds = this.signerSeeds(a[11], mintAuth, a[2]);
-        this.line(`TS_TRY(ts_mpl_create_v3(params, a_${program.name}, a_${metadata.name}, a_${mint.name}, a_${mintAuth.name}, a_${payer.name}, a_${updateAuth.name}, a_${sys.name}, ${name}, ${symbol}, ${uri}, ${fee.c}, ${mutable.c}, ${seeds.name}, ${seeds.count}));`);
+        // Arguments in source order, as JS evaluates them: a later one that runs statements (a helper changing account
+        // text) must not change what an earlier one read.
+        const vals = [];
+        const inOrder = (n, t) => {
+            const mark = this.lines.length;
+            const v = this.expect(this.expr(n, t), t, n);
+            for (let j = 0; j < vals.length; j++)
+                vals[j] = this.settle(vals[j], mark);
+            vals.push(v);
+            return vals.length - 1;
+        };
+        const slots = [...a.slice(6, 9).map((n) => inOrder(n, STRING)), inOrder(a[9], { kind: "int", name: "u16" }), inOrder(a[10], BOOL)];
+        const settleAll = (mark) => {
+            for (let j = 0; j < vals.length; j++)
+                vals[j] = this.settle(vals[j], mark);
+        };
+        const extrasMark = this.lines.length;
+        let creators = "NULL";
+        let ncreators = "-1";
+        let collection = "NULL";
+        if (extras) {
+            for (const p of extras.properties) {
+                if (!ts.isPropertyAssignment(p) || !ts.isIdentifier(p.name))
+                    this.fail(p, "use creators: [...] and collection: key");
+                if (p.name.text === "creators") {
+                    if (!ts.isArrayLiteralExpression(p.initializer))
+                        this.fail(p.initializer, "creators: [{ address, verified, share }, …] (an array literal)");
+                    const list = p.initializer.elements;
+                    if (list.length < 1 || list.length > 5)
+                        this.fail(p.initializer, "Metaplex takes 1 to 5 creators");
+                    const buf = this.tmp("creators");
+                    this.line(`uint8_t ${buf}[${34 * list.length}];`);
+                    let shares = 0n;
+                    let constant = true;
+                    list.forEach((el, i) => {
+                        if (!ts.isObjectLiteralExpression(el))
+                            this.fail(el, "a creator is { address, verified, share }");
+                        const field = (k) => {
+                            const q = el.properties.find((x) => ts.isPropertyAssignment(x) && ts.isIdentifier(x.name) && x.name.text === k);
+                            const sh = el.properties.find((x) => ts.isShorthandPropertyAssignment(x) && x.name.text === k);
+                            if (!q && !sh)
+                                this.fail(el, `a creator needs ${k}`);
+                            return q ? q.initializer : sh.name;
+                        };
+                        const at = 34 * i;
+                        const key = this.expect(this.expr(field("address"), PUBKEY), PUBKEY, el);
+                        this.line(`ts_memcpy(${buf} + ${at}, ${key.c}, 32);`);
+                        const verified = this.expect(this.expr(field("verified"), BOOL), BOOL, el);
+                        this.line(`${buf}[${at + 32}] = (${verified.c}) ? 1 : 0;`);
+                        const shareNode = field("share");
+                        if (ts.isBigIntLiteral(shareNode))
+                            shares += BigInt(shareNode.text.slice(0, -1));
+                        else
+                            constant = false;
+                        const share = this.expect(this.expr(shareNode, U8), U8, el);
+                        this.line(`${buf}[${at + 33}] = (uint8_t)(${share.c});`);
+                    });
+                    if (constant && shares !== 100n)
+                        this.fail(p.initializer, `creator shares add up to ${shares}; Metaplex requires 100`);
+                    creators = buf;
+                    ncreators = String(list.length);
+                }
+                else if (p.name.text === "collection") {
+                    const key = this.expect(this.expr(p.initializer, PUBKEY), PUBKEY, p.initializer);
+                    const t = this.tmp("coll");
+                    this.line(`SolPubkey ${t} = *(${key.c});`);
+                    collection = `&${t}`;
+                }
+                else
+                    this.fail(p.name, `createV3 extras are creators and collection, not ${p.name.text}`);
+            }
+        }
+        const seeds = this.signerSeeds(seedsArg, mintAuth, a[2]);
+        settleAll(extrasMark);
+        const [name, symbol, uri, fee, mutable] = slots.map((i) => vals[i]);
+        this.line(`TS_TRY(ts_mpl_create_v3(params, a_${program.name}, a_${metadata.name}, a_${mint.name}, a_${mintAuth.name}, a_${payer.name}, a_${updateAuth.name}, a_${sys.name}, ${name.c}, ${symbol.c}, ${uri.c}, ${fee.c}, ${mutable.c}, ${creators}, ${ncreators}, ${collection}, ${seeds.name}, ${seeds.count}));`);
         return undefined;
     }
     /**
@@ -914,9 +1080,22 @@ export class CpiEmitter extends CallEmitter {
         e.variants.forEach((v, i) => {
             this.line(`case ${i}: {`);
             for (const f of v.fields) {
+                const at = `${src.lv}.v.${v.name}.${f.name}`;
+                if (f.type.kind === "string") {
+                    // Borsh String: u32 length, then the bytes.
+                    const n = this.tmp("sl");
+                    this.line(`uint32_t ${n} = (uint32_t)${at}.len;`);
+                    put(`&${n}`, "4");
+                    put(`${at}.ptr`, `${at}.len`);
+                    continue;
+                }
+                if (f.type.kind === "dataEnum" && this.model.dataEnums.get(f.type.name)?.variable) {
+                    this.serializeDataEnumLv(at, f.type.name, put);
+                    continue;
+                }
                 const n = this.fieldBytes(f.type);
                 // put() with no static size: the payload differs by variant.
-                put(`&${src.lv}.v.${v.name}.${f.name}`, String(n));
+                put(`&${at}`, String(n));
             }
             this.line(`break; }`);
         });

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

@@ -23,6 +23,17 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
     protected textOfInt(name: IntName, c: string, out: string): string;
     /** `c ? a : b` on values: only the chosen branch runs (its checks and side effects included). */
     protected conditional(node: ts.ConditionalExpression, hint?: ValueType): Value;
+    /**
+     * `a ?? b` on an Option: a's value when it has one, else b, which runs only then (as in JS). The result is an
+     * Option itself when b can be null.
+     */
+    protected nullish(node: ts.BinaryExpression, hint?: ValueType): Value;
+    /**
+     * `a ** b` on integers, every multiplication checked (5100 on overflow, like `*`). A literal exponent unrolls by
+     * squaring at compile time; otherwise a square-and-multiply loop runs, squaring only while bits remain (a square
+     * that overflows then would make the result overflow too). A negative exponent aborts, as JS throws a RangeError.
+     */
+    protected power(node: ts.BinaryExpression, hint?: ValueType): Value;
     protected binary(node: ts.BinaryExpression, hint?: ValueType): Value;
     /** Checked integer arithmetic into a fresh temporary. */
     protected arith(op: ts.BinaryOperator, left: Value, right: Value, node: ts.Node): Value;

package/dist/compiler/emit/expressions.js

@@ -62,6 +62,13 @@ export class ExpressionEmitter extends StorageEmitter {
     expr(node, hint) {
         if (ts.isParenthesizedExpression(node))
             return this.expr(node.expression, hint);
+        // `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);
+            if (v.type.kind !== "option")
+                this.fail(node, "! works on Option values; check optional accounts with `x !== null`");
+            return this.unwrap(v, node);
+        }
         this.noOptionalChain(node);
         if (ts.isBigIntLiteral(node)) {
             const value = BigInt(node.text.slice(0, -1).replace(/_/g, ""));
@@ -406,9 +413,10 @@ export class ExpressionEmitter extends StorageEmitter {
             (ts.isBigIntLiteral(node.whenFalse) || ts.isPrefixUnaryExpression(node.whenFalse));
         if (!type && !bothLiteral && (ts.isBigIntLiteral(node.whenTrue) || node.whenTrue.kind === ts.SyntaxKind.NullKeyword)) {
             // Type the non-literal branch first, without emitting it, to give the literal its type.
-            const saved = { lines: this.lines.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
+            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(node.whenFalse));
             this.lines.length = saved.lines;
+            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
             this.temp = saved.temp;
             this.reporter.diagnostics.length = saved.diagnostics;
             if (probe && probe.literal === undefined && !probe.isNull)
@@ -434,11 +442,108 @@ export class ExpressionEmitter extends StorageEmitter {
         this.lines[declAt] = this.lines[declAt].replace(`/* ${t} */`, `${vt.kind === "pubkey" ? "SolPubkey" : valueC(vt)} ${t};`);
         return vt.kind === "pubkey" ? { c: `(&${t})`, type: vt } : { c: t, type: vt };
     }
+    /**
+     * `a ?? b` on an Option: a's value when it has one, else b, which runs only then (as in JS). The result is an
+     * Option itself when b can be null.
+     */
+    nullish(node, hint) {
+        const left = this.expr(node.left, hint?.kind === "option" ? hint : hint ? { kind: "option", inner: hint } : undefined);
+        if (left.isNull)
+            return this.expect(this.expr(node.right, hint), hint, node.right);
+        if (left.type.kind !== "option")
+            return left; // never null: JS never evaluates b
+        const inner = left.type.inner;
+        if (inner.kind === "struct")
+            this.fail(node, "?? works on Options of integers, booleans and Pubkeys");
+        const nullable = (t) => !!(t.flags & ts.TypeFlags.Null) || (t.isUnion() && t.types.some(nullable));
+        const type = hint ?? (nullable(this.checker.getTypeAtLocation(node)) ? left.type : inner);
+        const lo = this.tmp("opt");
+        this.line(`${optC(inner)} ${lo} = ${left.c};`);
+        const t = this.tmp("nn");
+        this.line(`${type.kind === "pubkey" ? "SolPubkey" : valueC(type)} ${t};`);
+        const set = (v) => this.line(v.type.kind === "pubkey" ? `${t} = *(${v.c});` : `${t} = ${v.c};`);
+        this.line(`if (${lo}.some) {`);
+        this.block(() => {
+            const some = inner.kind === "pubkey"
+                ? { c: `(&${lo}.v)`, type: inner }
+                : inner.kind === "bool"
+                    ? { c: `(${lo}.v != 0)`, type: inner }
+                    : { c: `${lo}.v`, type: inner };
+            set(this.expect(some, type, node.left));
+        });
+        this.line(`} else {`);
+        this.block(() => set(this.expect(this.expr(node.right, type), type, node.right)));
+        this.line(`}`);
+        return type.kind === "pubkey" ? { c: `(&${t})`, type } : { c: t, type };
+    }
+    /**
+     * `a ** b` on integers, every multiplication checked (5100 on overflow, like `*`). A literal exponent unrolls by
+     * squaring at compile time; otherwise a square-and-multiply loop runs, squaring only while bits remain (a square
+     * that overflows then would make the result overflow too). A negative exponent aborts, as JS throws a RangeError.
+     */
+    power(node, hint) {
+        let base = this.expr(node.left, hint?.kind === "int" ? hint : undefined);
+        const mark = this.lines.length;
+        const exp = this.expr(node.right);
+        // JS reads the base first: if the exponent ran statements (a helper that changes it), use the value read before.
+        base = this.settle(base, mark);
+        if (base.literal !== undefined)
+            base = this.literal(base.literal, hint?.kind === "int" ? hint : U64, node.left);
+        if (base.type.kind !== "int")
+            this.fail(node.left, "** needs an integer base");
+        const type = base.type;
+        const ct = INT_INFO[type.name].c;
+        const K = ts.SyntaxKind;
+        if (exp.literal !== undefined) {
+            if (exp.literal < 0n)
+                this.fail(node.right, "the exponent of ** cannot be negative");
+            if (exp.literal > 255n)
+                this.fail(node.right, "the exponent of ** must be at most 255 when it is a literal (larger ones always overflow unless the base is 0 or 1)");
+            const n = exp.literal;
+            if (n === 0n)
+                return this.literal(1n, type, node);
+            // Bits from high to low: square, then multiply by the base when the bit is set.
+            const b = this.tmp("pb");
+            this.line(`${ct} ${b} = ${base.c};`);
+            let acc = { c: b, type };
+            const bits = n.toString(2);
+            for (const bit of bits.slice(1)) {
+                acc = this.arith(K.AsteriskToken, acc, acc, node);
+                if (bit === "1")
+                    acc = this.arith(K.AsteriskToken, acc, { c: b, type }, node);
+            }
+            return acc;
+        }
+        if (exp.type.kind !== "int")
+            this.fail(node.right, "the exponent of ** must be an integer");
+        const r = this.tmp("pr");
+        const sq = this.tmp("ps");
+        const e = this.tmp("pe");
+        this.line(`${ct} ${r} = 1;`);
+        this.line(`${ct} ${sq} = ${base.c};`);
+        if (INT_INFO[exp.type.name].signed)
+            this.line(`if (${exp.c} < 0) TS_FAIL(TS_ERR_OVERFLOW, "TypeSOL: negative exponent");`);
+        this.line(`${INT_INFO[exp.type.name].bytes === 16 ? "unsigned __int128" : "uint64_t"} ${e} = (${INT_INFO[exp.type.name].bytes === 16 ? "unsigned __int128" : "uint64_t"})(${exp.c});`);
+        this.line(`while (${e}) {`);
+        this.block(() => {
+            this.line(`if (${e} & 1) {`);
+            this.block(() => this.line(`${r} = ${this.arith(K.AsteriskToken, { c: r, type }, { c: sq, type }, node).c};`));
+            this.line(`}`);
+            this.line(`${e} >>= 1;`);
+            this.line(`if (${e}) {`);
+            this.block(() => this.line(`${sq} = ${this.arith(K.AsteriskToken, { c: sq, type }, { c: sq, type }, node).c};`));
+            this.line(`}`);
+        });
+        this.line(`}`);
+        return { c: r, type };
+    }
     binary(node, hint) {
         const op = node.operatorToken.kind;
         const K = ts.SyntaxKind;
         if (op === K.AsteriskAsteriskToken)
-            this.fail(node.operatorToken, "** is not supported; multiply, or use mulDiv/isqrt");
+            return this.power(node, hint);
+        if (op === K.QuestionQuestionToken)
+            return this.nullish(node, hint);
         if (op === K.AmpersandAmpersandToken || op === K.BarBarToken) {
             const left = this.expect(this.expr(node.left, BOOL), BOOL, node.left);
             const t = this.tmp();

package/dist/compiler/emit/function.js

@@ -224,8 +224,18 @@ export class FunctionEmitter extends StatementEmitter {
                 e.variants.forEach((variant, i) => {
                     head.push(`  case ${i}: {`);
                     for (const f of variant.fields) {
+                        if (f.type.kind === "string") {
+                            // Borsh String: u32 length, then UTF-8 bytes, kept as a view of the instruction data.
+                            const lv = `${v}.v.${variant.name}.${f.name}`;
+                            head.push(`    if (params->data_len < off + 4) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
+                            head.push(`    { uint32_t n = (uint32_t)ts_read_le(params->data + off, 4); off += 4;`);
+                            head.push(`      if (params->data_len < off + n) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: instruction data too short");`);
+                            head.push(`      ${lv} = ts_str(params->data + off, n); off += n; }`);
+                            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))
-                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys and enums`);
+                            this.reporter.fail(a.node, `${e.name}.${variant.name}.${f.name}: enum arguments carry integers, booleans, Pubkeys, enums and strings`);
                         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};`);

package/dist/compiler/emit/shared.js

@@ -119,7 +119,8 @@ export function storageDecl(t, name) {
             return `uint32_t ${name}__len;
   ${storageDecl(t.elem, `${name}[]`)}`;
         case "string":
-            throw new Error("unreachable: variable strings are not stored");
+            // Only in a variable data enum's payload (arguments, events, locals): a view of the text.
+            return `TS_Str ${name}`;
     }
 }
 /** Why an account of kind `have` cannot be passed where a helper takes `want`, or undefined when it can. */
@@ -186,6 +187,6 @@ export function helperSignature(h) {
             params.push(`${valueC(p.type)} p_${p.name}`);
     }
     if (h.returns)
-        params.push(`${scalarC(h.returns)} *ret`);
+        params.push(h.returns.kind === "struct" ? `TSS_${h.returns.name} *ret` : `${scalarC(h.returns)} *ret`);
     return `static uint64_t fn_${h.name}(${params.join(", ")})`;
 }

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

@@ -10,6 +10,14 @@ export declare abstract class StatementEmitter extends CpiEmitter {
     /** `switch` on integers, enums and `.kind` of data enums: a C switch, with JS fallthrough/break semantics. */
     protected switchStatement(stmt: ts.SwitchStatement): void;
     protected forLoop(stmt: ts.ForStatement): void;
+    /**
+     * `for (const x of list)` over a Vec or FixedArray: an index loop that binds `x` as `const x = list.get(i)` would,
+     * so elements are values (scalars, strings) or references into the data (structs), with the same aliasing rules.
+     * 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;
+    /** Whether `e` is the remaining accounts (or a const bound to them). */
+    protected isRemaining(e: ts.Expression): boolean;
     /**
      * `while (1) { cond; if (!cond) break; body; continue_label: step }`. The condition is lowered
      * inside the loop so its checked-arithmetic temporaries are recomputed every iteration.
@@ -17,6 +25,11 @@ export declare abstract class StatementEmitter extends CpiEmitter {
     protected loop(cond: ts.Expression | undefined, body: ts.Statement, step: ts.Expression | undefined): void;
     protected body(stmt: ts.Statement): void;
     protected variable(list: ts.VariableDeclarationList, topLevel?: boolean): void;
+    /**
+     * `const { a, b: c } = s`: one declaration per name, `const a = s.a`, in source order. The source must be a name or
+     * a field path (no calls), so reading it once per name reads the same thing JS reads once.
+     */
+    protected destructure(list: ts.VariableDeclarationList, d: ts.VariableDeclaration, pattern: ts.ObjectBindingPattern, init: ts.Expression, topLevel: boolean): void;
     protected expressionStatement(e: ts.Expression, topLevel: boolean): void;
     protected assign(target: ts.Expression, valueNode: ts.Expression, op?: ts.BinaryOperator, topLevel?: boolean): void;
     /** Whether a place goes through a Vec element (`v.get(i).x`, `v.get(i)`). */