@typesol/cli 0.22.0 → 0.24.0

package/dist/compiler/emit/calls.js

@@ -1,9 +1,9 @@
 import ts from "typescript";
-import { calleeName, resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType, resolveValueType } from "../analyze.js";
 import { ANCHOR_ERRORS } from "../anchor-errors.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";
+import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, emptySizeC, vecLenCheck, } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
@@ -195,7 +195,7 @@ export class CallEmitter extends ExpressionEmitter {
                 if (!isWritable(acct.kind) || !struct)
                     this.fail(args[0], "realloc needs a Mut<Struct> account of this program");
                 if (struct?.vec)
-                    this.fail(args[0], `${struct.name} ends in a Vec, which sizes the account itself (push/pop/clear)`);
+                    this.fail(args[0], `${struct.name} has a growable Vec, which sizes the account itself (push/pop/clear)`);
                 const size = this.expect(this.expr(args[1], U64), U64, args[1]);
                 const payer = this.accountParam(args[2], "the payer");
                 if (payer.kind.kind !== "signer" || !payer.kind.mut)
@@ -460,11 +460,25 @@ export class CallEmitter extends ExpressionEmitter {
         }
         if (builtin)
             this.fail(callee, `${builtin} cannot be called here`);
+        // `adder(5n)(1n)`: the function a function returns, called right away.
+        if (ts.isCallExpression(callee)) {
+            const made = this.madeFunction(callee);
+            if (made)
+                return this.expandClosure(made, node.arguments, node);
+        }
         if (ts.isIdentifier(callee)) {
             const local = this.lookup(callee.text);
+            if (local?.closure && this.returnedFunction(local.closure.node))
+                this.fail(node, `${callee.text} returns a function: bind it (const f = ${callee.text}(…)) or call it right away (${callee.text}(…)(…))`);
             if (local?.closure)
                 return this.expandClosure(local.closure, node.arguments, node);
+            const name = calleeName(callee, this.model.helperDecls, this.checker) ?? callee.text;
+            if (!local && this.model.factories.has(name))
+                this.fail(node, `${callee.text} returns a function: bind it (const f = ${callee.text}(…)) or call it right away (${callee.text}(…)(…))`);
         }
+        const inlined = this.helperWithClosure(node);
+        if (inlined)
+            return inlined.value;
         const helper = this.helperOf(node);
         if (helper)
             return this.callHelper(node, helper);
@@ -473,9 +487,12 @@ export class CallEmitter extends ExpressionEmitter {
             // 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))
+                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.isPipeline(callee.expression) || this.peekArray(callee.expression))
                     return this.listMethod(node, method);
             }
