@typesol/cli 0.16.0 → 0.18.0

package/dist/compiler/emit/calls.js

@@ -1,12 +1,14 @@
 import ts from "typescript";
-import { resolveScalarType } from "../analyze.js";
+import { calleeName, resolveScalarType } from "../analyze.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, INT_NAMES, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
-import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, } from "./shared.js";
+import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
  */
+/** List methods taking a callback (or a value) that expand into a loop. */
+const LIST_METHODS = new Set(["forEach", "some", "every", "find", "findIndex", "reduce", "includes", "indexOf"]);
 export class CallEmitter extends ExpressionEmitter {
     call(node, topLevel) {
         const callee = node.expression;
@@ -126,14 +128,26 @@ export class CallEmitter extends ExpressionEmitter {
             }
             case "mulDiv":
             case "mulDivCeil": {
-                // a * b / c with a 128-bit intermediate (u64), rounding down or up; aborts if the result does not fit.
+                // a * b / c with a double-width intermediate (128-bit for u64, 256-bit for u128), rounding down or up;
+                // aborts if the result does not fit. All three are u64, or all u128 (literals take the others' type).
                 if (args.length !== 3)
-                    this.fail(node, `${builtin}(a, b, c) takes three u64 values`);
-                const [x, y, z] = this.lowerInOrder(args, [U64, U64, U64]);
+                    this.fail(node, `${builtin}(a, b, c) takes three u64 or three u128 values`);
+                const vals = [];
+                for (const a of args) {
+                    const mark = this.lines.length;
+                    const v = this.expr(a);
+                    for (let j = 0; j < vals.length; j++)
+                        vals[j] = this.settle(vals[j], mark);
+                    vals.push(v);
+                }
+                const typed = vals.find((v) => v.literal === undefined);
+                const wide = typed?.type.kind === "int" && typed.type.name === "u128";
+                const ty = wide ? { kind: "int", name: "u128" } : U64;
+                const [x, y, z] = vals.map((v, i) => this.expect(v.literal !== undefined ? this.literal(v.literal, ty, args[i]) : v, ty, args[i]));
                 const t = this.tmp("md");
-                this.line(`uint64_t ${t};`);
-                this.line(`TS_TRY(ts_mul_div(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
-                return { c: t, type: U64 };
+                this.line(`${wide ? "unsigned __int128" : "uint64_t"} ${t};`);
+                this.line(`TS_TRY(ts_mul_div${wide ? "_u128" : ""}(${x.c}, ${y.c}, ${z.c}, ${builtin === "mulDivCeil"}, &${t}));`);
+                return { c: t, type: ty };
             }
             case "isqrt": {
                 if (args.length !== 1)
@@ -219,7 +233,18 @@ export class CallEmitter extends ExpressionEmitter {
                 this.line(`TS_TRY(ts_t22_transfer_fee(${m}, ${amt.c}, &${t}));`);
                 return { c: t, type: U64 };
             }
+            case "isTransferring": {
+                // TransferHookAccount (15) on a Token-2022 token account: set only while Token-2022 runs a transfer of it.
+                if (args.length !== 1)
+                    this.fail(node, "isTransferring(tokenAccount) takes the source token account");
+                const m = this.anyAccount(args[0], "the token account");
+                this.line(`TS_TRY(ts_t22_layout(${m}, 2));`);
+                const off = this.tmp("eo");
+                this.line(`uint64_t ${off}, ${off}l;`);
+                return { c: `(ts_t22_ext(${m}, 15, &${off}, &${off}l) && ${off}l >= 1 && ${m}->data[${off}] != 0)`, type: BOOL };
+            }
             case "transferHookProgram":
+            case "transferHookAuthority":
             case "permanentDelegate":
             case "mintCloseAuthority": {
                 // Token-2022 mint extensions holding an optional Pubkey: TransferHook (14, program at +32),
@@ -228,7 +253,7 @@ export class CallEmitter extends ExpressionEmitter {
                     this.fail(node, `${builtin}(mint) takes the mint`);
                 const m = this.anyAccount(args[0], "the mint");
                 this.line(`TS_TRY(ts_t22_layout(${m}, 1));`);
-                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
+                const [type, field] = builtin === "transferHookProgram" ? [14, 32] : builtin === "transferHookAuthority" ? [14, 0] : builtin === "permanentDelegate" ? [12, 0] : [3, 0];
                 this.model.options.set("pubkey", PUBKEY);
                 const t = this.tmp("ext");
                 this.line(`${optC(PUBKEY)} ${t};`);
@@ -364,13 +389,14 @@ export class CallEmitter extends ExpressionEmitter {
                 this.line(`if (ts_find_pda(${seeds.name}, ${seeds.count}, ${program.c}, &${t}, &${b}) != SUCCESS) TS_FAIL(TS_ERR_SEEDS, "TypeSOL: no program address for these seeds");`);
                 return { c: `(&${t})`, type: PUBKEY };
             }
-            case "metadataAddress": {
+            case "metadataAddress":
+            case "masterEditionAddress": {
                 if (args.length !== 1)
-                    this.fail(node, "metadataAddress(mint) takes the mint");
+                    this.fail(node, `${builtin}(mint) takes the mint`);
                 const m = this.expect(this.expr(args[0], PUBKEY), PUBKEY, args[0]);
                 const t = this.tmp("md");
                 this.line(`SolPubkey ${t};`);
-                this.line(`TS_TRY(ts_metadata_address(${m.c}, &${t}));`);
+                this.line(`TS_TRY(${builtin === "metadataAddress" ? "ts_metadata_address" : "ts_master_edition_address"}(${m.c}, &${t}));`);
                 return { c: `(&${t})`, type: PUBKEY };
             }
             case "initExtraAccountMetas":
@@ -433,10 +459,22 @@ export class CallEmitter extends ExpressionEmitter {
         }
         if (builtin)
             this.fail(callee, `${builtin} cannot be called here`);
-        if (ts.isIdentifier(callee) && this.model.helpers.has(callee.text))
-            return this.callHelper(node, this.model.helpers.get(callee.text));
+        if (ts.isIdentifier(callee)) {
+            const local = this.lookup(callee.text);
+            if (local?.closure)
+                return this.expandClosure(local.closure, node.arguments, node);
+        }
+        const helper = this.helperOf(node);
+        if (helper)
+            return this.callHelper(node, helper);
         if (ts.isPropertyAccessExpression(callee)) {
             const method = callee.name.text;
+            // xs.some(…) and friends on a Vec, FixedArray, FixedVec or Vec argument: a loop with the callback expanded in it.
+            if (LIST_METHODS.has(method)) {
+                const l = ts.isIdentifier(callee.expression) ? this.lookup(callee.expression.text) : undefined;
+                if (l?.type.kind === "vecArg" || l?.type.kind === "array" || this.peekArray(callee.expression))
+                    return this.listMethod(node, method);
+            }
             // Vec<T> instruction arguments are read-only views.
             if (ts.isIdentifier(callee.expression)) {
                 const l = this.lookup(callee.expression.text);
@@ -444,6 +482,10 @@ export class CallEmitter extends ExpressionEmitter {
                     if (method !== "get" || args.length !== 1)
                         this.fail(node, "Vec arguments are read-only: use .get(i) and .length");
                     const elem = l.type.elem;
+                    if (elem.kind === "string") {
+                        const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
+                        return { c: `(((const TS_Str *)${l.c}.ptr)[${idx}])`, type: STRING };
+                    }
                     if (!isScalar(elem))
                         this.fail(node, `read a field of the element: ${callee.expression.text}.get(i).field`);
                     const idx = this.index(args[0], `(uint64_t)${l.c}.len`);
@@ -504,8 +546,10 @@ export class CallEmitter extends ExpressionEmitter {
                 // Program accounts used through their methods (systemProgram.transfer, tokenProgram.*…) may be optional.
                 if (target?.optional)
                     this.assertUsable(target, callee.expression);
-                if (target?.kind.kind === "token" && target.kind.init && method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
-                    return this.createAta(node, target, topLevel);
+                if ((target?.kind.kind === "token" || target?.kind.kind === "mint") &&
+                    target.kind.init &&
+                    method === (target.kind.init === "create" ? "create" : "createIfNeeded"))
+                    return target.kind.kind === "token" && target.constraints.ata ? this.createAta(node, target, topLevel) : this.createToken(node, target, topLevel);
                 if (target?.kind.kind === "init" && method === "create")
                     return this.create(node, target, topLevel);
                 if (target?.kind.kind === "initIfNeeded" && method === "createIfNeeded")
@@ -520,10 +564,14 @@ export class CallEmitter extends ExpressionEmitter {
                     return this.ataOp(node, target, method);
                 if (target?.kind.kind === "metadataProgram")
                     return this.metadataOp(node, target, method);
-                if (target?.kind.kind === "coreProgram")
-                    return this.coreOp(node, target, method);
-                if (target?.kind.kind === "bubblegumProgram")
-                    return this.bubblegumOp(node, target, method);
+                // Each Metaplex CPI in its own C block: its data buffer's stack slot is reused by the next one.
+                if (target?.kind.kind === "coreProgram" || target?.kind.kind === "bubblegumProgram") {
+                    const t = target;
+                    this.line("{");
+                    this.block(() => (t.kind.kind === "coreProgram" ? this.coreOp(node, t, method) : this.bubblegumOp(node, t, method)));
+                    this.line("}");
+                    return undefined;
+                }
             }
         }
         if (ts.isPropertyAccessExpression(callee) && ts.isCallExpression(callee.expression) && this.exportName(callee.expression.expression) === "fixedArray")
@@ -536,7 +584,8 @@ export class CallEmitter extends ExpressionEmitter {
         const args = node.arguments;
         const vt = v.type;
         const info = v.vec;
-        const elemRef = (idx) => ({ ...v, lv: `${v.lv}[${idx}]`, type: vt.elem, vec: undefined, path: undefined });
+        const elemRef = (idx) => this.withFixedVec({ ...v, lv: `${info.items}[${idx}]`, type: vt.elem, vec: undefined, path: undefined });
+        const count = vecCount(info);
         /**
          * Evaluate the value into a temporary first (JS evaluates arguments before the call runs), then return a
          * writer for the element: `push(v.length)` sees the old length, `set(i, pop())` checks i after the pop.
@@ -564,8 +613,10 @@ export class CallEmitter extends ExpressionEmitter {
         // Elements removed or replaced here must not be referenced afterwards.
         const elemPaths = () => (ts.isPropertyAccessExpression(node.expression) ? this.pathsOf(node.expression.expression)?.map((p) => `${p}[]`) : undefined);
         const resize = (newLen, payer) => {
+            if (info.cap !== undefined)
+                return; // a FixedVec has its room already
             if (!info.resizable || !v.account)
-                this.fail(node, "only Vecs of declared Mut<...> / Init<...> accounts can grow or shrink");
+                this.fail(node, "only Vecs of Mut<...> / Init<...> accounts can grow or shrink");
             this.line(`TS_TRY(ts_resize(params, ${payer}, a_${v.account.name}, 8 + ${info.fixed} + (${newLen}) * ${info.elemSize}, entry_${v.account.name}));`);
         };
         switch (method) {
@@ -577,11 +628,23 @@ export class CallEmitter extends ExpressionEmitter {
                     this.assertNotAliased(elemPaths(), node);
                 const i = this.indexValue(args[0]);
                 const write = stageElem(args[1]);
-                this.checkIndex(i, `(uint64_t)${info.len}`);
+                this.checkIndex(i, count);
                 write(elemRef(i));
                 return undefined;
             }
             case "push": {
+                if (info.cap !== undefined) {
+                    if (args.length !== 1)
+                        this.fail(node, "push(value) on a FixedVec takes the value (it has room for its capacity already)");
+                    needWritable();
+                    const write = stageElem(args[0]);
+                    const n = this.tmp("n");
+                    this.line(`uint64_t ${n} = ${count};`);
+                    this.line(`if (${n} >= ${info.cap}) TS_FAIL(TS_ERR_INDEX, "TypeSOL: push() on a full FixedVec");`);
+                    this.line(`${info.len} = (uint32_t)(${n} + 1);`);
+                    write(elemRef(n));
+                    return undefined;
+                }
                 if (args.length !== 2)
                     this.fail(node, "push(value, payer) takes the value and a Mut<Signer> that pays for the extra rent");
                 needWritable();
@@ -604,7 +667,7 @@ export class CallEmitter extends ExpressionEmitter {
                 this.assertNotAliased(elemPaths(), node);
                 const st = this.storageValueType(vt.elem);
                 const n = this.tmp("n");
-                this.line(`uint64_t ${n} = (uint64_t)${info.len};`);
+                this.line(`uint64_t ${n} = ${count};`);
                 this.line(`if (${n} == 0) TS_FAIL(TS_ERR_INDEX, "TypeSOL: pop() on an empty Vec");`);
                 // Structs and arrays are dropped (pop() as a statement); read .get(length - 1) first to keep one.
                 let result;
@@ -836,6 +899,8 @@ export class CallEmitter extends ExpressionEmitter {
         const s = targ && ts.isTypeReferenceNode(targ) && ts.isIdentifier(targ.typeName) ? this.model.structs.get(targ.typeName.text) : undefined;
         if (!s || s.size === undefined || s.vec)
             this.fail(node, "loadForeign needs a fixed-size struct type: loadForeign<Pool>(account, owner)");
+        if (s.layout === "borsh")
+            this.fail(node, `${s.name} is @layout borsh: loadForeign reads fixed layouts only`);
         if (node.arguments.length !== 2)
             this.fail(node, "loadForeign<T>(account, owner) takes the account and its owning program's address");
         const h = this.anyAccount(node.arguments[0], "loadForeign's account");
@@ -857,6 +922,8 @@ export class CallEmitter extends ExpressionEmitter {
         const s = targ && ts.isTypeReferenceNode(targ) && ts.isIdentifier(targ.typeName) ? this.model.structs.get(targ.typeName.text) : undefined;
         if (!s || s.size === undefined)
             this.fail(node, "loadAccount needs an account struct type: loadAccount<MyStruct>(account)");
+        if (s.layout === "borsh")
+            this.fail(node, `${s.name} is @layout borsh: declare it as an instruction parameter (remaining accounts are read in place)`);
         if (node.arguments.length !== 1)
             this.fail(node, "loadAccount<T>(account) takes one remaining account");
         const h = this.handle(node.arguments[0]);
@@ -874,16 +941,45 @@ export class CallEmitter extends ExpressionEmitter {
         }
         return { c: `((TSS_${s.name} *)(${h}->data + 8))`, type: { kind: "structRef", struct: s.name, writable: mut } };
     }
+    /** Whether a helper (or one it calls) grows a Vec, which needs the instruction's SystemProgram for rent. */
+    helperGrows(body, seen = new Set()) {
+        if (seen.has(body))
+            return false;
+        seen.add(body);
+        let found = false;
+        const visit = (n) => {
+            if (found)
+                return;
+            if (ts.isCallExpression(n)) {
+                // Vec.push(value, payer) grows the account; FixedVec.push(value) does not.
+                if (ts.isPropertyAccessExpression(n.expression) && n.expression.name.text === "push" && n.arguments.length === 2)
+                    found = true;
+                else if (ts.isIdentifier(n.expression)) {
+                    const name = calleeName(n.expression, this.model.helperDecls, this.checker);
+                    const callee = name ? (this.model.generics.get(name)?.node ?? this.model.helpers.get(name)?.node) : undefined;
+                    if (callee && this.helperGrows(callee, seen))
+                        found = true;
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(body);
+        return found;
+    }
     callHelper(node, h) {
-        if (node.arguments.length !== h.params.length)
-            this.fail(node, `${h.name}() takes ${h.params.length} argument(s)`);
+        if (this.ix && !this.ix.accounts.some((a) => a.kind.kind === "system" && !a.optional) && h.params.some((p) => p.account) && this.helperGrows(h.node))
+            this.fail(node, `${h.display}() grows a Vec (push): the instruction needs a SystemProgram parameter to top up rent`);
+        // Function arguments were bound when the helper was instantiated: they have no C parameter.
+        const argNodes = h.fnArgIndexes ? node.arguments.filter((_, i) => !h.fnArgIndexes.includes(i)) : node.arguments;
+        if (argNodes.length !== h.params.length)
+            this.fail(node, `${h.display}() takes ${h.params.length} argument(s)`);
         // Arguments are evaluated left to right: settle earlier ones when a later one runs statements.
         // A helper that takes accounts may change account data, so account text it gets is copied first.
         const takesAccounts = h.params.some((p) => p.account);
         const values = [];
         const pieces = [];
         h.params.forEach((p, i) => {
-            const n = node.arguments[i];
+            const n = argNodes[i];
             const mark = this.lines.length;
             const raw = this.helperArg(h, p, n);
             for (let j = 0; j < values.length; j++)
@@ -897,8 +993,8 @@ export class CallEmitter extends ExpressionEmitter {
         });
         // A helper that takes a writable struct account may replace anything stored in it (see assertNotAliased).
         for (const [i, p] of h.params.entries())
-            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(node.arguments[i]))
-                this.assertNotAliased([node.arguments[i].text], node, h.name);
+            if (p.account && p.account.kind === "account" && p.account.mut && ts.isIdentifier(argNodes[i]))
+                this.assertNotAliased([argNodes[i].text], node, h.display);
         const args = ["params", ...pieces.map((x) => (typeof x === "number" ? (values[x].type.kind === "pubkey" ? `*(${values[x].c})` : values[x].c) : x))];
         if (!h.returns) {
             this.line(`TS_TRY(fn_${h.name}(${args.join(", ")}));`);
@@ -912,6 +1008,11 @@ export class CallEmitter extends ExpressionEmitter {
             this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
             return { c: `(&${t})`, type: { kind: "structRef", struct: h.returns.name, writable: true } };
         }
+        if (h.returns.kind === "string") {
+            this.line(`TS_Str ${t};`);
+            this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
+            return { c: t, type: STRING };
+        }
         this.line(`${scalarC(h.returns)} ${t};`);
         this.line(`TS_TRY(fn_${h.name}(${[...args, `&${t}`].join(", ")}));`);
         return h.returns.kind === "pubkey" ? { c: `(&${t})`, type: h.returns } : { c: t, type: h.returns };
@@ -923,6 +1024,11 @@ export class CallEmitter extends ExpressionEmitter {
             const why = accountMismatch(acct.kind, p.account);
             if (why)
                 this.fail(n, `${h.name}() takes ${p.name} as ${why}`);
+            // A @layout borsh account goes with the struct it is being worked on as.
+            if (p.account.kind === "account" && p.account.struct.layout === "borsh")
+                return `a_${acct.name}, d_${acct.name}`;
+            if (p.account.kind === "account" && p.account.mut && p.account.struct.vec)
+                return `a_${acct.name}, entry_${acct.name}`;
             return `a_${acct.name}`;
         }
         switch (p.type.kind) {

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

@@ -2,6 +2,13 @@ import ts from "typescript";
 import { type AccountParam, type IdlSeed, type ValueType } from "../model.js";
 import { type Value } from "./shared.js";
 import { CallEmitter } from "./calls.js";
+/** One piece of a Metaplex instruction's Borsh data: fixed bytes, or a value lowered and serialized in source order. */
+type MplField = {
+    bytes: number[];
+} | {
+    value: ts.Expression;
+    type: ValueType;
+};
 /**
  * Other programs: PDAs and seeds, account creation, System/Token/ATA/Metaplex CPIs, generic invoke, Borsh
  * serialization and events.
@@ -19,6 +26,25 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected describeSeed(el: ts.Expression): IdlSeed | undefined;
     protected recordPda(account: AccountParam, idl: IdlSeed[] | undefined): void;
     protected create(node: ts.CallExpression, target: AccountParam, topLevel: boolean, ifNeeded?: boolean): Value;
+    /**
+     * `vault.create(payer, seeds | null, mint, authority)` on `Init<TokenAccount>` and `mint.create(payer, seeds | null,
+     * decimals, authority, freezeAuthority | null)` on `Init<Mint>` (Anchor's `init` with `token::` / `mint::`
+     * constraints): a PDA of this program (or, with `null`, a new keypair account that signs), created owned by the
+     * instruction's token program and initialized. `createIfNeeded` on `InitIfNeeded<…>` does that unless the account
+     * exists, and then checks it is that PDA, owned by the token program, and has that mint and owner / those
+     * authorities and decimals (Anchor's init_if_needed checks). create returns the bump (0 for a keypair),
+     * createIfNeeded whether it created the account.
+     */
+    protected createToken(node: ts.CallExpression, target: AccountParam, topLevel: boolean): Value;
+    /**
+     * The extensions in `mint.create(…, { … })` (Anchor's `extensions::…` constraints): their values are evaluated now,
+     * in source order; the returned lines (each extension's Token-2022 initializer, mint writable, before
+     * InitializeMint2) run after the account is created, sized for exactly these extensions.
+     */
+    protected mintExtensions(lit: ts.ObjectLiteralExpression, tp: string, acct: string): {
+        space: number;
+        lines: string[];
+    };
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`
      * (Anchor's `init` / `init_if_needed` with `associated_token::…`). create always calls the ATA program's Create, which
@@ -30,10 +56,17 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected systemTransfer(node: ts.CallExpression): undefined;
     /** systemProgram.createAccount(payer, account, lamports, space, owner, signerSeeds?) */
     protected createAccount(node: ts.CallExpression, system: AccountParam): undefined;
-    /** Emit a CPI to the program account `program` with these metas (account, writable, signer). */
+    /**
+     * 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).
+     */
     protected cpi(program: string, metas: [string, boolean, boolean][], buf: string, len: string, seeds: {
         name: string;
         count: number | string;
+    }, tail?: {
+        from: string;
+        to: string;
+        asPassed?: boolean;
     }): void;
     protected signerSeeds(node: ts.Expression | undefined, authority: AccountParam, at: ts.Node): {
         name: string;
@@ -47,25 +80,41 @@ export declare abstract class CpiEmitter extends CallEmitter {
     protected tokenOp(node: ts.CallExpression, program: AccountParam, method: string): undefined;
     protected ataOp(node: ts.CallExpression, program: AccountParam, method: string): undefined;
     protected metadataOp(node: ts.CallExpression, program: AccountParam, method: string): undefined;
+    /** CreateMasterEditionV3 (17) and Verify (52) with VerificationArgs::CollectionV1. */
+    protected metadataCollectionOp(node: ts.CallExpression, program: AccountParam, method: string): undefined;
     /**
      * One account of a Metaplex CPI: an account parameter, or `null` for an optional account left out
      * (Metaplex programs take their own id in its place).
      */
     protected mplMeta(n: ts.Expression, program: AccountParam, what: string, writable: boolean, signer: boolean): [string, boolean, boolean];
     /** Borsh fields into a fresh buffer: raw bytes ("u8:N" style) or lowered values. */
-    protected mplData(at: ts.Node, max: number, fields: ({
-        bytes: number[];
-    } | {
-        value: ts.Expression;
-        type: ValueType;
-    })[]): {
+    protected mplData(at: ts.Node, max: number, fields: MplField[]): {
         buf: string;
         len: string;
     };
-    /** 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.
+     */
+    protected corePlugin(n: ts.Expression, withAuthority: boolean): MplField[];
+    /** CreateV1 / CreateCollectionV1 plugins: Option<Vec<PluginAuthorityPair>>. */
+    protected corePluginList(n: ts.Expression | undefined): MplField[];
+    /** Metaplex Core: assets and collections (with plugins), plugins added, updated and removed, transfer and burn. */
     protected coreOp(node: ts.CallExpression, core: AccountParam, method: string): undefined;
+    /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
+    protected corePluginType(n: ts.Expression): MplField;
     /** Bubblegum (compressed NFTs on SPL account compression): createTree, mint (MintV1, no collection, no creators). */
     protected bubblegumOp(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
+    /** Bubblegum V2 (trees on mpl-account-compression with mpl-noop; optional Metaplex Core collections). */
+    protected bubblegumV2(node: ts.CallExpression, bg: AccountParam, method: string): undefined;
+    /** Object literal properties by name, refusing others. */
+    protected literalProps(o: ts.ObjectLiteralExpression, allowed: string[], what: string): Map<string, ts.Expression>;
+    /** Vec<Creator> (address, verified, share) from a literal list; shares add up to 100 when literal. */
+    protected bubblegumCreators(creators: ts.Expression | undefined): MplField[];
+    /** UpdateArgs: every field optional (left out or null: unchanged). */
+    protected bubblegumUpdateArgs(n: ts.Expression): MplField[];
+    /** `acct.key` of an account parameter, as an expression to serialize. */
+    protected keyOf(n: ts.Expression): ts.Expression;
     /**
      * `remainingAccounts()` (or a const bound to it): every remaining account; `rest.slice(a, b?)`: indexes a..b of them
      * (both checked against the count, 5104). C expressions for the range, relative to the first remaining account.
@@ -94,8 +143,13 @@ export declare abstract class CpiEmitter extends CallEmitter {
         authority: string;
         program: string;
     }): undefined;
+    /** emit<T> of a @layout borsh struct: built like account data, then packed as Anchor serializes it. */
+    private emitBorshEvent;
+    /** Discriminator + `body`, logged (emit) or self-invoked (emitCpi). */
+    private sendEvent;
     /** Structs reachable through the fields of struct `name` (not including itself unless it recurses). */
     protected nestedStructs(name: string): Set<string>;
     /** Structs whose IDL description is the fixed layout: account data, arguments, and everything nested in them. */
     protected fixedLayoutStructs(): Set<string>;
 }
+export {};