@typesol/cli 0.17.0 → 0.18.0

package/dist/compiler/emit/base.js

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

package/dist/compiler/emit/borsh.js

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

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

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

package/dist/compiler/emit/calls.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType } from "../analyze.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, INT_NAMES, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
 import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, } from "./shared.js";
@@ -7,6 +7,8 @@ import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
  */
+/** List methods taking a callback (or a value) that expand into a loop. */
+const LIST_METHODS = new Set(["forEach", "some", "every", "find", "findIndex", "reduce", "includes", "indexOf"]);
 export class CallEmitter extends ExpressionEmitter {
     call(node, topLevel) {
         const callee = node.expression;
@@ -126,14 +128,26 @@ export class CallEmitter extends ExpressionEmitter {
             }
             case "mulDiv":
             case "mulDivCeil": {
-                // a * b / c with a 128-bit intermediate (u64), rounding down or up; aborts if the result does not fit.
+                // a * b / c with a double-width intermediate (128-bit for u64, 256-bit for u128), rounding down or up;
+                // aborts if the result does not fit. All three are u64, or all u128 (literals take the others' type).
                 if (args.length !== 3)
-                    this.fail(node, `${builtin}(a, b, c) takes three u64 values`);
-                const [x, y, z] = this.lowerInOrder(args, [U64, U64, U64]);
+                    this.fail(node, `${builtin}(a, b, c) takes three u64 or three u128 values`);
+                const vals = [];
+                for (const a of args) {
+                    const mark = this.lines.length;
+                    const v = this.expr(a);
+                    for (let j = 0; j < vals.length; j++)
+                        vals[j] = this.settle(vals[j], mark);
+                    vals.push(v);
+                }
+                const typed = vals.find((v) => v.literal === undefined);
+                const wide = typed?.type.kind === "int" && typed.type.name === "u128";
+                const ty = wide ? { kind: "int", name: "u128" } : U64;
+                const [x, y, z] = vals.map((v, i) => this.expect(v.literal !== undefined ? this.literal(v.literal, ty, args[i]) : v, ty, args[i]));
                 const t = this.tmp("md");
-                this.line(`uint64_t ${t};`);
-                this.line(`TS_TRY(ts_mul_div(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
-                return { c: t, type: U64 };
+                this.line(`${wide ? "unsigned __int128" : "uint64_t"} ${t};`);
+                this.line(`TS_TRY(ts_mul_div${wide ? "_u128" : ""}(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
+                return { c: t, type: ty };
             }
             case "isqrt": {
                 if (args.length !== 1)
@@ -219,7 +233,18 @@ export class CallEmitter extends ExpressionEmitter {
                 this.line(`TS_TRY(ts_t22_transfer_fee(${m}, ${amt.c}, &${t}));`);
                 return { c: t, type: U64 };
             }
+            case "isTransferring": {
+                // TransferHookAccount (15) on a Token-2022 token account: set only while Token-2022 runs a transfer of it.
+                if (args.length !== 1)
+                    this.fail(node, "isTransferring(tokenAccount) takes the source token account");
+                const m = this.anyAccount(args[0], "the token account");
+                this.line(`TS_TRY(ts_t22_layout(${m}, 2));`);
+                const off = this.tmp("eo");
+                this.line(`uint64_t ${off}, ${off}l;`);
+                return { c: `(ts_t22_ext(${m}, 15, &${off}, &${off}l) && ${off}l >= 1 && ${m}->data[${off}] != 0)`, type: BOOL };
+            }
             case "transferHookProgram":
+            case "transferHookAuthority":
             case "permanentDelegate":
             case "mintCloseAuthority": {
                 // Token-2022 mint extensions holding an optional Pubkey: TransferHook (14, program at +32),
@@ -228,7 +253,7 @@ export class CallEmitter extends ExpressionEmitter {
                     this.fail(node, `${builtin}(mint) takes the mint`);
                 const m = this.anyAccount(args[0], "the mint");
                 this.line(`TS_TRY(ts_t22_layout(${m}, 1));`);
-                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
+                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "transferHookAuthority" ? [14, 0] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
                 this.model.options.set("pubkey", PUBKEY);
                 const t = this.tmp("ext");
                 this.line(`${optC(PUBKEY)} ${t};`);
@@ -434,11 +459,22 @@ export class CallEmitter extends ExpressionEmitter {
         }
         if (builtin)
             this.fail(callee, `${builtin} cannot be called here`);
+        if (ts.isIdentifier(callee)) {
+            const local = this.lookup(callee.text);
+            if (local?.closure)
+                return this.expandClosure(local.closure, node.arguments, node);
+        }
         const helper = this.helperOf(node);
         if (helper)
             return this.callHelper(node, helper);
         if (ts.isPropertyAccessExpression(callee)) {
             const method = callee.name.text;
+            // xs.some(…) and friends on a Vec, FixedArray, FixedVec or Vec argument: a loop with the callback expanded in it.
+            if (LIST_METHODS.has(method)) {
+                const l = ts.isIdentifier(callee.expression) ? this.lookup(callee.expression.text) : undefined;
+                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(callee.expression))
+                    return this.listMethod(node, method);
+            }
             // Vec<T> instruction arguments are read-only views.
             if (ts.isIdentifier(callee.expression)) {
                 const l = this.lookup(callee.expression.text);
@@ -446,6 +482,10 @@ export class CallEmitter extends ExpressionEmitter {
                     if (method !== "get" || args.length !== 1)
                         this.fail(node, "Vec arguments are read-only: use .get(i) and .length");
                     const elem = l.type.elem;
+                    if (elem.kind === "string") {
+                        const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
+                        return { c: `(((const TS_Str *)${l.c}.ptr)[${idx}])`, type: STRING };
+                    }
                     if (!isScalar(elem))
                         this.fail(node, `read a field of the element: ${callee.expression.text}.get(i).field`);
                     const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
@@ -506,8 +546,10 @@ export class CallEmitter extends ExpressionEmitter {
                 // Program accounts used through their methods (systemProgram.transfer, tokenProgram.*…) may be optional.
                 if (target?.optional)
                     this.assertUsable(target, callee.expression);
-                if (target?.kind.kind === "token" && target.kind.init && method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
-                    return this.createAta(node, target, topLevel);
+                if ((target?.kind.kind === "token" || target?.kind.kind === "mint") &&
+                    target.kind.init &&
+                    method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
+                    return target.kind.kind === "token" && target.constraints.ata ? this.createAta(node, target, topLevel) : this.createToken(node, target, topLevel);
                 if (target?.kind.kind === "init" && method === "create")
                     return this.create(node, target, topLevel);
                 if (target?.kind.kind === "initIfNeeded" && method === "createIfNeeded")
@@ -574,7 +616,7 @@ export class CallEmitter extends ExpressionEmitter {
             if (info.cap !== undefined)
                 return; // a FixedVec has its room already
             if (!info.resizable || !v.account)
-                this.fail(node, "only Vecs of declared Mut<...> / Init<...> accounts can grow or shrink");
+                this.fail(node, "only Vecs of Mut<...> / Init<...> accounts can grow or shrink");
             this.line(`TS_TRY(ts_resize(params, ${payer}, a_${v.account.name}, 8 + ${info.fixed} + (${newLen}) * ${info.elemSize}, entry_${v.account.name}));`);
         };
         switch (method) {
@@ -899,8 +941,37 @@ export class CallEmitter extends ExpressionEmitter {
         }
         return { c: `((TSS_${s.name} *)(${h}->data + 8))`, type: { kind: "structRef", struct: s.name, writable: mut } };
     }
+    /** Whether a helper (or one it calls) grows a Vec, which needs the instruction's SystemProgram for rent. */
+    helperGrows(body, seen = new Set()) {
+        if (seen.has(body))
+            return false;
+        seen.add(body);
+        let found = false;
+        const visit = (n) => {
+            if (found)
+                return;
+            if (ts.isCallExpression(n)) {
+                // Vec.push(value, payer) grows the account; FixedVec.push(value) does not.
+                if (ts.isPropertyAccessExpression(n.expression) && n.expression.name.text === "push" && n.arguments.length === 2)
+                    found = true;
+                else if (ts.isIdentifier(n.expression)) {
+                    const name = calleeName(n.expression, this.model.helperDecls, this.checker);
+                    const callee = name ? (this.model.generics.get(name)?.node ?? this.model.helpers.get(name)?.node) : undefined;
+                    if (callee && this.helperGrows(callee, seen))
+                        found = true;
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(body);
+        return found;
+    }
     callHelper(node, h) {
-        if (node.arguments.length !== h.params.length)
+        if (this.ix && !this.ix.accounts.some((a) => a.kind.kind === "system" && !a.optional) && h.params.some((p) => p.account) && this.helperGrows(h.node))
+            this.fail(node, `${h.display}() grows a Vec (push): the instruction needs a SystemProgram parameter to top up rent`);
+        // Function arguments were bound when the helper was instantiated: they have no C parameter.
+        const argNodes = h.fnArgIndexes ? node.arguments.filter((_, i) => !h.fnArgIndexes.includes(i)) : node.arguments;
+        if (argNodes.length !== h.params.length)
             this.fail(node, `${h.display}() takes ${h.params.length} argument(s)`);
         // Arguments are evaluated left to right: settle earlier ones when a later one runs statements.
         // A helper that takes accounts may change account data, so account text it gets is copied first.
@@ -908,7 +979,7 @@ export class CallEmitter extends ExpressionEmitter {
         const values = [];
         const pieces = [];
         h.params.forEach((p, i) => {
-            const n = node.arguments[i];
+            const n = argNodes[i];
             const mark = this.lines.length;
             const raw = this.helperArg(h, p, n);
             for (let j = 0; j < values.length; j++)
@@ -922,8 +993,8 @@ export class CallEmitter extends ExpressionEmitter {
         });
         // A helper that takes a writable struct account may replace anything stored in it (see assertNotAliased).
         for (const [i, p] of h.params.entries())
-            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(node.arguments[i]))
-                this.assertNotAliased([node.arguments[i].text], node, h.display);
+            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(argNodes[i]))
+                this.assertNotAliased([argNodes[i].text], node, h.display);
         const args = ["params", ...pieces.map((x) => (typeof x === "number" ? (values[x].type.kind === "pubkey" ? `*(${values[x].c})` : values[x].c) : x))];
         if (!h.returns) {
             this.line(`TS_TRY(fn_${h.name}(${args.join(", ")}));`);
@@ -937,6 +1008,11 @@ export class CallEmitter extends ExpressionEmitter {
             this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
             return { c: `(&${t})`, type: { kind: "structRef", struct: h.returns.name, writable: true } };
         }
+        if (h.returns.kind === "string") {
+            this.line(`TS_Str ${t};`);
+            this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
+            return { c: t, type: STRING };
+        }
         this.line(`${scalarC(h.returns)} ${t};`);
         this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
         return h.returns.kind === "pubkey" ? { c: `(&${t})`, type: h.returns } : { c: t, type: h.returns };
@@ -951,6 +1027,8 @@ export class CallEmitter extends ExpressionEmitter {
             // A @layout borsh account goes with the struct it is being worked on as.
             if (p.account.kind === "account" && p.account.struct.layout === "borsh")
                 return `a_${acct.name}, d_${acct.name}`;
+            if (p.account.kind === "account" && p.account.mut && p.account.struct.vec)
+                return `a_${acct.name}, entry_${acct.name}`;
             return `a_${acct.name}`;
         }
         switch (p.type.kind) {

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

@@ -26,6 +26,25 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected describeSeed(el: ts.Expression): IdlSeed | undefined;
     protected recordPda(account: AccountParam, idl: IdlSeed[] | undefined): void;
     protected create(node: ts.CallExpression, target: AccountParam, topLevel: boolean, ifNeeded?: boolean): Value;
+    /**
+     * `vault.create(payer, seeds | null, mint, authority)` on `Init<TokenAccount>` and `mint.create(payer, seeds | null,
+     * decimals, authority, freezeAuthority | null)` on `Init<Mint>` (Anchor's `init` with `token::` / `mint::`
+     * constraints): a PDA of this program (or, with `null`, a new keypair account that signs), created owned by the
+     * instruction's token program and initialized. `createIfNeeded` on `InitIfNeeded<…>` does that unless the account
+     * exists, and then checks it is that PDA, owned by the token program, and has that mint and owner / those
+     * authorities and decimals (Anchor's init_if_needed checks). create returns the bump (0 for a keypair),
+     * createIfNeeded whether it created the account.
+     */
+    protected createToken(node: ts.CallExpression, target: AccountParam, topLevel: boolean): Value;
+    /**
+     * The extensions in `mint.create(…, { … })` (Anchor's `extensions::…` constraints): their values are evaluated now,
+     * in source order; the returned lines (each extension's Token-2022 initializer, mint writable, before
+     * InitializeMint2) run after the account is created, sized for exactly these extensions.
+     */
+    protected mintExtensions(lit: ts.ObjectLiteralExpression, tp: string, acct: string): {
+        space: number;
+        lines: string[];
+    };
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`
      * (Anchor's `init` / `init_if_needed` with `associated_token::…`). create always calls the ATA program's Create, which
@@ -47,6 +66,7 @@ export declare abstract class CpiEmitter extends CallEmitter {
     }, tail?: {
         from: string;
         to: string;
+        asPassed?: boolean;
     }): void;
     protected signerSeeds(node: ts.Expression | undefined, authority: AccountParam, at: ts.Node): {
         name: string;
@@ -87,6 +107,12 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected bubblegumOp(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
     /** Bubblegum V2 (trees on mpl-account-compression with mpl-noop; optional Metaplex Core collections). */
     protected bubblegumV2(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
+    /** Object literal properties by name, refusing others. */
+    protected literalProps(o: ts.ObjectLiteralExpression, allowed: string[], what: string): Map<string, ts.Expression>;
+    /** Vec<Creator> (address, verified, share) from a literal list; shares add up to 100 when literal. */
+    protected bubblegumCreators(creators: ts.Expression | undefined): MplField[];
+    /** UpdateArgs: every field optional (left out or null: unchanged). */
+    protected bubblegumUpdateArgs(n: ts.Expression): MplField[];
     /** `acct.key` of an account parameter, as an expression to serialize. */
     protected keyOf(n: ts.Expression): ts.Expression;
     /**
@@ -117,6 +143,10 @@ export declare abstract class CpiEmitter extends CallEmitter {
         authority: string;
         program: string;
     }): undefined;
+    /** emit<T> of a @layout borsh struct: built like account data, then packed as Anchor serializes it. */
+    private emitBorshEvent;
+    /** Discriminator + `body`, logged (emit) or self-invoked (emitCpi). */
+    private sendEvent;
     /** Structs reachable through the fields of struct `name` (not including itself unless it recurses). */
     protected nestedStructs(name: string): Set<string>;
     /** Structs whose IDL description is the fixed layout: account data, arguments, and everything nested in them. */