+            // A map / filter chain is consumed by a list method, `.length` or for…of, or stored: const ys = xs.map(…).
+            if (this.isPipeline(node))
+                this.fail(node, `${method} builds a new list: store it (const ys = xs.${method}(…)), or use it right away with a list method, .length or for…of`);
             // Vec<T> instruction arguments are read-only views.
             if (ts.isIdentifier(callee.expression)) {
                 const l = this.lookup(callee.expression.text);
@@ -620,6 +637,21 @@ export class CallEmitter extends ExpressionEmitter {
                 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}));`);
         };
+        /**
+         * The growable Vecs stored after this one move by `by` bytes (+ grows, - shrinks): where they start and how many
+         * bytes they take, read before the resize; references into them cannot outlive this call.
+         */
+        const tail = info.tail;
+        const tailStart = () => {
+            if (!tail)
+                return undefined;
+            this.assertNotAliased(tail.paths, node);
+            const at = this.tmp("tail");
+            const n = this.tmp("tail_n");
+            this.line(`uint8_t *${at} = ${tail.end};`);
+            this.line(`uint64_t ${n} = (uint64_t)(${tail.dataEnd} - ${at});`);
+            return { at, n };
+        };
         switch (method) {
             case "set": {
                 if (args.length !== 2)
@@ -655,8 +687,11 @@ export class CallEmitter extends ExpressionEmitter {
                 const write = stageElem(args[0]);
                 const n = this.tmp("n");
                 this.line(`uint64_t ${n} = (uint64_t)${info.len};`);
-                // Resizing does not move the data, so element pointers stay valid.
+                const t = tailStart();
+                // Resizing does not move the data, so element pointers stay valid; the Vecs after this one shift up.
                 resize(`${n} + 1`, `a_${payer.name}`);
+                if (t)
+                    this.line(`ts_memmove(${t.at} + ${info.elemSize}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = (uint32_t)(${n} + 1);`);
                 write(elemRef(n));
                 return undefined;
@@ -686,6 +721,9 @@ export class CallEmitter extends ExpressionEmitter {
                         this.line(`${valueC(st)} ${out} = ${val.c};`);
                     result = st.kind === "pubkey" ? { c: `(&${out})`, type: st } : { c: out, type: st };
                 }
+                const t = info.cap === undefined ? tailStart() : undefined;
+                if (t)
+                    this.line(`ts_memmove(${t.at} - ${info.elemSize}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = (uint32_t)(${n} - 1);`);
                 resize(`${n} - 1`, "NULL");
                 return result;
@@ -695,6 +733,9 @@ export class CallEmitter extends ExpressionEmitter {
                     this.fail(node, "clear() takes no arguments");
                 needWritable();
                 this.assertNotAliased(elemPaths(), node);
+                const t = info.cap === undefined ? tailStart() : undefined;
+                if (t)
+                    this.line(`ts_memmove((uint8_t *)${info.items}, ${t.at}, ${t.n});`);
                 this.line(`${info.len} = 0;`);
                 resize("0", "NULL");
                 return undefined;
@@ -933,9 +974,10 @@ export class CallEmitter extends ExpressionEmitter {
         if (this.model.events.has(s.name) && s.fields.some((f) => f.type.kind === "option" || f.type.kind === "dataEnum"))
             this.fail(node, `${s.name} is emitted as an event and has Option or enum fields; declare a separate event struct`);
         this.model.accountStructs.add(s.name);
-        this.line(`TS_TRY(ts_check_program_account(${h}, params->program_id, TS_DISC_${s.name}, sizeof(TSS_${s.name})));`);
+        this.line(`TS_TRY(ts_check_program_account(${h}, params->program_id, TS_DISC_${s.name}, ${emptySizeC(s)}));`);
         if (s.vec)
-            this.line(`TS_TRY(ts_check_vec_len(${h}, sizeof(TSS_${s.name}), ((TSS_${s.name} *)(${h}->data + 8))->${s.vec.name}__len, TS_ELEM_${s.name}));`);
+            for (const l of vecLenCheck(s, h, `((TSS_${s.name} *)(${h}->data + 8))`, ""))
+                this.line(l);
         if (mut) {
             this.line(`TS_TRY(ts_check_writable(${h}));`);
             this.line(`TS_TRY(ts_check_unaliased(params, ${h}));`);
@@ -967,6 +1009,116 @@ export class CallEmitter extends ExpressionEmitter {
         visit(body);
         return found;
     }
+    /**
+     * A helper given a closure (a function that reads the caller's variables) for a function parameter: a closure only
+     * runs where it is declared, so the helper is expanded here, like a closure, with the closure bound to the
+     * parameter. Helpers expanded so take values (not accounts) and have no type parameters.
+     */
+    helperWithClosure(node) {
+        const g = this.givenClosure(node);
+        if (!g)
+            return undefined;
+        // Type parameters: bound from the call (as an instance would be) while the body is expanded.
+        const saved = this.scope;
+        if (g.typeParams.length) {
+            const typeArgs = this.typeArgsOf(node, g);
+            const bound = new Map();
+            const structs = new Map();
+            g.typeParams.forEach((n, i) => {
+                const t = typeArgs[i];
+                if (t.kind === "struct")
+                    structs.set(n, t.name);
+                else
+                    bound.set(n, t);
+            });
+            this.scope = { ...this.scope, typeArgs: bound, structArgs: structs };
+        }
+        try {
+            return { value: this.expandClosure({ node: g.node, name: g.display, scopes: [], env: this.noEnv(), imports: g.imports }, node.arguments, node) };
+        }
+        finally {
+            this.scope = saved;
+        }
+    }
+    /** The function a function returns (`return (x) => x + n`, or an arrow body `(n) => (x) => x + n`), if it returns one. */
+    returnedFunction(fn) {
+        const strip = (e) => (e && ts.isParenthesizedExpression(e) ? strip(e.expression) : e);
+        const body = fn.body;
+        let ret;
+        if (body && !ts.isBlock(body))
+            ret = strip(body);
+        else if (body && body.statements.length === 1 && ts.isReturnStatement(body.statements[0]))
+            ret = strip(body.statements[0].expression);
+        if (ret && (ts.isArrowFunction(ret) || ts.isFunctionExpression(ret)))
+            return ret;
+        if (fn.type && ts.isFunctionTypeNode(fn.type))
+            this.fail(fn, "a function that returns a function has one statement: return (x) => … (the function it makes)");
+        return undefined;
+    }
+    /**
+     * `adder(5n)`, where `adder` returns a function: the arguments are evaluated here into locals of the current block,
+     * and the function it returns is bound to them as a closure (expanded where it is called, like any closure).
+     */
+    madeFunction(call) {
+        if (!ts.isIdentifier(call.expression))
+            return undefined;
+        const local = this.lookup(call.expression.text);
+        let maker = local?.closure;
+        if (!maker && !local) {
+            const name = calleeName(call.expression, this.model.helperDecls, this.checker) ?? call.expression.text;
+            const f = this.model.factories.get(name);
+            if (f)
+                maker = { node: f.node, name: call.expression.text, scopes: [], env: this.noEnv(), imports: f.imports };
+        }
+        if (!maker)
+            return undefined;
+        const made = this.returnedFunction(maker.node);
+        if (!made)
+            return undefined;
+        const fn = maker.node;
+        if (call.arguments.length !== fn.parameters.length)
+            this.fail(call, `${maker.name}() takes ${fn.parameters.length} argument(s)`);
+        const params = new Map();
+        fn.parameters.forEach((p, i) => {
+            if (!ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken)
+                this.fail(p, "parameters are plain names");
+            const arg = call.arguments[i];
+            if (p.type && ts.isFunctionTypeNode(p.type)) {
+                params.set(p.name.text, { c: "", type: BOOL, mutable: false, closure: this.closureOf(arg) });
+                return;
+            }
+            const annotated = p.type ? resolveValueType(p.type, this.scope) : undefined;
+            let v = this.expr(arg, annotated);
+            if (v.literal !== undefined && !annotated)
+                v = this.literal(v.literal, U64, arg);
+            const type = annotated ?? v.type;
+            if (!["int", "bool", "pubkey", "string", "enum", "option"].includes(type.kind))
+                this.fail(arg, `the function made keeps integers, booleans, Pubkeys, strings, enums or Options, not ${typeName(type)}`);
+            v = this.expect(v, type, arg);
+            const c = `l_${p.name.text}_${this.temp++}`;
+            if (type.kind === "pubkey")
+                this.line(`SolPubkey ${c} = *(${v.c});`);
+            else
+                this.line(`${valueC(type)} ${c} = ${this.ownedString(v).c};`);
+            params.set(p.name.text, { c, type, mutable: true });
+        });
+        return { node: made, name: `the function ${maker.name}() made`, scopes: [...maker.scopes, params], env: maker.env, imports: maker.imports };
+    }
+    /** A function given for a function parameter of an expanded helper or closure, as something to expand. */
+    closureOf(arg) {
+        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))
+            return { node: arg, name: "the function passed", scopes: [...this.scopes], env: this.envNow(), imports: this.scope.imports };
+        if (ts.isIdentifier(arg)) {
+            const l = this.lookup(arg.text);
+            if (l?.closure)
+                return l.closure;
+            const name = calleeName(arg, this.model.helperDecls, this.checker) ?? arg.text;
+            const h = this.model.helpers.get(name) ?? this.model.generics.get(name);
+            if (h)
+                return { node: h.node, name: h.display, scopes: [], env: this.noEnv(), imports: h.imports };
+        }
+        this.fail(arg, "pass a function: its name, or an arrow written here");
+    }
     callHelper(node, h) {
         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`);

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

@@ -8,6 +8,9 @@ type MplField = {
 } | {
     value: ts.Expression;
     type: ValueType;
+} | {
+    c: string;
+    n: string;
 };
 /**
  * Other programs: PDAs and seeds, account creation, System/Token/ATA/Metaplex CPIs, generic invoke, Borsh
@@ -102,6 +105,26 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected corePluginList(n: ts.Expression | undefined): MplField[];
     /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
     protected coreOp(node: ts.CallExpression, core: AccountParam, method: string): undefined;
+    /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
+    private coreProps;
+    /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */
+    private coreAuthority;
+    private coreOption;
+    private coreSchema;
+    /** Vec<(HookableLifecycleEvent, ExternalCheckResult)>: `[{ event: "transfer", canReject: true }, …]`. */
+    private coreChecks;
+    /** ExtraAccount: `{ kind: "address", address, isSigner?, isWritable? }` or a preconfigured one (`{ kind: "owner" }`, …). */
+    private coreExtraAccount;
+    /**
+     * ExternalPluginAdapterInitInfo from a literal: `{ kind: "AppData", dataAuthority, schema? }`, `{ kind: "Oracle",
+     * baseAddress, checks, resultsOffset?, baseAddressConfig? }`, `{ kind: "LifecycleHook", hookedProgram, checks,
+     * extraAccounts?, dataAuthority?, schema? }` and the Linked forms (collections); `authority?` is the plugin's own.
+     */
+    protected coreExternalPlugin(n: ts.Expression): MplField[];
+    /** ExternalPluginAdapterKey: `{ kind: "AppData", dataAuthority }`, `{ kind: "Oracle", address }`, `{ kind: "LifecycleHook", address }`, … */
+    protected coreExternalKey(n: ts.Expression): MplField[];
+    /** The data written: Option<Vec<u8>> from a string, a Vec<u8> argument, or null (clears it). */
+    protected coreExternalData(n: ts.Expression): MplField[];
     /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
     protected corePluginType(n: ts.Expression): MplField;
     /** Bubblegum (compressed NFTs on SPL account compression): createTree, mint (MintV1, no collection, no creators). */

package/dist/compiler/emit/cpi.js

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { discriminator, snakeCase } from "../analyze.js";
 import { borshMinSize } from "./borsh.js";
 import { INT_INFO, isScalar, isWritable, optionKey, sameType, scalarSize, typeName, } from "../model.js";
-import { MAX_ACCOUNTS, MAX_SEEDS, MAX_CPI_DATA, MAX_EVENT, U64, U8, BOOL, PUBKEY, STRING, cBytes, isStable, cString, scalarStorageC, optC, valueC, } from "./shared.js";
+import { MAX_ACCOUNTS, MAX_SEEDS, MAX_CPI_DATA, MAX_EVENT, U64, U8, BOOL, PUBKEY, STRING, cBytes, isStable, cString, scalarStorageC, optC, valueC, emptySizeC, fixedVecC, vecCount, } from "./shared.js";
 import { CallEmitter } from "./calls.js";
 /**
  * Bubblegum instructions that replace a leaf: discriminator, accounts in order ([label, writable, signer, optional,
@@ -321,7 +321,7 @@ export class CpiEmitter extends CallEmitter {
         const b = this.tmp("bump");
         // The account's size: the struct's (8 + its fixed size, Anchor's InitSpace for @layout borsh), or Anchor's
         // `space = …` when given, which must hold the struct.
-        const need = `8 + sizeof(TSS_${s.name})`;
+        const need = s.layout === "borsh" ? `8 + sizeof(TSS_${s.name})` : `8 + ${emptySizeC(s)}`;
         let space = need;
         const spaceArg = node.arguments[2];
         if (spaceArg) {
@@ -1526,6 +1526,8 @@ export class CpiEmitter extends CallEmitter {
                 this.line(`static const uint8_t ${name}[${f.bytes.length}] = ${cBytes(f.bytes)};`);
                 put(name, String(f.bytes.length), f.bytes.length);
             }
+            else if ("c" in f)
+                put(f.c, f.n);
             else
                 this.serialize(this.expect(this.expr(f.value, f.type), f.type, f.value), f.value, put);
         }
@@ -1829,8 +1831,237 @@ export class CpiEmitter extends CallEmitter {
                 this.cpi(p, metas, data.buf, data.len, seedsAt(4));
                 return undefined;
             }
+            case "addExternalPlugin":
+            case "removeExternalPlugin":
+            case "writeExternalPluginData": {
+                // Add/RemoveExternalPluginAdapterV1: asset, collection, payer, authority, systemProgram, logWrapper;
+                // WriteExternalPluginAdapterDataV1 has a buffer account (left out: the data is in the instruction) before systemProgram.
+                const write = method === "writeExternalPluginData";
+                const n = write ? 7 : 6;
+                if (a.length !== n && a.length !== n + 1)
+                    this.fail(node, `${method}(asset, collection | null, payer, authority | null, systemProgram, ${method === "addExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
+                const metas = [
+                    this.mplMeta(a[0], core, "the asset", true, false),
+                    this.mplMeta(a[1], core, "the collection", true, false),
+                    this.mplMeta(a[2], core, "the payer", true, true),
+                    this.mplMeta(a[3], core, "the authority", false, true),
+                    ...(write ? [self] : []),
+                    this.mplMeta(a[4], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "addExternalPlugin"
+                    ? this.coreExternalPlugin(a[5])
+                    : write
+                        ? [...this.coreExternalKey(a[5]), ...this.coreExternalData(a[6])]
+                        : this.coreExternalKey(a[5]);
+                const data = this.mplData(node, 1024, [{ bytes: [{ addExternalPlugin: 22, removeExternalPlugin: 24, writeExternalPluginData: 28 }[method]] }, ...body]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
+                return undefined;
+            }
+            case "addCollectionExternalPlugin":
+            case "removeCollectionExternalPlugin":
+            case "writeCollectionExternalPluginData": {
+                // The same on a collection: collection, payer, authority, (buffer,) systemProgram, logWrapper.
+                const write = method === "writeCollectionExternalPluginData";
+                const n = write ? 6 : 5;
+                if (a.length !== n && a.length !== n + 1)
+                    this.fail(node, `${method}(collection, payer, authority | null, systemProgram, ${method === "addCollectionExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
+                const metas = [
+                    this.mplMeta(a[0], core, "the collection", true, false),
+                    this.mplMeta(a[1], core, "the payer", true, true),
+                    this.mplMeta(a[2], core, "the authority", false, true),
+                    ...(write ? [self] : []),
+                    this.mplMeta(a[3], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "addCollectionExternalPlugin"
+                    ? this.coreExternalPlugin(a[4])
+                    : write
+                        ? [...this.coreExternalKey(a[4]), ...this.coreExternalData(a[5])]
+                        : this.coreExternalKey(a[4]);
+                const data = this.mplData(node, 1024, [
+                    { bytes: [{ addCollectionExternalPlugin: 23, removeCollectionExternalPlugin: 25, writeCollectionExternalPluginData: 29 }[method]] },
+                    ...body,
+                ]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
+                return undefined;
+            }
+        }
+        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin, addExternalPlugin, removeExternalPlugin, writeExternalPluginData (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+    }
+    /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
+    coreProps(node, what) {
+        let n = node;
+        while (ts.isParenthesizedExpression(n) || ts.isAsExpression(n) || ts.isSatisfiesExpression(n))
+            n = n.expression;
+        if (!ts.isObjectLiteralExpression(n))
+            this.fail(n, `${what} is an object literal: { kind: "…", … }`);
+        const props = new Map();
+        for (const q of n.properties) {
+            if (ts.isPropertyAssignment(q) && ts.isIdentifier(q.name))
+                props.set(q.name.text, q.initializer);
+            else if (ts.isShorthandPropertyAssignment(q))
+                props.set(q.name.text, q.name);
+            else
+                this.fail(q, "write the fields as name: value");
+        }
+        return props;
+    }
+    /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */
+    coreAuthority(n) {
+        if (ts.isStringLiteral(n)) {
+            const i = ["none", "owner", "updateAuthority"].indexOf(n.text);
+            if (i < 0)
+                this.fail(n, 'an authority is "none", "owner", "updateAuthority" or a Pubkey');
+            return [{ bytes: [i] }];
+        }
+        return [{ bytes: [3] }, { value: n, type: PUBKEY }];
+    }
+    coreOption(n, inner) {
+        return n ? [{ bytes: [1] }, ...inner(n)] : [{ bytes: [0] }];
+    }
+    coreSchema(n) {
+        const i = ts.isStringLiteral(n) ? ["binary", "json", "msgpack"].indexOf(n.text) : -1;
+        if (i < 0)
+            this.fail(n, 'schema is "binary", "json" or "msgpack"');
+        return [{ bytes: [i] }];
+    }
+    /** Vec<(HookableLifecycleEvent, ExternalCheckResult)>: `[{ event: "transfer", canReject: true }, …]`. */
+    coreChecks(n, at) {
+        if (!n || !ts.isArrayLiteralExpression(n))
+            this.fail(n ?? at, 'checks is a list: [{ event: "transfer", canApprove: true, canReject: true }]');
+        const out = [{ bytes: [n.elements.length & 0xff, 0, 0, 0] }];
+        for (const e of n.elements) {
+            const p = this.coreProps(e, "a lifecycle check");
+            const ev = p.get("event");
+            const i = ev && ts.isStringLiteral(ev) ? ["create", "transfer", "burn", "update", "execute"].indexOf(ev.text) : -1;
+            if (i < 0)
+                this.fail(ev ?? e, 'event is "create", "transfer", "burn", "update" or "execute"');
+            let flags = 0;
+            for (const [k, bit] of [
+                ["canListen", 1],
+                ["canApprove", 2],
+                ["canReject", 4],
+            ]) {
+                const v = p.get(k);
+                if (v && v.kind !== ts.SyntaxKind.TrueKeyword && v.kind !== ts.SyntaxKind.FalseKeyword)
+                    this.fail(v, `${k} is true or false`);
+                if (v?.kind === ts.SyntaxKind.TrueKeyword)
+                    flags |= bit;
+            }
+            for (const k of p.keys())
+                if (!["event", "canListen", "canApprove", "canReject"].includes(k))
+                    this.fail(e, `a lifecycle check has event, canListen, canApprove and canReject, not ${k}`);
+            out.push({ bytes: [i, flags, 0, 0, 0] });
+        }
+        return out;
+    }
+    /** ExtraAccount: `{ kind: "address", address, isSigner?, isWritable? }` or a preconfigured one (`{ kind: "owner" }`, …). */
+    coreExtraAccount(n) {
+        const p = this.coreProps(n, "an extra account");
+        const kind = p.get("kind");
+        const kinds = ["program", "collection", "owner", "recipient", "asset", "customPda", "address"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0 || i === 5)
+            this.fail(kind ?? n, 'an extra account is { kind: "address", address } or "program", "collection", "owner", "recipient", "asset"');
+        const flag = (k) => {
+            const v = p.get(k);
+            if (v && v.kind !== ts.SyntaxKind.TrueKeyword && v.kind !== ts.SyntaxKind.FalseKeyword)
+                this.fail(v, `${k} is true or false`);
+            return v?.kind === ts.SyntaxKind.TrueKeyword ? 1 : 0;
+        };
+        if (i === 6) {
+            const addr = p.get("address");
+            if (!addr)
+                this.fail(n, "an address extra account needs address");
+            return [{ bytes: [6] }, { value: addr, type: PUBKEY }, { bytes: [flag("isSigner"), flag("isWritable")] }];
+        }
+        return [{ bytes: [i, flag("isSigner"), flag("isWritable")] }];
+    }
+    /**
+     * ExternalPluginAdapterInitInfo from a literal: `{ kind: "AppData", dataAuthority, schema? }`, `{ kind: "Oracle",
+     * baseAddress, checks, resultsOffset?, baseAddressConfig? }`, `{ kind: "LifecycleHook", hookedProgram, checks,
+     * extraAccounts?, dataAuthority?, schema? }` and the Linked forms (collections); `authority?` is the plugin's own.
+     */
+    coreExternalPlugin(n) {
+        const p = this.coreProps(n, "a Core external plugin");
+        const kind = p.get("kind");
+        const kinds = ["LifecycleHook", "Oracle", "AppData", "LinkedLifecycleHook", "LinkedAppData"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0)
+            this.fail(kind ?? n, `a Core external plugin is ${kinds.join(", ")}`);
+        const allowed = {
+            0: ["hookedProgram", "checks", "extraAccounts", "dataAuthority", "schema"],
+            1: ["baseAddress", "checks", "baseAddressConfig", "resultsOffset"],
+            2: ["dataAuthority", "schema"],
+            3: ["hookedProgram", "checks", "extraAccounts", "dataAuthority", "schema"],
+            4: ["dataAuthority", "schema"],
+        };
+        for (const k of p.keys())
+            if (k !== "kind" && k !== "authority" && !allowed[i].includes(k))
+                this.fail(n, `${kinds[i]} takes ${allowed[i].join(", ")} and authority, not ${k}`);
+        const need = (k) => p.get(k) ?? this.fail(n, `${kinds[i]} needs ${k}`);
+        const auth = this.coreOption(p.get("authority"), (x) => this.coreAuthority(x));
+        const schema = this.coreOption(p.get("schema"), (x) => this.coreSchema(x));
+        if (i === 2 || i === 4)
+            return [{ bytes: [i] }, ...this.coreAuthority(need("dataAuthority")), ...auth, ...schema];
+        if (i === 1) {
+            const offset = p.get("resultsOffset");
+            const off = !offset
+                ? [{ bytes: [0] }]
+                : ts.isStringLiteral(offset) && (offset.text === "none" || offset.text === "anchor")
+                    ? [{ bytes: [1, offset.text === "none" ? 0 : 1] }]
+                    : [{ bytes: [1, 2] }, { value: offset, type: U64 }];
+            return [
+                { bytes: [1] },
+                { value: need("baseAddress"), type: PUBKEY },
+                ...auth,
+                ...this.coreChecks(need("checks"), n),
+                ...this.coreOption(p.get("baseAddressConfig"), (x) => this.coreExtraAccount(x)),
+                ...off,
+            ];
+        }
+        const extras = p.get("extraAccounts");
+        if (extras && !ts.isArrayLiteralExpression(extras))
+            this.fail(extras, "extraAccounts is a list of extra accounts");
+        return [
+            { bytes: [i] },
+            { value: need("hookedProgram"), type: PUBKEY },
+            ...auth,
+            ...this.coreChecks(need("checks"), n),
+            ...(extras ? [{ bytes: [1, extras.elements.length & 0xff, 0, 0, 0] }, ...extras.elements.flatMap((e) => this.coreExtraAccount(e))] : [{ bytes: [0] }]),
+            ...this.coreOption(p.get("dataAuthority"), (x) => this.coreAuthority(x)),
+            ...schema,
+        ];
+    }
+    /** ExternalPluginAdapterKey: `{ kind: "AppData", dataAuthority }`, `{ kind: "Oracle", address }`, `{ kind: "LifecycleHook", address }`, … */
+    coreExternalKey(n) {
+        const p = this.coreProps(n, "a Core external plugin key");
+        const kind = p.get("kind");
+        const kinds = ["LifecycleHook", "Oracle", "AppData", "LinkedLifecycleHook", "LinkedAppData"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0)
+            this.fail(kind ?? n, `a Core external plugin key is ${kinds.join(", ")}`);
+        if (i === 2 || i === 4)
+            return [{ bytes: [i] }, ...this.coreAuthority(p.get("dataAuthority") ?? this.fail(n, `${kinds[i]}'s key is its dataAuthority`))];
+        return [
+            { bytes: [i] },
+            { value: p.get("address") ?? this.fail(n, `${kinds[i]}'s key is its address (the oracle's base address or the hooked program)`), type: PUBKEY },
+        ];
+    }
+    /** The data written: Option<Vec<u8>> from a string, a Vec<u8> argument, or null (clears it). */
+    coreExternalData(n) {
+        if (n.kind === ts.SyntaxKind.NullKeyword)
+            return [{ bytes: [0] }];
+        const l = ts.isIdentifier(n) ? this.lookup(n.text) : undefined;
+        if (l?.type.kind === "vecArg") {
+            if (l.type.elem.kind !== "int" || l.type.elem.name !== "u8")
+                this.fail(n, "data is a string, a Vec<u8> argument or null");
+            const t = this.tmp("dl");
+            this.line(`uint32_t ${t} = (uint32_t)${l.c}.len;`);
+            return [{ bytes: [1] }, { c: `&${t}`, n: "4" }, { c: `${l.c}.ptr`, n: `(uint64_t)${t}` }];
         }
-        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+        return [{ bytes: [1] }, { value: n, type: STRING }];
     }
     /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
     corePluginType(n) {
@@ -2642,8 +2873,46 @@ export class CpiEmitter extends CallEmitter {
                 this.fail(obj, `missing field "${f.name}" of ${s.name}`);
         for (const [name, e] of given) {
             const f = s.fields.find((x) => x.name === name);
-            if (f.type.kind === "vec")
-                this.fail(obj, "Vec fields are not supported in events yet");
+            if (f.type.kind === "vec" && f.type.cap !== undefined) {
+                // A FixedVec keeps its fixed layout, as in account data: u32 length, then room for N elements.
+                const ft = f.type;
+                const t = this.tmp("evv");
+                this.line(`${fixedVecC(ft)} ${t};`);
+                this.line(`ts_memzero(&${t}, sizeof(${t}));`);
+                this.writeAggregate({ lv: t, type: ft, writable: true }, e);
+                const n = this.fieldBytes(ft);
+                staged.set(name, (put) => put(`&${t}`, String(n), n));
+                continue;
+            }
+            if (f.type.kind === "vec") {
+                // A Vec is Borsh: u32 length, then the elements, read from a Vec argument or account data when emitted.
+                const l = ts.isIdentifier(e) ? this.lookup(e.text) : undefined;
+                const r = l?.type.kind === "vecArg" ? undefined : this.ref(e);
+                const elemSize = this.fieldBytes(f.type.elem);
+                if (l?.type.kind === "vecArg") {
+                    if (!sameType(l.type.elem, f.type.elem))
+                        this.fail(e, `expected a ${typeName(f.type)}`);
+                    const c = l.c;
+                    staged.set(name, (put) => {
+                        const n = this.tmp("vl");
+                        this.line(`uint32_t ${n} = (uint32_t)${c}.len;`);
+                        put(`&${n}`, "4");
+                        put(`(const uint8_t *)${c}.ptr`, `(uint64_t)${n} * ${elemSize}`);
+                    });
+                }
+                else if (r?.vec && r.type.kind === "vec" && sameType(r.type.elem, f.type.elem)) {
+                    const info = r.vec;
+                    staged.set(name, (put) => {
+                        const n = this.tmp("vl");
+                        this.line(`uint32_t ${n} = (uint32_t)${vecCount(info)};`);
+                        put(`&${n}`, "4");
+                        put(`(const uint8_t *)${info.items}`, `(uint64_t)${n} * ${elemSize}`);
+                    });
+                }
+                else
+                    this.fail(e, `expected a ${typeName(f.type)}: a Vec argument or a list in account data`);
+                continue;
+            }
             if (f.type.kind === "option" && f.type.inner.kind === "struct")
                 this.fail(obj, "Option<struct> fields are not supported in events yet");
             const vt = f.type.kind === "string" ? STRING : f.type.kind === "option" || isScalar(f.type) ? f.type : undefined;

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

@@ -32,17 +32,25 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
         text: string;
         arr?: undefined;
         n?: undefined;
+        only?: undefined;
     } | {
         text?: undefined;
         arr: string;
         n: number;
+        only?: undefined;
+    } | {
+        only: string;
+        text?: undefined;
     };
     /**
      * The text of `${e}` when it is known at compile time: a string literal or constant, a non-negative integer
      * literal, a boolean literal, or a Pubkey constant (its base58). Undefined otherwise.
      */
     protected constantText(e: ts.Expression): string | undefined;
-    protected toText(node: ts.Expression): string;
+    /** `${node}`'s text; `converted.yes` when it was made from a non-string value (new text, not a view of other text). */
+    protected toText(node: ts.Expression, converted?: {
+        yes: boolean;
+    }): string;
     /** C statement writing the decimal text of an integer into the TS_Str `out`. */
     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). */