@typesol/cli 0.17.0 → 0.18.0

package/dist/compiler/emit/cpi.js

@@ -1,9 +1,153 @@
 import ts from "typescript";
 import { discriminator, snakeCase } from "../analyze.js";
 import { borshMinSize } from "./borsh.js";
-import { INT_INFO, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
+import { 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",
@@ -22,9 +166,17 @@ const CORE_PLUGINS = [
     "VerifiedCreators",
     "Autograph",
     "BubblegumV2",
+    "FreezeExecute",
+    "PermanentFreezeExecute",
+    "Groups",
 ];
 const CORE_PLUGIN_FIELDS = {
-    Royalties: ["basisPoints", "creators"],
+    Royalties: ["basisPoints", "creators", "ruleSet"],
+    MasterEdition: ["maxSupply", "name", "uri"],
+    VerifiedCreators: ["signatures"],
+    Autograph: ["signatures"],
+    FreezeExecute: ["frozen"],
+    PermanentFreezeExecute: ["frozen"],
     FreezeDelegate: ["frozen"],
     PermanentFreezeDelegate: ["frozen"],
     UpdateDelegate: ["additionalDelegates"],
@@ -149,38 +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}), 8 + ${s.layout === "borsh" ? borshMinSize(s, this.model) : `sizeof(TSS_${s.name})`}, &${b}, &${created}));`);
+            this.line(`TS_TRY(ts_create_pda_if_needed(params, a_${payer.name}, a_${target.name}, ${seeds.name}, ${seeds.count}, TS_DISC_${s.name}, ${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}));`);
-            this.created.add(target.name);
-            this.pendingInit.delete(target.name);
-            this.bumps.set(target.name, b);
+                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">`
@@ -297,7 +794,7 @@ export class CpiEmitter extends CallEmitter {
         this.line(`if (${metas.length} + (${tail.to} - ${tail.from}) > TS_MAX_ACCOUNTS) TS_FAIL(TS_ERR_TOO_MANY_ACCOUNTS, "TypeSOL: the CPI lists more than ${MAX_ACCOUNTS} accounts");`);
         this.line(`SolAccountMeta ${m}[TS_MAX_ACCOUNTS] = {${fixed}};`);
         this.line(`uint64_t ${cnt} = ${metas.length};`);
-        this.line(`for (uint64_t ${i} = ${n} + ${tail.from}; ${i} < ${n} + ${tail.to}; ${i}++) ${m}[${cnt}++] = (SolAccountMeta){&params->ka[${i}]->key, 0, 0};`);
+        this.line(`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) {
@@ -355,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]);
@@ -378,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);
@@ -388,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<...>)");
@@ -509,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");
@@ -585,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")
@@ -807,8 +1501,8 @@ export class CpiEmitter extends CallEmitter {
         const index = CORE_PLUGINS.indexOf(kind);
         if (index < 0)
             this.fail(kindNode, `Core plugins are ${CORE_PLUGINS.join(", ")}`);
-        if (kind === "MasterEdition" || kind === "VerifiedCreators" || kind === "Autograph")
-            this.fail(kindNode, `the ${kind} plugin is not supported yet (removePlugin can remove one)`);
+        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))
@@ -852,9 +1546,55 @@ export class CpiEmitter extends CallEmitter {
                 }
                 if (constant && creators.length && sum !== 100n)
                     this.fail(need("creators"), `creator percentages add up to ${sum}; Core requires 100`);
-                fields.push({ bytes: [0] }); // rule_set: RuleSet::None
+                // 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 });
@@ -1119,10 +1859,17 @@ export class CpiEmitter extends CallEmitter {
         const U32 = { kind: "int", name: "u32" };
         const U64v = { kind: "int", name: "u64" };
         const HASH = { kind: "pubkey", hash: true };
-        // The leaf a transfer or burn replaces: { root, dataHash, creatorHash, assetDataHash?, flags?, nonce, index }.
-        const leafFields = (n) => {
+        // 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 { root, dataHash, creatorHash, assetDataHash?, flags?, nonce, index }");
+                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))
@@ -1132,27 +1879,64 @@ export class CpiEmitter extends CallEmitter {
                 else
                     this.fail(q, "write leaf fields as name: value");
             }
-            const known = ["root", "dataHash", "creatorHash", "assetDataHash", "flags", "nonce", "index"];
             for (const [k, v] of props)
                 if (!known.includes(k))
                     this.fail(v, `the leaf has no field ${k}`);
             const need = (k) => props.get(k) ?? this.fail(n, `the leaf needs ${k}`);
+            // 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] }];
-                return [{ bytes: [1] }, { value: v, type: t }];
+                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 },
-                { value: need("dataHash"), type: HASH },
-                { value: need("creatorHash"), type: HASH },
+                ...hashes,
+                ...(shape === "delegate" ? opt("collectionHash", HASH) : []),
                 ...opt("assetDataHash", HASH),
                 ...opt("flags", U8),
-                { value: need("nonce"), type: U64v },
-                { value: need("index"), type: U32 },
+                ...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");
@@ -1311,7 +2095,102 @@ export class CpiEmitter extends CallEmitter {
                 return undefined;
             }
         }
-        this.fail(node.expression, `Bubblegum supports createTree, mint, createTreeV2, mintV2, transferV2 and burnV2, not ${method}`);
+        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) {
@@ -1446,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;`);
@@ -1606,11 +2499,11 @@ export class CpiEmitter extends CallEmitter {
         const s = targ && ts.isTypeReferenceNode(targ) && ts.isIdentifier(targ.typeName) ? this.model.structs.get(targ.typeName.text) : undefined;
         if (!s)
             this.fail(node, "emit needs an explicit event type: emit<MyEvent>({ ... })");
-        if (s.layout === "borsh")
-            this.fail(node, `${s.name} is @layout borsh, an account layout; declare a separate event struct`);
         const obj = node.arguments[0];
         if (node.arguments.length !== (cpi ? 3 : 1) || !ts.isObjectLiteralExpression(obj))
             this.fail(node, "emit<T>({ field: value, ... }) takes one object literal");
+        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))
@@ -1685,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");
@@ -1705,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) {