@typesol/cli 0.15.0 → 0.17.0

package/dist/compiler/emit/cpi.js

@@ -1,8 +1,36 @@
 import ts from "typescript";
 import { discriminator, snakeCase } from "../analyze.js";
+import { borshMinSize } from "./borsh.js";
 import { INT_INFO, isScalar, isWritable, 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 { CallEmitter } from "./calls.js";
+/** Metaplex Core's Plugin / PluginType enums, in order (MasterEdition, VerifiedCreators and Autograph values are refused). */
+const CORE_PLUGINS = [
+    "Royalties",
+    "FreezeDelegate",
+    "BurnDelegate",
+    "TransferDelegate",
+    "UpdateDelegate",
+    "PermanentFreezeDelegate",
+    "Attributes",
+    "PermanentTransferDelegate",
+    "PermanentBurnDelegate",
+    "Edition",
+    "MasterEdition",
+    "AddBlocker",
+    "ImmutableMetadata",
+    "VerifiedCreators",
+    "Autograph",
+    "BubblegumV2",
+];
+const CORE_PLUGIN_FIELDS = {
+    Royalties: ["basisPoints", "creators"],
+    FreezeDelegate: ["frozen"],
+    PermanentFreezeDelegate: ["frozen"],
+    UpdateDelegate: ["additionalDelegates"],
+    Attributes: ["attributes"],
+    Edition: ["number"],
+};
 /**
  * Other programs: PDAs and seeds, account creation, System/Token/ATA/Metaplex CPIs, generic invoke, Borsh
  * serialization and events.
@@ -139,7 +167,10 @@ export class CpiEmitter extends CallEmitter {
             // Returns whether it was created now; an existing account must be this PDA, ours, and a ${s.name}.
             const created = this.tmp("created");
             this.line(`bool ${created};`);
-            this.line(`TS_TRY(ts_create_pda_if_needed(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, 8 + sizeof(TSS_${s.name}), &${b}, &${created}));`);
+            this.line(`TS_TRY(ts_create_pda_if_needed(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, 8 + sizeof(TSS_${s.name}), 8 + ${s.layout === "borsh" ? borshMinSize(s, this.model) : `sizeof(TSS_${s.name})`}, &${b}, &${created}));`);
+            // An existing @layout borsh account is unpacked now (a new one starts from the zeroed struct).
+            if (s.layout === "borsh")
+                this.line(`if (!${created}) TS_TRY(ts_unpack_${s.name}(a_${target.name}->data + 8, a_${target.name}->data_len - 8, d_${target.name}));`);
             this.created.add(target.name);
             this.pendingInit.delete(target.name);
             this.bumps.set(target.name, b);
@@ -248,11 +279,26 @@ export class CpiEmitter extends CallEmitter {
         ], buf, len, seeds);
         return undefined;
     }
-    /** Emit a CPI to the program account `program` with these metas (account, writable, signer). */
-    cpi(program, metas, buf, len, seeds) {
+    /**
+     * Emit a CPI to the program account `program` with these metas (account, writable, signer), and then (`tail`) a range
+     * of the remaining accounts, read-only (a Merkle proof).
+     */
+    cpi(program, metas, buf, len, seeds, tail) {
         const m = this.tmp("metas");
-        this.line(`SolAccountMeta ${m}[${metas.length}] = {${metas.map(([acc, w, sg]) => `{&${acc}->key, ${w}, ${sg}}`).join(", ")}};`);
-        this.line(`TS_TRY(ts_cpi(params, ${program}, ${buf}, ${len}, ${m}, ${metas.length}, ${seeds.name}, ${seeds.count}));`);
+        const fixed = metas.map(([acc, w, sg]) => `{&${acc}->key, ${w}, ${sg}}`).join(", ");
+        if (!tail) {
+            this.line(`SolAccountMeta ${m}[${metas.length}] = {${fixed}};`);
+            this.line(`TS_TRY(ts_cpi(params, ${program}, ${buf}, ${len}, ${m}, ${metas.length}, ${seeds.name}, ${seeds.count}));`);
+            return;
+        }
+        const n = this.ix.accounts.length;
+        const cnt = this.tmp("nmetas");
+        const i = this.tmp("ri");
+        this.line(`if (${metas.length} + (${tail.to} - ${tail.from}) > TS_MAX_ACCOUNTS) TS_FAIL(TS_ERR_TOO_MANY_ACCOUNTS, "TypeSOL: the CPI lists more than ${MAX_ACCOUNTS} accounts");`);
+        this.line(`SolAccountMeta ${m}[TS_MAX_ACCOUNTS] = {${fixed}};`);
+        this.line(`uint64_t ${cnt} = ${metas.length};`);
+        this.line(`for (uint64_t ${i} = ${n} + ${tail.from}; ${i} < ${n} + ${tail.to}; ${i}++) ${m}[${cnt}++] = (SolAccountMeta){&params->ka[${i}]->key, 0, 0};`);
+        this.line(`TS_TRY(ts_cpi(params, ${program}, ${buf}, ${len}, ${m}, ${cnt}, ${seeds.name}, ${seeds.count}));`);
     }
     signerSeeds(node, authority, at) {
         if (!node) {
@@ -371,7 +417,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 +585,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")
@@ -471,11 +608,17 @@ export class CpiEmitter extends CallEmitter {
         return undefined;
     }
     metadataOp(node, program, method) {
+        if (method === "createMasterEditionV3" || method === "verifyCollection")
+            return this.metadataCollectionOp(node, program, method);
         if (method !== "createV3")
-            this.fail(node.expression, "the Token Metadata program supports createV3");
+            this.fail(node.expression, `the Token Metadata program supports createV3, createMasterEditionV3 and verifyCollection, not ${method}`);
         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?, isCollection? }?, 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 +626,135 @@ 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";
+        let sized = "false";
+        if (extras) {
+            for (const p of extras.properties) {
+                if (!ts.isPropertyAssignment(p) || !ts.isIdentifier(p.name))
+                    this.fail(p, "use creators: [...], collection: key and isCollection: boolean");
+                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 if (p.name.text === "isCollection") {
+                    const v = this.expect(this.expr(p.initializer, BOOL), BOOL, p.initializer);
+                    const t = this.tmp("sized");
+                    this.line(`bool ${t} = ${v.c};`);
+                    sized = t;
+                }
+                else
+                    this.fail(p.name, `createV3 extras are creators, collection and isCollection, 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}, ${sized}, ${seeds.name}, ${seeds.count}));`);
+        return undefined;
+    }
+    /** CreateMasterEditionV3 (17) and Verify (52) with VerificationArgs::CollectionV1. */
+    metadataCollectionOp(node, program, method) {
+        const a = node.arguments;
+        const p = `a_${program.name}`;
+        const seedsAt = (i) => (a[i] ? this.signingSeeds(a[i]) : { name: "NULL", count: 0 });
+        const acct = (i, what, w, s) => {
+            if (a[i].kind === ts.SyntaxKind.NullKeyword)
+                this.fail(a[i], `pass ${what}`);
+            return this.mplMeta(a[i], program, what, w, s);
+        };
+        if (method === "createMasterEditionV3") {
+            if (a.length !== 9 && a.length !== 10)
+                this.fail(node, "createMasterEditionV3(edition, mint, updateAuthority, mintAuthority, payer, metadata, tokenProgram, systemProgram, maxSupply | null, signerSeeds?)");
+            const metas = [
+                acct(0, "the edition", true, false),
+                acct(1, "the mint", true, false),
+                acct(2, "the update authority", false, true),
+                acct(3, "the mint authority", false, true),
+                acct(4, "the payer", true, true),
+                acct(5, "the metadata", true, false),
+                acct(6, "the token program", false, false),
+                acct(7, "the system program", false, false),
+            ];
+            // max_supply: Option<u64>; Some(0) makes a one of one, None allows unlimited prints.
+            const data = this.mplData(node, 16, a[8].kind === ts.SyntaxKind.NullKeyword ? [{ bytes: [17, 0] }] : [{ bytes: [17, 1] }, { value: a[8], type: { kind: "int", name: "u64" } }]);
+            this.cpi(p, metas, data.buf, data.len, seedsAt(9));
+            return undefined;
+        }
+        // Verify: authority, delegate record (absent: the program id), metadata, collection mint, collection metadata,
+        // collection master edition, system program, instructions sysvar.
+        if (a.length !== 7 && a.length !== 8)
+            this.fail(node, "verifyCollection(authority, metadata, collectionMint, collectionMetadata, collectionMasterEdition, systemProgram, instructionsSysvar, signerSeeds?)");
+        const metas = [
+            acct(0, "the collection authority", false, true),
+            [p, false, false],
+            acct(1, "the metadata", true, false),
+            acct(2, "the collection mint", false, false),
+            acct(3, "the collection metadata", true, false),
+            acct(4, "the collection master edition", false, false),
+            acct(5, "the system program", false, false),
+            acct(6, "the instructions sysvar", false, false),
+        ];
+        const data = this.mplData(node, 8, [{ bytes: [52, 1] }]);
+        this.cpi(p, metas, data.buf, data.len, seedsAt(7));
         return undefined;
     }
     /**
@@ -517,17 +784,156 @@ export class CpiEmitter extends CallEmitter {
         finish(at);
         return { buf, len };
     }
-    /** Metaplex Core: createAsset, createCollection, transferAsset, burnAsset (no plugins). */
+    /**
+     * Borsh of one Metaplex Core plugin literal (`{ kind: "FreezeDelegate", frozen: true, authority?: … }`): the Plugin
+     * enum, then (`withAuthority`) the Option<PluginAuthority> that CreateV1's PluginAuthorityPair and AddPluginV1 take.
+     */
+    corePlugin(n, withAuthority) {
+        if (!ts.isObjectLiteralExpression(n))
+            this.fail(n, 'a Core plugin is an object literal: { kind: "FreezeDelegate", frozen: false }');
+        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 plugin fields as name: value");
+        }
+        const kindNode = props.get("kind");
+        if (!kindNode || !ts.isStringLiteral(kindNode))
+            this.fail(n, 'a Core plugin needs kind: "Royalties" | "FreezeDelegate" | …');
+        const kind = kindNode.text;
+        const index = CORE_PLUGINS.indexOf(kind);
+        if (index < 0)
+            this.fail(kindNode, `Core plugins are ${CORE_PLUGINS.join(", ")}`);
+        if (kind === "MasterEdition" || kind === "VerifiedCreators" || kind === "Autograph")
+            this.fail(kindNode, `the ${kind} plugin is not supported yet (removePlugin can remove one)`);
+        const known = new Set(["kind", "authority", ...(CORE_PLUGIN_FIELDS[kind] ?? [])]);
+        for (const [k, v] of props)
+            if (!known.has(k))
+                this.fail(v, `${kind} has no field ${k}`);
+        const need = (k) => props.get(k) ?? this.fail(n, `${kind} needs ${k}`);
+        const list = (k, max) => {
+            const e = need(k);
+            if (!ts.isArrayLiteralExpression(e))
+                this.fail(e, `${k} is an array literal`);
+            if (e.elements.length > max)
+                this.fail(e, `at most ${max} entries in ${k}`);
+            return e.elements;
+        };
+        const u32 = (x) => [x & 0xff, (x >> 8) & 0xff, (x >> 16) & 0xff, x >>> 24];
+        const fields = [{ bytes: [index] }];
+        switch (kind) {
+            case "Royalties": {
+                const bps = need("basisPoints");
+                if (ts.isBigIntLiteral(bps) && BigInt(bps.text.slice(0, -1)) > 10000n)
+                    this.fail(bps, "basisPoints is at most 10000 (100%)");
+                fields.push({ value: bps, type: { kind: "int", name: "u16" } });
+                const creators = list("creators", 5);
+                fields.push({ bytes: u32(creators.length) });
+                let sum = 0n;
+                let constant = true;
+                for (const c of creators) {
+                    if (!ts.isObjectLiteralExpression(c))
+                        this.fail(c, "a creator is { address, percentage }");
+                    const get = (k) => {
+                        const q = c.properties.find((x) => (ts.isPropertyAssignment(x) || ts.isShorthandPropertyAssignment(x)) && ts.isIdentifier(x.name) && x.name.text === k);
+                        if (!q)
+                            this.fail(c, `a creator needs ${k}`);
+                        return ts.isPropertyAssignment(q) ? q.initializer : q.name;
+                    };
+                    const pct = get("percentage");
+                    if (ts.isBigIntLiteral(pct))
+                        sum += BigInt(pct.text.slice(0, -1));
+                    else
+                        constant = false;
+                    fields.push({ value: get("address"), type: PUBKEY }, { value: pct, type: U8 });
+                }
+                if (constant && creators.length && sum !== 100n)
+                    this.fail(need("creators"), `creator percentages add up to ${sum}; Core requires 100`);
+                fields.push({ bytes: [0] }); // rule_set: RuleSet::None
+                break;
+            }
+            case "FreezeDelegate":
+            case "PermanentFreezeDelegate":
+                fields.push({ value: need("frozen"), type: BOOL });
+                break;
+            case "UpdateDelegate": {
+                const keys = props.has("additionalDelegates") ? list("additionalDelegates", 8) : [];
+                fields.push({ bytes: u32(keys.length) }, ...keys.map((k) => ({ value: k, type: PUBKEY })));
+                break;
+            }
+            case "Attributes": {
+                const attrs = list("attributes", 32);
+                fields.push({ bytes: u32(attrs.length) });
+                for (const at of attrs) {
+                    if (!ts.isObjectLiteralExpression(at))
+                        this.fail(at, "an attribute is { key, value }");
+                    for (const k of ["key", "value"]) {
+                        const q = at.properties.find((x) => (ts.isPropertyAssignment(x) || ts.isShorthandPropertyAssignment(x)) && ts.isIdentifier(x.name) && x.name.text === k);
+                        if (!q)
+                            this.fail(at, `an attribute needs ${k}`);
+                        fields.push({ value: ts.isPropertyAssignment(q) ? q.initializer : q.name, type: STRING });
+                    }
+                }
+                break;
+            }
+            case "Edition":
+                fields.push({ value: need("number"), type: { kind: "int", name: "u32" } });
+                break;
+        }
+        const auth = props.get("authority");
+        if (!withAuthority) {
+            if (auth)
+                this.fail(auth, "a plugin's authority is set when it is added; change it with Core's approve / revoke");
+            return fields;
+        }
+        if (!auth)
+            fields.push({ bytes: [0] }); // the plugin type's default authority
+        else if (ts.isStringLiteral(auth)) {
+            const i = ["none", "owner", "updateAuthority"].indexOf(auth.text);
+            if (i < 0)
+                this.fail(auth, 'authority is "none", "owner", "updateAuthority" or a Pubkey');
+            fields.push({ bytes: [1, i] });
+        }
+        else
+            fields.push({ bytes: [1, 3] }, { value: auth, type: PUBKEY });
+        return fields;
+    }
+    /** CreateV1 / CreateCollectionV1 plugins: Option<Vec<PluginAuthorityPair>>. */
+    corePluginList(n) {
+        if (!n)
+            return [{ bytes: [0] }];
+        const els = n.elements;
+        if (els.length > 16)
+            this.fail(n, "at most 16 plugins");
+        const kinds = els.map((e) => ts.isObjectLiteralExpression(e) ? e.properties.find((q) => q.name && ts.isIdentifier(q.name) && q.name.text === "kind") : undefined);
+        const seen = new Set();
+        kinds.forEach((k, i) => {
+            const lit = k && ts.isPropertyAssignment(k) && ts.isStringLiteral(k.initializer) ? k.initializer.text : undefined;
+            if (lit && seen.has(lit))
+                this.fail(els[i], `${lit} is listed twice; an asset has one plugin of each kind`);
+            if (lit)
+                seen.add(lit);
+        });
+        return [{ bytes: [1, els.length & 0xff, 0, 0, 0] }, ...els.flatMap((e) => this.corePlugin(e, true))];
+    }
+    /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
     coreOp(node, core, method) {
         const a = node.arguments;
         const p = `a_${core.name}`;
         const seedsAt = (i) => (a[i] ? this.signingSeeds(a[i]) : { name: "NULL", count: 0 });
         const str = (n) => ({ value: n, type: STRING });
+        // An array literal of object literals after the uri is the plugin list; the signer seeds come after it.
+        const isPlugins = (n) => !!n && ts.isArrayLiteralExpression(n) && (n.elements.length === 0 || n.elements.every((e) => ts.isObjectLiteralExpression(e)));
+        const self = [p, false, false];
         switch (method) {
             case "createAsset": {
                 // CreateV1: asset, collection, authority, payer, owner, updateAuthority, systemProgram, logWrapper.
-                if (a.length !== 8 && a.length !== 9)
-                    this.fail(node, "createAsset(asset, collection | null, authority | null, payer, owner | null, systemProgram, name, uri, signerSeeds?)");
+                const plugins = isPlugins(a[8]) ? a[8] : undefined;
+                if (a.length < 8 || a.length > (plugins ? 10 : 9))
+                    this.fail(node, "createAsset(asset, collection | null, authority | null, payer, owner | null, systemProgram, name, uri, plugins?, signerSeeds?)");
                 const metas = [
                     this.mplMeta(a[0], core, "the asset", true, true),
                     this.mplMeta(a[1], core, "the collection", true, false),
@@ -538,24 +944,64 @@ export class CpiEmitter extends CallEmitter {
                     this.mplMeta(a[5], core, "the system program", false, false),
                     [p, false, false],
                 ];
-                const data = this.mplData(node, 1024, [{ bytes: [0, 0] }, str(a[6]), str(a[7]), { bytes: [0] }]);
-                this.cpi(p, metas, data.buf, data.len, seedsAt(8));
+                const data = this.mplData(node, 2048, [{ bytes: [0, 0] }, str(a[6]), str(a[7]), ...this.corePluginList(plugins)]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(plugins ? 9 : 8));
                 return undefined;
             }
             case "createCollection": {
                 // CreateCollectionV1: collection, updateAuthority, payer, systemProgram.
-                if (a.length !== 6 && a.length !== 7)
-                    this.fail(node, "createCollection(collection, updateAuthority | null, payer, systemProgram, name, uri, signerSeeds?)");
+                const plugins = isPlugins(a[6]) ? a[6] : undefined;
+                if (a.length < 6 || a.length > (plugins ? 8 : 7))
+                    this.fail(node, "createCollection(collection, updateAuthority | null, payer, systemProgram, name, uri, plugins?, signerSeeds?)");
                 const metas = [
                     this.mplMeta(a[0], core, "the collection", true, true),
                     this.mplMeta(a[1], core, "the update authority", false, false),
                     this.mplMeta(a[2], core, "the payer", true, true),
                     this.mplMeta(a[3], core, "the system program", false, false),
                 ];
-                const data = this.mplData(node, 1024, [{ bytes: [1] }, str(a[4]), str(a[5]), { bytes: [0] }]);
+                const data = this.mplData(node, 2048, [{ bytes: [1] }, str(a[4]), str(a[5]), ...this.corePluginList(plugins)]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(plugins ? 7 : 6));
+                return undefined;
+            }
+            case "addPlugin":
+            case "updatePlugin":
+            case "removePlugin": {
+                // Add/Remove/UpdatePluginV1: asset, collection, payer, authority, systemProgram, logWrapper.
+                const last = method === "removePlugin" ? "kind" : "plugin";
+                if (a.length !== 6 && a.length !== 7)
+                    this.fail(node, `${method}(asset, collection | null, payer, authority | null, systemProgram, ${last}, 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),
+                    this.mplMeta(a[4], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "removePlugin" ? [this.corePluginType(a[5])] : this.corePlugin(a[5], method === "addPlugin");
+                const data = this.mplData(node, 2048, [{ bytes: [{ addPlugin: 2, removePlugin: 4, updatePlugin: 6 }[method]] }, ...body]);
                 this.cpi(p, metas, data.buf, data.len, seedsAt(6));
                 return undefined;
             }
+            case "addCollectionPlugin":
+            case "updateCollectionPlugin":
+            case "removeCollectionPlugin": {
+                // Add/Remove/UpdateCollectionPluginV1: collection, payer, authority, systemProgram, logWrapper.
+                const last = method === "removeCollectionPlugin" ? "kind" : "plugin";
+                if (a.length !== 5 && a.length !== 6)
+                    this.fail(node, `${method}(collection, payer, authority | null, systemProgram, ${last}, 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),
+                    this.mplMeta(a[3], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "removeCollectionPlugin" ? [this.corePluginType(a[4])] : this.corePlugin(a[4], method === "addCollectionPlugin");
+                const data = this.mplData(node, 2048, [{ bytes: [{ addCollectionPlugin: 3, removeCollectionPlugin: 5, updateCollectionPlugin: 7 }[method]] }, ...body]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(5));
+                return undefined;
+            }
             case "transferAsset": {
                 // TransferV1: asset, collection, payer, authority, newOwner, systemProgram, logWrapper.
                 if (a.length !== 5 && a.length !== 6)
@@ -590,7 +1036,16 @@ export class CpiEmitter extends CallEmitter {
                 return undefined;
             }
         }
-        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, transferAsset and burnAsset, not ${method}`);
+        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+    }
+    /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
+    corePluginType(n) {
+        if (!ts.isStringLiteral(n))
+            this.fail(n, 'name the plugin kind as a string literal: "FreezeDelegate"');
+        const i = CORE_PLUGINS.indexOf(n.text);
+        if (i < 0)
+            this.fail(n, `Core plugins are ${CORE_PLUGINS.join(", ")}`);
+        return { bytes: [i] };
     }
     /** Bubblegum (compressed NFTs on SPL account compression): createTree, mint (MintV1, no collection, no creators). */
     bubblegumOp(node, bg, method) {
@@ -653,7 +1108,218 @@ export class CpiEmitter extends CallEmitter {
                 return undefined;
             }
         }
-        this.fail(node.expression, `Bubblegum supports createTree and mint, not ${method}`);
+        return this.bubblegumV2(node, bg, method);
+    }
+    /** Bubblegum V2 (trees on mpl-account-compression with mpl-noop; optional Metaplex Core collections). */
+    bubblegumV2(node, bg, method) {
+        const a = node.arguments;
+        const p = `a_${bg.name}`;
+        const acct = (i, what, w, s) => this.mplMeta(a[i], bg, what, w, s);
+        const seedsAt = (i) => (a[i] ? this.signingSeeds(a[i]) : { name: "NULL", count: 0 });
+        const U32 = { kind: "int", name: "u32" };
+        const U64v = { kind: "int", name: "u64" };
+        const HASH = { kind: "pubkey", hash: true };
+        // The leaf a transfer or burn replaces: { root, dataHash, creatorHash, assetDataHash?, flags?, nonce, index }.
+        const leafFields = (n) => {
+            if (!ts.isObjectLiteralExpression(n))
+                this.fail(n, "the leaf is { root, dataHash, creatorHash, assetDataHash?, flags?, nonce, index }");
+            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 leaf fields as name: value");
+            }
+            const known = ["root", "dataHash", "creatorHash", "assetDataHash", "flags", "nonce", "index"];
+            for (const [k, v] of props)
+                if (!known.includes(k))
+                    this.fail(v, `the leaf has no field ${k}`);
+            const need = (k) => props.get(k) ?? this.fail(n, `the leaf needs ${k}`);
+            const opt = (k, t) => {
+                const v = props.get(k);
+                if (!v || v.kind === ts.SyntaxKind.NullKeyword)
+                    return [{ bytes: [0] }];
+                return [{ bytes: [1] }, { value: v, type: t }];
+            };
+            return [
+                { value: need("root"), type: HASH },
+                { value: need("dataHash"), type: HASH },
+                { value: need("creatorHash"), type: HASH },
+                ...opt("assetDataHash", HASH),
+                ...opt("flags", U8),
+                { value: need("nonce"), type: U64v },
+                { value: need("index"), type: U32 },
+            ];
+        };
+        const proofRange = (n) => {
+            if (!this.ix)
+                this.fail(n, "a Merkle proof comes from remainingAccounts(), so only instructions can pass one");
+            return this.remainingRange(n) ?? this.fail(n, "pass the proof as remainingAccounts() or rest.slice(a, b)");
+        };
+        switch (method) {
+            case "createTreeV2": {
+                // CreateTreeConfigV2: treeConfig, merkleTree, payer, treeCreator, logWrapper, compressionProgram, systemProgram.
+                if (a.length !== 10 && a.length !== 11)
+                    this.fail(node, "createTreeV2(treeConfig, merkleTree, payer, treeCreator | null, logWrapper, compressionProgram, systemProgram, maxDepth, maxBufferSize, isPublic, signerSeeds?)");
+                const metas = [
+                    acct(0, "the tree config", true, false),
+                    acct(1, "the merkle tree", true, false),
+                    acct(2, "the payer", true, true),
+                    acct(3, "the tree creator", false, true),
+                    acct(4, "the log wrapper", false, false),
+                    acct(5, "the compression program", false, false),
+                    acct(6, "the system program", false, false),
+                ];
+                const data = this.mplData(node, 32, [
+                    { bytes: [55, 99, 95, 215, 142, 203, 227, 205] },
+                    { value: a[7], type: U32 },
+                    { value: a[8], type: U32 },
+                    { bytes: [1] },
+                    { value: a[9], type: BOOL },
+                ]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(10));
+                return undefined;
+            }
+            case "mintV2": {
+                // MintV2: treeConfig, payer, treeCreatorOrDelegate, collectionAuthority, leafOwner, leafDelegate, merkleTree,
+                // coreCollection, mplCoreCpiSigner, logWrapper, compressionProgram, mplCoreProgram, systemProgram.
+                const usage = "mintV2(treeConfig, payer, treeDelegate | null, leafOwner, leafDelegate | null, merkleTree, logWrapper, compressionProgram, mplCoreProgram, systemProgram, { name, symbol, uri, sellerFeeBasisPoints, creators?, isMutable? }, { collection, authority, cpiSigner }?, signerSeeds?)";
+                const collection = a[11] && ts.isObjectLiteralExpression(a[11]) ? a[11] : undefined;
+                if (a.length < 11 || a.length > (collection ? 13 : 12))
+                    this.fail(node, usage);
+                const md = a[10];
+                if (!ts.isObjectLiteralExpression(md))
+                    this.fail(md, "the metadata is { name, symbol, uri, sellerFeeBasisPoints, creators?, isMutable? }");
+                const field = (o, k) => {
+                    const q = o.properties.find((x) => (ts.isPropertyAssignment(x) || ts.isShorthandPropertyAssignment(x)) && ts.isIdentifier(x.name) && x.name.text === k);
+                    return q ? (ts.isPropertyAssignment(q) ? q.initializer : q.name) : undefined;
+                };
+                for (const q of md.properties)
+                    if (!q.name || !ts.isIdentifier(q.name) || !["name", "symbol", "uri", "sellerFeeBasisPoints", "creators", "isMutable"].includes(q.name.text))
+                        this.fail(q, "the metadata takes name, symbol, uri, sellerFeeBasisPoints, creators and isMutable");
+                const coll = collection
+                    ? ["collection", "authority", "cpiSigner"].map((k) => field(collection, k) ?? this.fail(collection, `the collection needs ${k}`))
+                    : undefined;
+                if (collection)
+                    for (const q of collection.properties)
+                        if (!q.name || !ts.isIdentifier(q.name) || !["collection", "authority", "cpiSigner"].includes(q.name.text))
+                            this.fail(q, "the collection is { collection, authority, cpiSigner }");
+                const metas = [
+                    acct(0, "the tree config", true, false),
+                    acct(1, "the payer", true, true),
+                    acct(2, "the tree delegate", false, true),
+                    coll ? this.mplMeta(coll[1], bg, "the collection authority", false, true) : [p, false, false],
+                    acct(3, "the leaf owner", false, false),
+                    acct(4, "the leaf delegate", false, false),
+                    acct(5, "the merkle tree", true, false),
+                    coll ? this.mplMeta(coll[0], bg, "the core collection", true, false) : [p, false, false],
+                    coll ? this.mplMeta(coll[2], bg, "the mpl-core CPI signer", false, false) : [p, false, false],
+                    acct(6, "the log wrapper", false, false),
+                    acct(7, "the compression program", false, false),
+                    acct(8, "the mpl-core program", false, false),
+                    acct(9, "the system program", false, false),
+                ];
+                const need = (k) => field(md, k) ?? this.fail(md, `the metadata needs ${k}`);
+                const fields = [
+                    { bytes: [120, 121, 23, 146, 173, 110, 199, 205] },
+                    { value: need("name"), type: STRING },
+                    { value: need("symbol"), type: STRING },
+                    { value: need("uri"), type: STRING },
+                    { value: need("sellerFeeBasisPoints"), type: { kind: "int", name: "u16" } },
+                    { bytes: [0] }, // primary_sale_happened
+                ];
+                const mutable = field(md, "isMutable");
+                fields.push(mutable ? { value: mutable, type: BOOL } : { bytes: [1] });
+                fields.push({ bytes: [1, 0] }); // token_standard: Some(NonFungible)
+                const creators = field(md, "creators");
+                if (creators && !ts.isArrayLiteralExpression(creators))
+                    this.fail(creators, "creators: [{ address, verified, share }, …] (an array literal)");
+                const list = creators ? creators.elements : [];
+                if (list.length > 5)
+                    this.fail(creators, "Bubblegum takes at most 5 creators");
+                fields.push({ bytes: [list.length, 0, 0, 0] });
+                let shares = 0n;
+                let constant = true;
+                for (const el of list) {
+                    if (!ts.isObjectLiteralExpression(el))
+                        this.fail(el, "a creator is { address, verified, share }");
+                    const f = (k) => field(el, k) ?? this.fail(el, `a creator needs ${k}`);
+                    const share = f("share");
+                    if (ts.isBigIntLiteral(share))
+                        shares += BigInt(share.text.slice(0, -1));
+                    else
+                        constant = false;
+                    fields.push({ value: f("address"), type: PUBKEY }, { value: f("verified"), type: BOOL }, { value: share, type: U8 });
+                }
+                if (list.length && constant && shares !== 100n)
+                    this.fail(creators, `creator shares add up to ${shares}; Bubblegum requires 100`);
+                // collection: Some(the core collection's key) when minting into one.
+                if (coll)
+                    fields.push({ bytes: [1] }, { value: this.keyOf(coll[0]), type: PUBKEY });
+                else
+                    fields.push({ bytes: [0] });
+                fields.push({ bytes: [0, 0] }); // asset_data, asset_data_schema: None
+                const data = this.mplData(node, 1024, fields);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(collection ? 12 : 11));
+                return undefined;
+            }
+            case "transferV2": {
+                // TransferV2: treeConfig, payer, authority, leafOwner, leafDelegate, newLeafOwner, merkleTree, coreCollection,
+                // logWrapper, compressionProgram, systemProgram; the proof follows as remaining accounts.
+                if (a.length !== 13 && a.length !== 14)
+                    this.fail(node, "transferV2(treeConfig, payer, authority | null, leafOwner, leafDelegate | null, newLeafOwner, merkleTree, coreCollection | null, logWrapper, compressionProgram, systemProgram, leaf, proof, signerSeeds?)");
+                const metas = [
+                    acct(0, "the tree config", true, false),
+                    acct(1, "the payer", true, true),
+                    acct(2, "the authority", false, true),
+                    acct(3, "the leaf owner", false, false),
+                    acct(4, "the leaf delegate", false, false),
+                    acct(5, "the new leaf owner", false, false),
+                    acct(6, "the merkle tree", true, false),
+                    acct(7, "the core collection", false, false),
+                    acct(8, "the log wrapper", false, false),
+                    acct(9, "the compression program", false, false),
+                    acct(10, "the system program", false, false),
+                ];
+                const data = this.mplData(node, 160, [{ bytes: [119, 40, 6, 235, 234, 221, 248, 49] }, ...leafFields(a[11])]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(13), proofRange(a[12]));
+                return undefined;
+            }
+            case "burnV2": {
+                // BurnV2: treeConfig, payer, authority, leafOwner, leafDelegate, merkleTree, coreCollection, mplCoreCpiSigner,
+                // logWrapper, compressionProgram, mplCoreProgram, systemProgram; the proof follows as remaining accounts.
+                if (a.length !== 14 && a.length !== 15)
+                    this.fail(node, "burnV2(treeConfig, payer, authority | null, leafOwner, leafDelegate | null, merkleTree, coreCollection | null, mplCoreCpiSigner | null, logWrapper, compressionProgram, mplCoreProgram, systemProgram, leaf, proof, signerSeeds?)");
+                const metas = [
+                    acct(0, "the tree config", true, false),
+                    acct(1, "the payer", true, true),
+                    acct(2, "the authority", false, true),
+                    acct(3, "the leaf owner", false, false),
+                    acct(4, "the leaf delegate", false, false),
+                    acct(5, "the merkle tree", true, false),
+                    acct(6, "the core collection", true, false),
+                    acct(7, "the mpl-core CPI signer", false, false),
+                    acct(8, "the log wrapper", false, false),
+                    acct(9, "the compression program", false, false),
+                    acct(10, "the mpl-core program", false, false),
+                    acct(11, "the system program", false, false),
+                ];
+                const data = this.mplData(node, 160, [{ bytes: [115, 210, 34, 240, 232, 143, 183, 16] }, ...leafFields(a[12])]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(14), proofRange(a[13]));
+                return undefined;
+            }
+        }
+        this.fail(node.expression, `Bubblegum supports createTree, mint, createTreeV2, mintV2, transferV2 and burnV2, not ${method}`);
+    }
+    /** `acct.key` of an account parameter, as an expression to serialize. */
+    keyOf(n) {
+        const f = ts.factory;
+        const e = f.createPropertyAccessExpression(n, "key");
+        ts.setTextRange(e, n);
+        e.parent = n.parent;
+        return e;
     }
     /**
      * `remainingAccounts()` (or a const bound to it): every remaining account; `rest.slice(a, b?)`: indexes a..b of them
@@ -914,9 +1580,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; }`);
         });
@@ -927,6 +1606,8 @@ export class CpiEmitter extends CallEmitter {
         const s = targ && ts.isTypeReferenceNode(targ) && ts.isIdentifier(targ.typeName) ? this.model.structs.get(targ.typeName.text) : undefined;
         if (!s)
             this.fail(node, "emit needs an explicit event type: emit<MyEvent>({ ... })");
+        if (s.layout === "borsh")
+            this.fail(node, `${s.name} is @layout borsh, an account layout; declare a separate event struct`);
         const obj = node.arguments[0];
         if (node.arguments.length !== (cpi ? 3 : 1) || !ts.isObjectLiteralExpression(obj))
             this.fail(node, "emit<T>({ field: value, ... }) takes one object literal");