@typesol/cli 0.16.0 → 0.18.0

package/dist/compiler/emit/cpi.js

@@ -1,8 +1,188 @@
 import ts from "typescript";
 import { discriminator, snakeCase } from "../analyze.js";
-import { INT_INFO, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.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 { CallEmitter } from "./calls.js";
+/**
+ * Bubblegum instructions that replace a leaf: discriminator, accounts in order ([label, writable, signer, optional,
+ * either-signs]) and the leaf's shape. Optional accounts take `null` (the program id). The Merkle proof follows the
+ * leaf (and metadata) as remaining accounts.
+ */
+const BUBBLEGUM_OPS = {
+    delegateV2: {
+        disc: [95, 87, 125, 140, 181, 131, 128, 227],
+        leaf: "delegate",
+        accounts: [
+            ["treeConfig", true, false],
+            ["payer", true, true],
+            ["leafOwner", false, true, true],
+            ["previousLeafDelegate", false, false, true],
+            ["newLeafDelegate", false, false],
+            ["merkleTree", true, false],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+    ...Object.fromEntries([
+        ["freezeV2", [200, 151, 244, 102, 16, 195, 255, 3], false],
+        ["thawV2", [96, 133, 101, 93, 82, 220, 146, 191], false],
+        ["setNonTransferableV2", [181, 141, 206, 58, 242, 199, 152, 168], true],
+    ].map(([name, disc, needsCollection]) => [
+        name,
+        {
+            disc: disc,
+            leaf: "v2",
+            accounts: [
+                ["treeConfig", true, false],
+                ["payer", true, true],
+                ["authority", false, true, true],
+                ["leafOwner", false, false],
+                ["leafDelegate", false, false, name === "setNonTransferableV2"],
+                ["merkleTree", true, false],
+                ["coreCollection", false, false, !needsCollection],
+                ["logWrapper", false, false],
+                ["compressionProgram", false, false],
+                ["systemProgram", false, false],
+            ],
+        },
+    ])),
+    updateMetadataV2: {
+        disc: [43, 103, 89, 42, 121, 242, 62, 72],
+        leaf: "meta",
+        accounts: [
+            ["treeConfig", true, false],
+            ["payer", true, true],
+            ["authority", false, true, true],
+            ["leafOwner", false, false],
+            ["leafDelegate", false, false, true],
+            ["merkleTree", true, false],
+            ["coreCollection", false, false, true],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+    ...Object.fromEntries([
+        ["verifyCreatorV2", [85, 138, 140, 42, 22, 241, 118, 102]],
+        ["unverifyCreatorV2", [174, 112, 29, 142, 230, 100, 239, 7]],
+    ].map(([name, disc]) => [
+        name,
+        {
+            disc: disc,
+            leaf: "meta",
+            accounts: [
+                ["treeConfig", true, false],
+                ["payer", true, true],
+                ["creator", false, true, true],
+                ["leafOwner", false, false],
+                ["leafDelegate", false, false, true],
+                ["merkleTree", true, false],
+                ["logWrapper", false, false],
+                ["compressionProgram", false, false],
+                ["systemProgram", false, false],
+            ],
+        },
+    ])),
+    setCollectionV2: {
+        disc: [229, 35, 61, 91, 15, 14, 99, 160],
+        leaf: "meta",
+        accounts: [
+            ["treeConfig", true, false],
+            ["payer", true, true],
+            ["authority", false, true, true],
+            ["newCollectionAuthority", false, true, true],
+            ["leafOwner", false, false],
+            ["leafDelegate", false, false, true],
+            ["merkleTree", true, false],
+            ["coreCollection", true, false, true],
+            ["newCoreCollection", true, false, true],
+            ["mplCoreCpiSigner", false, false, true],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["mplCoreProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+    // V1 trees (SPL Account Compression, SPL Noop).
+    transfer: {
+        disc: [163, 52, 200, 231, 140, 3, 69, 186],
+        leaf: "v1",
+        accounts: [
+            ["treeConfig", false, false],
+            ["leafOwner", false, false, false, "owner"],
+            ["leafDelegate", false, false, false, "delegate"],
+            ["newLeafOwner", false, false],
+            ["merkleTree", true, false],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+    burn: {
+        disc: [116, 110, 29, 56, 107, 219, 42, 93],
+        leaf: "v1",
+        accounts: [
+            ["treeConfig", false, false],
+            ["leafOwner", false, false, false, "owner"],
+            ["leafDelegate", false, false, false, "delegate"],
+            ["merkleTree", true, false],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+    delegate: {
+        disc: [90, 147, 75, 178, 85, 88, 4, 137],
+        leaf: "v1",
+        accounts: [
+            ["treeConfig", false, false],
+            ["leafOwner", false, false, false, "owner"],
+            ["previousLeafDelegate", false, false],
+            ["newLeafDelegate", false, false],
+            ["merkleTree", true, false],
+            ["logWrapper", false, false],
+            ["compressionProgram", false, false],
+            ["systemProgram", false, false],
+        ],
+    },
+};
+/** 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",
+    "FreezeExecute",
+    "PermanentFreezeExecute",
+    "Groups",
+];
+const CORE_PLUGIN_FIELDS = {
+    Royalties: ["basisPoints", "creators", "ruleSet"],
+    MasterEdition: ["maxSupply", "name", "uri"],
+    VerifiedCreators: ["signatures"],
+    Autograph: ["signatures"],
+    FreezeExecute: ["frozen"],
+    PermanentFreezeExecute: ["frozen"],
+    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.
@@ -121,35 +301,383 @@ export class CpiEmitter extends CallEmitter {
             this.ix.pdas.set(account.name, idl);
     }
     create(node, target, topLevel, ifNeeded = false) {
+        const call = `${target.name}.${ifNeeded ? "createIfNeeded" : "create"}`;
         if (!topLevel)
-            this.fail(node, `${target.name}.${ifNeeded ? "createIfNeeded" : "create"}(...) must be a top-level statement of the instruction`);
+            this.fail(node, `${call}(...) must be a top-level statement of the instruction`);
         if (this.created.has(target.name))
             this.fail(node, `${target.name} is already created`);
-        if (node.arguments.length !== 2)
-            this.fail(node, "create(payer, seeds) takes two arguments");
+        if (node.arguments.length !== 2 && node.arguments.length !== 3)
+            this.fail(node, `${call}(payer, seeds | null, space?) takes two or three arguments`);
         const payer = this.accountParam(node.arguments[0], "the payer");
         if (payer.kind.kind !== "signer" || !payer.kind.mut)
             this.fail(node.arguments[0], "the payer must be a Mut<Signer>");
-        const seeds = this.seeds(node.arguments[1], 1);
-        this.recordPda(target, seeds.idl);
         const s = target.kind.struct;
+        const keypair = node.arguments[1].kind === ts.SyntaxKind.NullKeyword;
+        if (keypair && ifNeeded)
+            this.fail(node.arguments[1], "createIfNeeded takes seeds: a keypair account cannot be checked to be the one meant");
+        const seeds = keypair ? undefined : this.seeds(node.arguments[1], 1);
+        if (seeds)
+            this.recordPda(target, seeds.idl);
         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})`;
+        let space = need;
+        const spaceArg = node.arguments[2];
+        if (spaceArg) {
+            if (s.vec)
+                this.fail(spaceArg, `${s.name} has a growable Vec: its size follows the Vec's length, so it takes no space argument`);
+            const raw = this.expr(spaceArg);
+            const v = this.expect(raw, U64, spaceArg);
+            const min = 8 + this.fieldBytes({ kind: "struct", name: s.name });
+            if (raw.literal !== undefined && raw.literal < BigInt(min))
+                this.fail(spaceArg, `${s.name} needs at least ${min} bytes (8 + its size)`);
+            space = this.tmp("space");
+            this.line(`uint64_t ${space} = ${v.c};`);
+            this.line(`if (${space} < ${need} || ${space} > 10240) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: space must hold the account and be at most 10240 bytes");`);
+        }
         this.line(`uint8_t ${b};`);
+        const done = () => {
+            this.created.add(target.name);
+            this.pendingInit.delete(target.name);
+            this.bumps.set(target.name, b);
+        };
+        if (!seeds) {
+            // A new keypair account that signs the transaction (Anchor's `init` without seeds).
+            target.signsInit = true;
+            this.line(`TS_TRY(ts_create_owned(params, a_${payer.name}, a_${target.name}, NULL, 0, params->program_id, ${space}, &${b}));`);
+            this.line(`a_${target.name}->data_len = ${space};`);
+            this.line(`ts_memcpy(a_${target.name}->data, TS_DISC_${s.name}, 8);`);
+            done();
+            return { c: b, type: U8 };
+        }
         if (ifNeeded) {
             // 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.created.add(target.name);
-            this.pendingInit.delete(target.name);
-            this.bumps.set(target.name, b);
+            this.line(`TS_TRY(ts_create_pda_if_needed(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, ${space}, 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}, NULL));`);
+            done();
             return { c: created, type: BOOL };
         }
-        this.line(`TS_TRY(ts_create_pda(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, 8 + sizeof(TSS_${s.name}), &${b}));`);
+        this.line(`TS_TRY(ts_create_pda(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, ${space}, &${b}));`);
+        done();
+        return { c: b, type: U8 };
+    }
+    /**
+     * `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.
+     */
+    createToken(node, target, topLevel) {
+        const isMint = target.kind.kind === "mint";
+        const ifNeeded = target.kind.init === "ifNeeded";
+        const call = `${target.name}.${ifNeeded ? "createIfNeeded" : "create"}`;
+        const usage = isMint
+            ? `${call}(payer, seeds | null, decimals, mintAuthority, freezeAuthority | null, extensions?, tokenProgram?)`
+            : `${call}(payer, seeds | null, mint, authority, tokenProgram?)`;
+        if (!topLevel)
+            this.fail(node, `${call}(...) must be a top-level statement of the instruction`);
+        if (this.created.has(target.name))
+            this.fail(node, `${target.name} is already created`);
+        const a = node.arguments;
+        if (!isMint && a.length === 1)
+            this.fail(node, `${call}(payer) creates an associated token account: wrap it in Ata<…, "owner", "mint">; or call ${usage.slice(call.length)}`);
+        // A mint may list its Token-2022 extensions next (Anchor's `extensions::…`), as an object literal.
+        const bare = (e) => e && (ts.isAsExpression(e) || ts.isParenthesizedExpression(e) || ts.isSatisfiesExpression(e)) ? bare(e.expression) : e;
+        const ext5 = bare(a[5]);
+        const extArg = isMint && ext5 && ts.isObjectLiteralExpression(ext5) ? ext5 : undefined;
+        const fixedArgs = isMint ? (extArg ? 6 : 5) : 4;
+        if (a.length !== fixedArgs && a.length !== fixedArgs + 1)
+            this.fail(node, usage);
+        if (extArg && ifNeeded)
+            this.fail(extArg, "createIfNeeded does not take extensions yet: create the mint with create(…)");
+        const payer = this.accountParam(a[0], "the payer");
+        if (payer.kind.kind !== "signer" || !payer.kind.mut)
+            this.fail(a[0], "the payer must be a Mut<Signer>");
+        // The token program: named as the last argument, or the instruction's only token program parameter.
+        let programs = this.ix.accounts.filter((p) => p.kind.kind === "tokenProgram");
+        if (a[fixedArgs]) {
+            const named = this.accountParam(a[fixedArgs], "the token program");
+            if (named.kind.kind !== "tokenProgram")
+                this.fail(a[fixedArgs], "pass a TokenProgram, Token2022Program or TokenInterface parameter");
+            programs = [named];
+        }
+        if (programs.length !== 1)
+            this.fail(node, `${call}(...) needs one token program: pass it as the last argument, or have exactly one token program parameter`);
+        if (programs[0].optional)
+            this.fail(programs[0].node, `${call}(...) needs "${programs[0].name}": it cannot be optional`);
+        if (!this.ix.accounts.some((p) => p.kind.kind === "system" && !p.optional))
+            this.fail(node, `${call}(...) needs a SystemProgram parameter`);
+        const tp = `a_${programs[0].name}`;
+        const acct = `a_${target.name}`;
+        // Seeds, then the values, in source order.
+        let seeds = { name: "NULL", count: 0 };
+        if (a[1].kind !== ts.SyntaxKind.NullKeyword) {
+            const s = this.seeds(a[1], 1);
+            this.recordPda(target, s.idl);
+            seeds = s;
+        }
+        else
+            target.signsInit = true;
+        const vals = [];
+        const take = (n, t) => {
+            const mark = this.lines.length;
+            // The account's own address is known before it exists (`vault.create(payer, seeds, mint, vault.key)`).
+            const own = ts.isPropertyAccessExpression(n) && n.name.text === "key" && ts.isIdentifier(n.expression) && n.expression.text === target.name;
+            const v = own ? { c: `(&${acct}->key)`, type: PUBKEY } : 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);
+        };
+        let mint;
+        const extLines = [];
+        let mintSpace = "TS_MINT_LEN";
+        if (isMint) {
+            take(a[2], U8);
+            take(a[3], PUBKEY);
+            if (a[4].kind !== ts.SyntaxKind.NullKeyword)
+                take(a[4], PUBKEY);
+            if (extArg) {
+                if (programs[0].kind.kind === "tokenProgram" && programs[0].kind.flavor === "token")
+                    this.fail(extArg, "mint extensions are Token-2022's; use Token2022Program or TokenInterface");
+                const ext = this.mintExtensions(extArg, tp, acct);
+                mintSpace = String(ext.space);
+                extLines.push(...ext.lines);
+            }
+        }
+        else {
+            mint = this.accountParam(a[2], "the mint");
+            if (mint.kind.kind !== "mint")
+                this.fail(a[2], "pass the Mint parameter the account will hold");
+            take(a[3], PUBKEY);
+        }
+        const b = this.tmp("bump");
+        this.line(`uint8_t ${b};`);
+        const created = this.tmp("created");
+        const createLines = [];
+        if (isMint) {
+            const [decimals, authority, freeze] = vals;
+            createLines.push(`TS_TRY(ts_create_owned(params, a_${payer.name}, ${acct}, ${seeds.name}, ${seeds.count}, &${tp}->key, ${mintSpace}, &${b}));`, ...extLines, `TS_TRY(ts_token_init_mint(params, ${tp}, ${acct}, (uint8_t)(${decimals.c}), ${authority.c}, ${freeze ? freeze.c : "NULL"}));`);
+            if (ifNeeded) {
+                this.line(`bool ${created} = ts_key_eq(&${acct}->owner, &TS_SYSTEM_PROGRAM_ID);`);
+                this.line(`if (${created}) {`);
+                for (const l of createLines)
+                    this.line(`  ${l}`);
+                this.line(`} else {`);
+                this.line(`  TS_TRY(ts_token_existing(params, ${acct}, ${tp}, ${seeds.name}, ${seeds.count}, &${b}));`);
+                this.line(`  TS_TRY(ts_check_mint(${acct}));`);
+                this.line(`  TS_TRY(ts_check_mint_is(${acct}, (uint8_t)(${decimals.c}), ${authority.c}, ${freeze ? freeze.c : "NULL"}));`);
+                this.line(`}`);
+            }
+            else
+                for (const l of createLines)
+                    this.line(l);
+        }
+        else {
+            const [authority] = vals;
+            const space = this.tmp("space");
+            createLines.push(`uint64_t ${space};`, `TS_TRY(ts_token_account_space(params, ${tp}, a_${mint.name}, &${space}));`, `TS_TRY(ts_create_owned(params, a_${payer.name}, ${acct}, ${seeds.name}, ${seeds.count}, &${tp}->key, ${space}, &${b}));`, `TS_TRY(ts_token_init_account(params, ${tp}, ${acct}, a_${mint.name}, ${authority.c}));`);
+            if (ifNeeded) {
+                this.line(`bool ${created} = ts_key_eq(&${acct}->owner, &TS_SYSTEM_PROGRAM_ID);`);
+                this.line(`if (${created}) {`);
+                for (const l of createLines)
+                    this.line(`  ${l}`);
+                this.line(`} else {`);
+                this.line(`  TS_TRY(ts_token_existing(params, ${acct}, ${tp}, ${seeds.name}, ${seeds.count}, &${b}));`);
+                this.line(`  TS_TRY(ts_check_token_account(${acct}));`);
+                this.line(`  if (!ts_key_eq(ts_token_mint(${acct}), &a_${mint.name}->key)) TS_FAIL(TS_ERR_TOKEN_MINT, "TypeSOL: ${target.name} is not a token account of ${mint.name}");`);
+                this.line(`  if (!ts_key_eq(ts_token_owner(${acct}), ${authority.c})) TS_FAIL(TS_ERR_TOKEN_OWNER, "TypeSOL: ${target.name} has another owner");`);
+                this.line(`}`);
+            }
+            else
+                for (const l of createLines)
+                    this.line(l);
+        }
         this.created.add(target.name);
         this.pendingInit.delete(target.name);
         this.bumps.set(target.name, b);
-        return { c: b, type: U8 };
+        return ifNeeded ? { c: created, type: BOOL } : { c: b, type: U8 };
+    }
+    /**
+     * 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.
+     */
+    mintExtensions(lit, tp, acct) {
+        const optKey = { kind: "option", inner: PUBKEY };
+        this.model.options.set("pubkey", PUBKEY);
+        // name: [extension type length, initializer tag, the fields an object value takes ([] for a plain value)]
+        const KINDS = {
+            transferFee: { len: 108, fields: ["configAuthority", "withdrawAuthority", "basisPoints", "maximumFee"] },
+            closeAuthority: { len: 32, fields: [] },
+            defaultAccountState: { len: 1, fields: [] },
+            nonTransferable: { len: 0, fields: [] },
+            interestBearing: { len: 52, fields: ["rateAuthority", "rate"] },
+            permanentDelegate: { len: 32, fields: [] },
+            transferHook: { len: 64, fields: ["authority", "programId"] },
+            metadataPointer: { len: 64, fields: ["authority", "metadataAddress"] },
+            groupPointer: { len: 64, fields: ["authority", "groupAddress"] },
+            groupMemberPointer: { len: 64, fields: ["authority", "memberAddress"] },
+        };
+        const given = new Map();
+        for (const p of lit.properties) {
+            const value = ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) ? p.initializer : ts.isShorthandPropertyAssignment(p) ? p.name : undefined;
+            if (!value || !p.name || !ts.isIdentifier(p.name))
+                this.fail(p, "write the extensions as `name: value` entries");
+            if (!KINDS[p.name.text])
+                this.fail(p.name, `mint extensions: ${Object.keys(KINDS).join(", ")}`);
+            given.set(p.name.text, value);
+        }
+        const U16 = { kind: "int", name: "u16" };
+        const I16 = { kind: "int", name: "i16" };
+        // Values in source order, held in temporaries; the CPIs come later.
+        const held = new Map();
+        const keyTmp = (e, nonZero) => {
+            // OptionalNonZeroPubkey (32 bytes, zero for none) or COption (a tag byte, then 32).
+            const v = this.expect(this.expr(e, optKey), optKey, e);
+            const t = this.tmp("xk");
+            this.line(`${optC(PUBKEY)} ${t} = ${v.c};`);
+            if (!nonZero)
+                return t;
+            const z = this.tmp("xz");
+            this.line(`SolPubkey ${z};`);
+            this.line(`if (${t}.some) ${z} = ${t}.v; else ts_memzero(&${z}, 32);`);
+            return z;
+        };
+        const scalarTmp = (e, t) => {
+            const v = this.expect(this.expr(e, t), t, e);
+            const n = this.tmp("xv");
+            this.line(`${scalarStorageC(t)} ${n} = ${v.c};`);
+            return n;
+        };
+        for (const [name, e] of given) {
+            const k = KINDS[name];
+            const vals = new Map();
+            if (k.fields.length) {
+                if (!ts.isObjectLiteralExpression(e))
+                    this.fail(e, `${name}: { ${k.fields.join(", ")} }`);
+                const props = new Map();
+                for (const p of e.properties) {
+                    const value = ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) ? p.initializer : ts.isShorthandPropertyAssignment(p) ? p.name : undefined;
+                    if (!value || !p.name || !ts.isIdentifier(p.name) || !k.fields.includes(p.name.text))
+                        this.fail(p, `${name}: { ${k.fields.join(", ")} }`);
+                    props.set(p.name.text, value);
+                }
+                for (const f of k.fields)
+                    if (!props.has(f))
+                        this.fail(e, `${name} needs ${f}`);
+                for (const [f, v] of props) {
+                    if (f === "basisPoints") {
+                        const t = scalarTmp(v, U16);
+                        this.line(`if (${t} > 10000) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: transfer fee above 10000 basis points");`);
+                        vals.set(f, t);
+                    }
+                    else if (f === "maximumFee")
+                        vals.set(f, scalarTmp(v, U64));
+                    else if (f === "rate")
+                        vals.set(f, scalarTmp(v, I16));
+                    else
+                        vals.set(f, keyTmp(v, name !== "transferFee"));
+                }
+            }
+            else if (name === "closeAuthority")
+                vals.set("v", keyTmp(e, false));
+            else if (name === "permanentDelegate") {
+                const v = this.expect(this.expr(e, PUBKEY), PUBKEY, e);
+                const t = this.tmp("xk");
+                this.line(`SolPubkey ${t} = *(${v.c});`);
+                vals.set("v", t);
+            }
+            else if (name === "defaultAccountState") {
+                const v = this.expect(this.expr(e, BOOL), BOOL, e);
+                const t = this.tmp("xs");
+                this.line(`uint8_t ${t} = (${v.c}) ? 2 : 1;`); // frozen: AccountState::Frozen, else Initialized
+                vals.set("v", t);
+            }
+            else if (!(e.kind === ts.SyntaxKind.TrueKeyword))
+                this.fail(e, "nonTransferable: true");
+            held.set(name, vals);
+        }
+        // Each initializer: its bytes, then a CPI with the mint as the only (writable) account.
+        const lines = [];
+        const cpi = (bytes) => {
+            const total = bytes.reduce((n, [, k]) => n + k, 0);
+            const buf = this.tmp("xd");
+            lines.push(`{ uint8_t ${buf}[${total}]; uint64_t at = 0;`);
+            for (const [src, n] of bytes)
+                lines.push(`  ts_memcpy(${buf} + at, ${src}, ${n}); at += ${n};`);
+            lines.push(`  SolAccountMeta m[1] = {{&${acct}->key, true, false}};`, `  TS_TRY(ts_cpi(params, ${tp}, ${buf}, at, m, 1, NULL, 0)); }`);
+        };
+        const tag = (n) => `(const uint8_t[]){${n}}`;
+        const coption = (t) => [
+            [`(const uint8_t[]){${t}.some ? 1 : 0}`, 1],
+            [`&${t}.v`, 32],
+        ];
+        let space = 0;
+        for (const name of Object.keys(KINDS)) {
+            const v = held.get(name);
+            if (!v)
+                continue;
+            space += 4 + KINDS[name].len;
+            switch (name) {
+                case "transferFee":
+                    cpi([
+                        [tag(26), 1],
+                        [tag(0), 1],
+                        ...coption(v.get("configAuthority")),
+                        ...coption(v.get("withdrawAuthority")),
+                        [`&${v.get("basisPoints")}`, 2],
+                        [`&${v.get("maximumFee")}`, 8],
+                    ]);
+                    break;
+                case "closeAuthority":
+                    cpi([[tag(25), 1], ...coption(v.get("v"))]);
+                    break;
+                case "defaultAccountState":
+                    cpi([
+                        [tag(28), 1],
+                        [tag(0), 1],
+                        [`&${v.get("v")}`, 1],
+                    ]);
+                    break;
+                case "nonTransferable":
+                    cpi([[tag(32), 1]]);
+                    break;
+                case "interestBearing":
+                    cpi([
+                        [tag(33), 1],
+                        [tag(0), 1],
+                        [`&${v.get("rateAuthority")}`, 32],
+                        [`&${v.get("rate")}`, 2],
+                    ]);
+                    break;
+                case "permanentDelegate":
+                    cpi([
+                        [tag(35), 1],
+                        [`&${v.get("v")}`, 32],
+                    ]);
+                    break;
+                default: {
+                    const t = { transferHook: 36, metadataPointer: 39, groupPointer: 40, groupMemberPointer: 41 }[name];
+                    const [f1, f2] = KINDS[name].fields;
+                    cpi([
+                        [tag(t), 1],
+                        [tag(0), 1],
+                        [`&${v.get(f1)}`, 32],
+                        [`&${v.get(f2)}`, 32],
+                    ]);
+                }
+            }
+        }
+        // Base account (165, the mint padded to an account's size), the account type byte, then each TLV entry.
+        return { space: 165 + 1 + space, lines };
     }
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`
@@ -248,11 +776,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, ${tail.asPassed ? `params->ka[${i}]->is_writable` : 0}, 0};`);
+        this.line(`TS_TRY(ts_cpi(params, ${program}, ${buf}, ${len}, ${m}, ${cnt}, ${seeds.name}, ${seeds.count}));`);
     }
     signerSeeds(node, authority, at) {
         if (!node) {
@@ -309,7 +852,10 @@ export class CpiEmitter extends CallEmitter {
             }
             case "mintTo": {
                 arity(4);
-                const mint = want(a[0], "mint", true, "the mint");
+                // A Mut<Mint>, or a mint created and initialized earlier in this instruction (Mut<Signer> / Mut<AccountInfo>).
+                const mint = this.accountParam(a[0], "the mint");
+                if (!isWritable(mint.kind) || (mint.kind.kind !== "mint" && mint.kind.kind !== "signer" && mint.kind.kind !== "info"))
+                    this.fail(a[0], "the mint must be a Mut<Mint>, or a Mut<Signer> / Mut<AccountInfo> mint this instruction created");
                 const to = want(a[1], "token", true, "the destination");
                 const auth = this.accountParam(a[2], "the mint authority");
                 const amt = amount(a[3]);
@@ -332,7 +878,10 @@ export class CpiEmitter extends CallEmitter {
                     this.fail(node, "metadata lives in Token-2022 mints; use Token2022Program or TokenInterface");
                 if (a.length !== 6 && a.length !== 7)
                     this.fail(node, "initializeMetadata(mint, updateAuthority, mintAuthority, name, symbol, uri, signerSeeds?)");
-                const mint = want(a[0], "mint", true, "the mint");
+                // The mint may have been created and initialized earlier in this instruction (a Mut<Signer> or Mut<AccountInfo>).
+                const mint = this.accountParam(a[0], "the mint");
+                if (!isWritable(mint.kind))
+                    this.fail(a[0], "the mint must be writable (Mut<...>)");
                 const ua = this.accountParam(a[1], "the update authority");
                 const ma = this.accountParam(a[2], "the mint authority");
                 const [nm, sym, uri] = [a[3], a[4], a[5]].map((n) => this.expect(this.expr(n, STRING), STRING, n).c);
@@ -342,7 +891,10 @@ export class CpiEmitter extends CallEmitter {
             }
             case "closeAccount": {
                 arity(3);
-                const acct = want(a[0], "token", true, "the closed account");
+                // A token account, or (Token-2022, with a MintCloseAuthority and no supply left) a mint.
+                const acct = this.accountParam(a[0], "the closed account");
+                if (!((acct.kind.kind === "token" || acct.kind.kind === "mint") && acct.kind.mut))
+                    this.fail(a[0], "the closed account must be a Mut<TokenAccount> or a Mut<Mint>");
                 const dest = this.accountParam(a[1], "the destination");
                 if (!isWritable(dest.kind))
                     this.fail(a[1], "the destination must be writable (Mut<...>)");
@@ -463,6 +1015,194 @@ export class CpiEmitter extends CallEmitter {
                 simple(22, [], [[acct, true, false]], none);
                 return undefined;
             }
+            case "updateDefaultAccountState": {
+                token2022Only();
+                if (a.length !== 3 && a.length !== 4)
+                    this.fail(node, "updateDefaultAccountState(mint, freezeAuthority, frozen, signerSeeds?)");
+                const mint = anyAcct(a[0], "the mint", true);
+                const auth = this.accountParam(a[1], "the freeze authority");
+                const frozen = this.expect(this.expr(a[2], BOOL), BOOL, a[2]);
+                const st = this.tmp("st");
+                this.line(`uint8_t ${st} = (${frozen.c}) ? 2 : 1;`);
+                simple(28, [byte(1), (put) => put(`&${st}`, "1", 1)], [
+                    [mint, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[3], auth, a[1]));
+                return undefined;
+            }
+            case "enableRequiredMemoTransfers":
+            case "disableRequiredMemoTransfers": {
+                token2022Only();
+                if (a.length !== 2 && a.length !== 3)
+                    this.fail(node, `${method}(account, owner, signerSeeds?)`);
+                const acct = anyAcct(a[0], "the token account", true);
+                const owner = this.accountParam(a[1], "the owner");
+                simple(30, [byte(method === "enableRequiredMemoTransfers" ? 0 : 1)], [
+                    [acct, true, false],
+                    [owner, false, true],
+                ], this.signerSeeds(a[2], owner, a[1]));
+                return undefined;
+            }
+            case "updateTransferHook": {
+                token2022Only();
+                if (a.length !== 3 && a.length !== 4)
+                    this.fail(node, "updateTransferHook(mint, authority, programId | null, signerSeeds?)");
+                const mint = anyAcct(a[0], "the mint", true);
+                const auth = this.accountParam(a[1], "the transfer hook authority");
+                simple(36, [byte(1), nonZeroKey(a[2])], [
+                    [mint, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[3], auth, a[1]));
+                return undefined;
+            }
+            case "updateInterestRate": {
+                token2022Only();
+                if (a.length !== 3 && a.length !== 4)
+                    this.fail(node, "updateInterestRate(mint, rateAuthority, rate, signerSeeds?)");
+                const mint = anyAcct(a[0], "the mint", true);
+                const auth = this.accountParam(a[1], "the rate authority");
+                simple(33, [byte(1), value(a[2], I16)], [
+                    [mint, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[3], auth, a[1]));
+                return undefined;
+            }
+            case "transferCheckedWithFee": {
+                token2022Only();
+                if (a.length !== 6 && a.length !== 7)
+                    this.fail(node, "transferCheckedWithFee(from, mint, to, authority, amount, fee, signerSeeds?)");
+                const from = want(a[0], "token", true, "the source");
+                const mint = want(a[1], "mint", false, "the mint");
+                const to = want(a[2], "token", true, "the destination");
+                const auth = this.accountParam(a[3], "the authority");
+                // The decimals are the mint's own (checked when the mint was), as transferChecked does.
+                const dec = (put) => {
+                    const t = this.tmp("dec");
+                    this.line(`uint8_t ${t} = a_${mint.name}->data[44];`);
+                    put(`&${t}`, "1", 1);
+                };
+                simple(26, [byte(1), value(a[4], U64), dec, value(a[5], U64)], [
+                    [from, true, false],
+                    [mint, false, false],
+                    [to, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[6], auth, a[3]));
+                return undefined;
+            }
+            case "harvestWithheldTokensToMint": {
+                token2022Only();
+                if (a.length !== 2)
+                    this.fail(node, "harvestWithheldTokensToMint(mint, sources): sources is remainingAccounts() or rest.slice(a, b)");
+                if (!this.ix)
+                    this.fail(node, "harvestWithheldTokensToMint takes remaining accounts, so only instructions can call it");
+                const mint = anyAcct(a[0], "the mint", true);
+                const range = this.remainingRange(a[1]) ?? this.fail(a[1], "pass the source token accounts as remainingAccounts() or rest.slice(a, b)");
+                const { buf, len, put, finish } = this.byteBuffer("tok", 2, "TS_ERR_INSTRUCTION_DATA", "token instruction");
+                byte(26)(put);
+                byte(4)(put);
+                finish(node);
+                // The sources go as they were passed (Token-2022 skips any it cannot harvest from).
+                this.cpi(p, [[`a_${mint.name}`, true, false]], buf, len, none, { ...range, asPassed: true });
+                return undefined;
+            }
+            case "withdrawWithheldTokensFromMint": {
+                token2022Only();
+                if (a.length !== 3 && a.length !== 4)
+                    this.fail(node, "withdrawWithheldTokensFromMint(mint, destination, authority, signerSeeds?)");
+                const mint = anyAcct(a[0], "the mint", true);
+                const dest = want(a[1], "token", true, "the destination");
+                const auth = this.accountParam(a[2], "the withdraw authority");
+                simple(26, [byte(2)], [
+                    [mint, true, false],
+                    [dest, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[3], auth, a[2]));
+                return undefined;
+            }
+            case "setTransferFee": {
+                token2022Only();
+                if (a.length !== 4 && a.length !== 5)
+                    this.fail(node, "setTransferFee(mint, configAuthority, basisPoints, maximumFee, signerSeeds?)");
+                const mint = anyAcct(a[0], "the mint", true);
+                const auth = this.accountParam(a[1], "the config authority");
+                const bps = (put) => {
+                    const v = this.expect(this.expr(a[2], U16), U16, a[2]);
+                    this.line(`if (${v.c} > 10000) TS_FAIL(TS_ERR_INSTRUCTION_DATA, "TypeSOL: transfer fee above 10000 basis points");`);
+                    this.serialize(v, a[2], put);
+                };
+                simple(26, [byte(5), bps, value(a[3], U64)], [
+                    [mint, true, false],
+                    [auth, false, true],
+                ], this.signerSeeds(a[4], auth, a[1]));
+                return undefined;
+            }
+            case "updateMetadataField":
+            case "removeMetadataKey":
+            case "updateMetadataAuthority":
+            case "emitMetadata": {
+                token2022Only();
+                // The Token Metadata interface (spl-token-metadata-interface), served by Token-2022 for metadata in the mint.
+                const usage = {
+                    updateMetadataField: "updateMetadataField(mint, updateAuthority, field, value, signerSeeds?)",
+                    removeMetadataKey: "removeMetadataKey(mint, updateAuthority, key, idempotent, signerSeeds?)",
+                    updateMetadataAuthority: "updateMetadataAuthority(mint, updateAuthority, newAuthority | null, signerSeeds?)",
+                    emitMetadata: "emitMetadata(mint)",
+                }[method];
+                const fixedArgs = { updateMetadataField: 4, removeMetadataKey: 4, updateMetadataAuthority: 3, emitMetadata: 1 }[method];
+                if (a.length !== fixedArgs && (method === "emitMetadata" || a.length !== fixedArgs + 1))
+                    this.fail(node, usage);
+                const disc = {
+                    updateMetadataField: "dde9312db5cadcc8",
+                    removeMetadataKey: "ea122038598d25b5",
+                    updateMetadataAuthority: "d7e4a6e45464567b",
+                    emitMetadata: "faa6b4fa0d0cb846",
+                }[method];
+                const mint = anyAcct(a[0], "the mint", method !== "emitMetadata");
+                const auth = method === "emitMetadata" ? undefined : this.accountParam(a[1], "the update authority");
+                const { buf, len, put, finish } = this.byteBuffer("tmd", 1232, "TS_ERR_INSTRUCTION_DATA", "token metadata instruction");
+                const d = this.tmp("disc");
+                this.line(`static const uint8_t ${d}[8] = ${cBytes([...Buffer.from(disc, "hex")])};`);
+                put(d, "8", 8);
+                if (method === "updateMetadataField") {
+                    // Field: Name / Symbol / Uri for those names, otherwise Key(field), as the Token-2022 CLI reads them.
+                    const f = this.expect(this.expr(a[2], STRING), STRING, a[2]);
+                    const ft = this.tmp("field");
+                    const tag = this.tmp("ftag");
+                    this.line(`TS_Str ${ft} = ${f.c};`);
+                    this.line(`uint8_t ${tag} = ts_str_eq(${ft}, ts_str((const uint8_t *)"name", 4)) ? 0 : ts_str_eq(${ft}, ts_str((const uint8_t *)"symbol", 6)) ? 1 : ts_str_eq(${ft}, ts_str((const uint8_t *)"uri", 3)) ? 2 : 3;`);
+                    put(`&${tag}`, "1", 1);
+                    const kl = this.tmp("klen");
+                    this.line(`uint32_t ${kl} = (uint32_t)${ft}.len;`);
+                    put(`&${kl}`, `(${tag} == 3 ? 4 : 0)`);
+                    put(`${ft}.ptr`, `(${tag} == 3 ? ${ft}.len : 0)`);
+                    this.serialize(this.expect(this.expr(a[3], STRING), STRING, a[3]), a[3], put);
+                }
+                else if (method === "removeMetadataKey") {
+                    const key = this.expect(this.expr(a[2], STRING), STRING, a[2]);
+                    const idem = this.expect(this.expr(a[3], BOOL), BOOL, a[3]);
+                    const t = this.tmp("idem");
+                    this.line(`uint8_t ${t} = (${idem.c}) ? 1 : 0;`);
+                    put(`&${t}`, "1", 1);
+                    this.serialize(key, a[2], put);
+                }
+                else if (method === "updateMetadataAuthority") {
+                    nonZeroKey(a[2])(put);
+                }
+                else {
+                    // start: None, end: None (the whole TokenMetadata as return data).
+                    byte(0)(put);
+                    byte(0)(put);
+                }
+                finish(node);
+                const seeds = auth ? this.signerSeeds(a[fixedArgs], auth, a[1]) : none;
+                this.cpi(p, auth
+                    ? [
+                        [`a_${mint.name}`, true, false],
+                        [`a_${auth.name}`, false, true],
+                    ]
+                    : [[`a_${mint.name}`, false, false]], buf, len, seeds);
+                return undefined;
+            }
             case "approve": {
                 arity(4);
                 const src = want(a[0], "token", true, "the source");
@@ -539,7 +1279,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, initializeMetadata and the Token-2022 extension initializers (initializeTransferFeeConfig, initializeMintCloseAuthority, initializeNonTransferableMint, initializePermanentDelegate, initializeDefaultAccountState, initializeMetadataPointer, initializeGroupPointer, initializeGroupMemberPointer, initializeTransferHook, initializeInterestBearingMint, initializeImmutableOwner), not ${method}`);
+        this.fail(node.expression, `token programs support transfer, transferChecked, mintTo, burn, closeAccount, approve, revoke, setAuthority, freezeAccount, thawAccount, syncNative, initializeMint2, initializeAccount3, initializeMetadata, updateMetadataField, removeMetadataKey, updateMetadataAuthority, emitMetadata, the Token-2022 extension instructions (updateDefaultAccountState, updateTransferHook, enableRequiredMemoTransfers, disableRequiredMemoTransfers, updateInterestRate, transferCheckedWithFee, harvestWithheldTokensToMint, withdrawWithheldTokensFromMint, setTransferFee) and initializers (initializeTransferFeeConfig, initializeMintCloseAuthority, initializeNonTransferableMint, initializePermanentDelegate, initializeDefaultAccountState, initializeMetadataPointer, initializeGroupPointer, initializeGroupMemberPointer, initializeTransferHook, initializeInterestBearingMint, initializeImmutableOwner), not ${method}`);
     }
     ataOp(node, program, method) {
         if (method !== "create" && method !== "createIdempotent")
@@ -562,10 +1302,12 @@ 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;
-        const usage = "createV3(metadata, mint, mintAuthority, payer, updateAuthority, systemProgram, name, symbol, uri, sellerFeeBasisPoints, isMutable, { creators?, collection? }?, 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];
@@ -598,10 +1340,11 @@ export class CpiEmitter extends CallEmitter {
         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: [...] and collection: key");
+                    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)");
@@ -646,14 +1389,66 @@ export class CpiEmitter extends CallEmitter {
                     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 and collection, not ${p.name.text}`);
+                    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}, ${seeds.name}, ${seeds.count}));`);
+        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;
     }
     /**
@@ -683,17 +1478,202 @@ 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 === "Groups")
+            this.fail(kindNode, "Groups is kept by Core's group instructions (AddCollectionsToGroupV1 …), not set as a plugin");
+        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`);
+                // rule_set: None, or { programAllowList: [...] } / { programDenyList: [...] }
+                const rs = props.get("ruleSet");
+                if (!rs)
+                    fields.push({ bytes: [0] });
+                else {
+                    const pick = ts.isObjectLiteralExpression(rs) && rs.properties.length === 1 ? rs.properties[0] : undefined;
+                    const which = pick && ts.isPropertyAssignment(pick) && ts.isIdentifier(pick.name) ? pick.name.text : undefined;
+                    if (!pick ||
+                        (which !== "programAllowList" && which !== "programDenyList") ||
+                        !ts.isArrayLiteralExpression(pick.initializer))
+                        this.fail(rs, "ruleSet is { programAllowList: [programs] } or { programDenyList: [programs] }");
+                    const progs = pick.initializer.elements;
+                    if (progs.length > 16)
+                        this.fail(rs, "at most 16 programs in a rule set");
+                    fields.push({ bytes: [which === "programAllowList" ? 1 : 2, ...u32(progs.length)] }, ...progs.map((k) => ({ value: k, type: PUBKEY })));
+                }
+                break;
+            }
+            case "MasterEdition": {
+                // Option<u32>, Option<String>, Option<String>: left out or null is None.
+                const opt = (k, t) => {
+                    const v = props.get(k);
+                    return !v || v.kind === ts.SyntaxKind.NullKeyword ? [{ bytes: [0] }] : [{ bytes: [1] }, { value: v, type: t }];
+                };
+                fields.push(...opt("maxSupply", { kind: "int", name: "u32" }), ...opt("name", STRING), ...opt("uri", STRING));
+                break;
+            }
+            case "VerifiedCreators":
+            case "Autograph": {
+                const sigs = list("signatures", 16);
+                fields.push({ bytes: u32(sigs.length) });
+                const second = kind === "VerifiedCreators" ? "verified" : "message";
+                for (const sg of sigs) {
+                    if (!ts.isObjectLiteralExpression(sg))
+                        this.fail(sg, `a signature is { address, ${second} }`);
+                    const get = (k) => {
+                        const q = sg.properties.find((x) => (ts.isPropertyAssignment(x) || ts.isShorthandPropertyAssignment(x)) && ts.isIdentifier(x.name) && x.name.text === k);
+                        if (!q)
+                            this.fail(sg, `a signature needs ${k}`);
+                        return ts.isPropertyAssignment(q) ? q.initializer : q.name;
+                    };
+                    fields.push({ value: get("address"), type: PUBKEY }, { value: get(second), type: kind === "VerifiedCreators" ? BOOL : STRING });
+                }
+                break;
+            }
+            case "FreezeExecute":
+            case "PermanentFreezeExecute":
+                fields.push({ value: need("frozen"), type: BOOL });
+                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),
@@ -704,24 +1684,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)
@@ -756,7 +1776,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) {
@@ -819,7 +1848,357 @@ 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 an instruction replaces. "v2": { root, dataHash, creatorHash, assetDataHash?, flags?, nonce, index };
+        // "delegate": the same with collectionHash? before assetDataHash; "meta": { root, assetDataHash?, flags?, nonce,
+        // index } (the hashes come from the metadata passed); "v1": { root, dataHash, creatorHash, nonce, index }.
+        const leafFields = (n, shape = "v2") => {
+            const known = shape === "v1"
+                ? ["root", "dataHash", "creatorHash", "nonce", "index"]
+                : shape === "meta"
+                    ? ["root", "assetDataHash", "flags", "nonce", "index"]
+                    : ["root", "dataHash", "creatorHash", ...(shape === "delegate" ? ["collectionHash"] : []), "assetDataHash", "flags", "nonce", "index"];
+            if (!ts.isObjectLiteralExpression(n))
+                this.fail(n, `the leaf is { ${known.join(", ")} }`);
+            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");
+            }
+            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}`);
+            // Left out or null: None. A value that may be null at run time (`Hash | null`) goes as a Borsh Option.
+            const opt = (k, t) => {
+                const v = props.get(k);
+                if (!v || v.kind === ts.SyntaxKind.NullKeyword)
+                    return [{ bytes: [0] }];
+                this.model.options.set(optionKey(t), t);
+                return [{ value: v, type: { kind: "option", inner: t } }];
+            };
+            const hashes = shape === "meta"
+                ? []
+                : [
+                    { value: need("dataHash"), type: HASH },
+                    { value: need("creatorHash"), type: HASH },
+                ];
+            const tail = [
+                { value: need("nonce"), type: U64v },
+                { value: need("index"), type: U32 },
+            ];
+            if (shape === "v1")
+                return [{ value: need("root"), type: HASH }, ...hashes, ...tail];
+            return [
+                { value: need("root"), type: HASH },
+                ...hashes,
+                ...(shape === "delegate" ? opt("collectionHash", HASH) : []),
+                ...opt("assetDataHash", HASH),
+                ...opt("flags", U8),
+                ...tail,
+            ];
+        };
+        // MetadataArgsV2 from { name, symbol, uri, sellerFeeBasisPoints, primarySaleHappened?, isMutable?, creators?,
+        // collection? } (a leaf's current metadata: the program hashes it to check the leaf).
+        const metadataV2 = (md) => {
+            if (!ts.isObjectLiteralExpression(md))
+                this.fail(md, "the metadata is { name, symbol, uri, sellerFeeBasisPoints, primarySaleHappened?, isMutable?, creators?, collection? }");
+            const props = this.literalProps(md, ["name", "symbol", "uri", "sellerFeeBasisPoints", "primarySaleHappened", "isMutable", "creators", "collection"], "the metadata");
+            const need = (k) => props.get(k) ?? this.fail(md, `the metadata needs ${k}`);
+            const fields = [
+                { value: need("name"), type: STRING },
+                { value: need("symbol"), type: STRING },
+                { value: need("uri"), type: STRING },
+                { value: need("sellerFeeBasisPoints"), type: { kind: "int", name: "u16" } },
+            ];
+            const flag = (k, dflt) => (props.get(k) ? { value: props.get(k), type: BOOL } : { bytes: [dflt] });
+            fields.push(flag("primarySaleHappened", 0), flag("isMutable", 1), { bytes: [1, 0] }); // token_standard: Some(NonFungible)
+            fields.push(...this.bubblegumCreators(props.get("creators")));
+            const coll = props.get("collection");
+            if (!coll || coll.kind === ts.SyntaxKind.NullKeyword)
+                fields.push({ bytes: [0] });
+            else {
+                this.model.options.set("pubkey", PUBKEY);
+                fields.push({ value: coll, type: { kind: "option", inner: PUBKEY } });
+            }
+            return fields;
+        };
+        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;
+            }
+        }
+        const op = BUBBLEGUM_OPS[method];
+        if (op) {
+            // accounts…, [leaf, metadata?, update?], proof, signerSeeds?
+            const nAccounts = op.accounts.length;
+            const extra = op.leaf === "meta" ? (method === "updateMetadataV2" ? 2 : 1) : 0;
+            const proofAt = nAccounts + 1 + extra;
+            if (a.length !== proofAt + 1 && a.length !== proofAt + 2)
+                this.fail(node, `${method}(${op.accounts.map(([l, , , o]) => (o ? `${l} | null` : l)).join(", ")}, leaf${extra ? (extra === 2 ? ", currentMetadata, update" : ", metadata") : ""}, proof, signerSeeds?)`);
+            const hasSeeds = !!a[proofAt + 1];
+            const metas = op.accounts.map(([label, w, s, optional, either], i) => {
+                if (!optional && a[i].kind === ts.SyntaxKind.NullKeyword)
+                    this.fail(a[i], `pass ${label}`);
+                const m = this.mplMeta(a[i], bg, label, w, s);
+                // V1 leaf owner / delegate: either may sign (a PDA owner signs with the seeds).
+                if (either)
+                    return [
+                        m[0],
+                        w,
+                        either === "owner"
+                            ? `(${m[0]}->is_signer || ${hasSeeds})`
+                            : `(${m[0]}->is_signer || (${hasSeeds} && ${m[0]} == ${`a_${this.accountParam(a[i - 1], "the leaf owner").name}`}))`,
+                    ];
+                return m;
+            });
+            const fields = [{ bytes: op.disc }, ...leafFields(a[nAccounts], op.leaf)];
+            if (op.leaf === "meta")
+                fields.push(...metadataV2(a[nAccounts + 1]));
+            if (method === "updateMetadataV2")
+                fields.push(...this.bubblegumUpdateArgs(a[nAccounts + 2]));
+            const data = this.mplData(node, 2048, fields);
+            this.cpi(p, metas, data.buf, data.len, seedsAt(proofAt + 1), proofRange(a[proofAt]));
+            return undefined;
+        }
+        this.fail(node.expression, `Bubblegum supports createTree, mint, createTreeV2, mintV2, transferV2, burnV2, ${Object.keys(BUBBLEGUM_OPS).join(", ")}, not ${method}`);
+    }
+    /** Object literal properties by name, refusing others. */
+    literalProps(o, allowed, what) {
+        const props = new Map();
+        for (const q of o.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 ${what}'s fields as name: value`);
+        }
+        for (const [k, v] of props)
+            if (!allowed.includes(k))
+                this.fail(v, `${what} has no field ${k} (${allowed.join(", ")})`);
+        return props;
+    }
+    /** Vec<Creator> (address, verified, share) from a literal list; shares add up to 100 when literal. */
+    bubblegumCreators(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");
+        const fields = [{ 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 props = this.literalProps(el, ["address", "verified", "share"], "a creator");
+            const f = (k) => props.get(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`);
+        return fields;
+    }
+    /** UpdateArgs: every field optional (left out or null: unchanged). */
+    bubblegumUpdateArgs(n) {
+        if (!ts.isObjectLiteralExpression(n))
+            this.fail(n, "the update is { name?, symbol?, uri?, creators?, sellerFeeBasisPoints?, primarySaleHappened?, isMutable? }");
+        const props = this.literalProps(n, ["name", "symbol", "uri", "creators", "sellerFeeBasisPoints", "primarySaleHappened", "isMutable"], "the update");
+        const opt = (k, t) => {
+            const v = props.get(k);
+            return !v || v.kind === ts.SyntaxKind.NullKeyword ? [{ bytes: [0] }] : [{ bytes: [1] }, { value: v, type: t }];
+        };
+        const creators = props.get("creators");
+        return [
+            ...opt("name", STRING),
+            ...opt("symbol", STRING),
+            ...opt("uri", STRING),
+            ...(creators && creators.kind !== ts.SyntaxKind.NullKeyword ? [{ bytes: [1] }, ...this.bubblegumCreators(creators)] : [{ bytes: [0] }]),
+            ...opt("sellerFeeBasisPoints", { kind: "int", name: "u16" }),
+            ...opt("primarySaleHappened", BOOL),
+            ...opt("isMutable", BOOL),
+        ];
+    }
+    /** `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
@@ -946,6 +2325,20 @@ export class CpiEmitter extends CallEmitter {
                 continue;
             }
             const vec = ts.isIdentifier(el) ? this.lookup(el.text) : undefined;
+            if (vec?.type.kind === "vecArg" && vec.type.elem.kind === "string") {
+                // Borsh Vec<String> again: the count, then each string's length and bytes.
+                const n = this.tmp("vlen");
+                const i = this.tmp("vi");
+                const sl = this.tmp("slen");
+                this.line(`uint32_t ${n} = ${vec.c}.len;`);
+                put(`&${n}`, "4", 4);
+                this.line(`for (uint32_t ${i} = 0; ${i} < ${n}; ${i}++) {`);
+                this.line(`uint32_t ${sl} = (uint32_t)((const TS_Str *)${vec.c}.ptr)[${i}].len;`);
+                put(`&${sl}`, "4");
+                put(`((const TS_Str *)${vec.c}.ptr)[${i}].ptr`, `${sl}`);
+                this.line(`}`);
+                continue;
+            }
             if (vec?.type.kind === "vecArg") {
                 const n = this.tmp("vlen");
                 this.line(`uint32_t ${n} = ${vec.c}.len;`);
@@ -1109,6 +2502,8 @@ export class CpiEmitter extends CallEmitter {
         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");
+        if (s.layout === "borsh")
+            return this.emitBorshEvent(node, s, obj, cpi);
         const given = new Map();
         for (const p of obj.properties) {
             if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name))
@@ -1183,15 +2578,39 @@ export class CpiEmitter extends CallEmitter {
                 staged.set(name, (put) => put(t, String(n), n));
             }
         }
+        this.sendEvent(s, obj, cpi, (put) => {
+            for (const f of s.fields)
+                staged.get(f.name)(put);
+        });
+        return undefined;
+    }
+    /** emit<T> of a @layout borsh struct: built like account data, then packed as Anchor serializes it. */
+    emitBorshEvent(node, s, obj, cpi) {
+        this.model.events.add(s.name);
+        const t = this.tmp("evs");
+        const b = this.tmp("evb");
+        const w = this.tmp("evw");
+        // One pair of heap buffers per emit site, taken on first use: an emit in a loop does not take new heap each pass.
+        this.hoisted.push(`  TSS_${s.name} *${t} = NULL;`, `  uint8_t *${b} = NULL;`);
+        this.line(`if (${t} == NULL) TS_TRY(ts_alloc(sizeof(TSS_${s.name}), (uint8_t **)&${t}));`);
+        this.writeAggregate({ lv: `(*${t})`, type: { kind: "struct", name: s.name }, writable: true }, obj);
+        // Borsh never takes more than the fixed layout (a String/Vec is 4 + used bytes, an Option 1 + payload).
+        this.line(`uint64_t ${w} = 0;`);
+        this.line(`if (${b} == NULL) TS_TRY(ts_alloc(sizeof(TSS_${s.name}), &${b}));`);
+        this.line(`TS_TRY(ts_pack_${s.name}(${t}, ${b}, sizeof(TSS_${s.name}), &${w}));`);
+        this.sendEvent(s, node, cpi, (put) => put(b, w));
+        return undefined;
+    }
+    /** Discriminator + `body`, logged (emit) or self-invoked (emitCpi). */
+    sendEvent(s, at, cpi, body) {
         const { buf, len, put, finish } = this.byteBuffer("ev", MAX_EVENT + (cpi ? 8 : 0), "TS_ERR_EVENT_TOO_LARGE", "event");
         if (cpi)
             put("TS_EVENT_IX_TAG", "8", 8);
         const disc = this.tmp("disc");
         this.line(`static const uint8_t ${disc}[8] = ${cBytes(s.eventDiscriminator)};`);
         put(disc, "8", 8);
-        for (const f of s.fields)
-            staged.get(f.name)(put);
-        finish(obj);
+        body(put);
+        finish(at);
         if (cpi) {
             // Invoke ourselves with the event authority PDA as the only (signing) account; the entrypoint accepts it.
             const m = this.tmp("metas");
@@ -1203,12 +2622,11 @@ export class CpiEmitter extends CallEmitter {
             this.line(`SolInstruction ${ix} = {&a_${cpi.program}->key, ${m}, 1, ${buf}, ${len}};`);
             this.line(`SolSignerSeeds ${signer} = {${sd}, 2};`);
             this.line(`TS_TRY(ts_invoke(params, &${ix}, &${signer}, 1));`);
-            return undefined;
+            return;
         }
         const bytes = this.tmp("evbytes");
         this.line(`SolBytes ${bytes} = {${buf}, ${len}};`);
         this.line(`sol_log_data(&${bytes}, 1);`);
-        return undefined;
     }
     /** Structs reachable through the fields of struct `name` (not including itself unless it recurses). */
     nestedStructs(name) {