@typesol/cli 0.24.0 → 0.25.0

package/CHANGELOG.md

@@ -1,10 +1,54 @@
 # Changelog
 
-TypeSOL follows [semantic versioning](https://semver.org/) with the 0.x rules described in CONTRIBUTING.md:
-until 1.0, a minor version may change the language, the IDL layout or error codes, and says so here.
+TypeSOL follows the organization's [versioning policy](https://github.com/typesol/.github/blob/main/VERSIONING.md)
+(compiler specifics in CONTRIBUTING.md): until 1.0, a minor version may change the language, the IDL layout or error
+codes, and says so here.
 
 ## Unreleased
 
+## 0.25.0 — 2026-10-29
+
+Security review (October 2026) fixes, and error codes aligned with Anchor. Some refused transactions now report a
+different error code (below): a minor version.
+
+- Fixed: `loadAccountMut` on the same remaining account twice (`rest.get(i)`, `rest.get(j)` with `i == j`) gave two
+  writable views of one account; a program reading both before writing both could be made to create value. The second
+  load is now refused with 2040.
+- Fixed: a Vec element written with a right side that resizes the Vec (`book.bids.get(i).qty += settle(book)` where the
+  helper pops, a closure, or a `push` / `pop` / `clear` in the expression) wrote through the element's old position,
+  into the bytes of the next Vec. Such an assignment is now a compile error ("store its result in a local first"),
+  as it already was for a plain `=` with a helper.
+- Fixed: `Ata<Init<…>>` / `Ata<InitIfNeeded<…>>` creation and `Ata<AccountInfo, …>` with two token program parameters
+  used the first one; they now need exactly one (use `TokenInterface`).
+- New: `TokenOf<…, …, …, "tokenProgram">` / `MintOf<…, …, …, "tokenProgram">`, Anchor's `token::token_program` /
+  `mint::token_program` (2021 / 2022). The escrow port uses it.
+- New: `pythPrice(update, feedId, maxAge, exponent)` refuses a feed whose exponent is not the one given;
+  `switchboardValue(…, minSamples)` refuses a result resting on fewer oracle samples.
+- Changed: each account's constraints are checked in Anchor's order (seeds, associated token account, has_one, owner,
+  executable, address, token::, mint::), so a transaction breaking several fails with Anchor's code: e.g. a stranger's
+  call on a `Seeds<HasOne<…>>` account now fails with 2006 (ConstraintSeeds) instead of 2001, and an `Ata<…>` of
+  another wallet with 2015 instead of 2009. A `Mut<…>` account passed read-only fails with 2000 (ConstraintMut), as
+  Anchor's `#[account(mut)]`, instead of 3006. docs/errors.md lists the order and the differences left.
+- Docs: unchecked raw Pyth fields, `requirePda` with a bump from the arguments, Merkle leaves, and what
+  `createIfNeeded` leaves unchecked on an existing account.
+- Docs: [Case study: porting Anchor's escrow](docs/case-study-escrow.md), one Anchor program ported end to end, with the
+  differences, the checks run against the original and the cost.
+- Releases: the release workflow checks that CHANGELOG.md has the version, and after publishing installs the package
+  from npm, scaffolds a project from each template and runs its typecheck, build and test.
+
+## 0.24.1 — 2026-10-28
+
+Smaller programs and fewer compute units, with the same results; no change to the language, IDLs or error codes. Also
+new contributor docs (repository layout, a guide to the C runtime). Not externally audited (see SECURITY.md).
+
+### Performance
+- Smaller programs, same results: the rent calculation no longer links soft-float (an exact integer equivalent,
+  checked against IEEE doubles), and every failure logs through one shared call. The benchmarked programs are 11.6%
+  smaller in total (counter 13.1 → 11.0 KB, escrow 23.9 → 21.3 KB). A failing instruction costs 2 more compute units;
+  successful ones are unchanged.
+- An identical signer-seed list in the same scope reuses the array declared for the first CPI (escrow `take_offer`
+  7058 → 7044, `refund_offer` 4287 → 4271).
+
 ## 0.24.0 — 2026-10-28
 
 Functions as values, closures for any helper, stored `map` to structs and text, Metaplex Core external plugins, and

package/README.md

@@ -162,8 +162,9 @@ existing project: `npm install -D typesol@npm:@typesol/cli`.
 Deploying again upgrades the program in place. Keep `target/deploy/<name>-keypair.json`: that keypair is your
 program's address.
 
-Coming from Anchor: [docs/migrate-from-anchor.md](docs/migrate-from-anchor.md) maps every construct, and `typesol port`
-starts from your program's IDL. Tests use `typesol/testing` (accounts by name, plain values; [docs/test-your-program.md](docs/test-your-program.md)). To go to
+Coming from Anchor: [docs/migrate-from-anchor.md](docs/migrate-from-anchor.md) maps every construct, `typesol port`
+starts from your program's IDL, and [docs/case-study-escrow.md](docs/case-study-escrow.md) follows one complete Anchor
+program through the port. Tests use `typesol/testing` (accounts by name, plain values; [docs/test-your-program.md](docs/test-your-program.md)). To go to
 mainnet (wallet, cost, deploy, IDL, verification), follow [docs/mainnet.md](docs/mainnet.md).
 
 ## How it works
@@ -232,7 +233,9 @@ Subpath exports: `typesol/compiler`, `typesol/workspace`, `typesol/cpi`, `typeso
 
 The same counter, vault and escrow programs, written four ways. All four use the same instruction encoding, account
 layout and checks. They get identical transactions in LiteSVM and must end in identical account state. The table
-shows mean compute units per call (generated by `scripts/readme-bench.ts` from the benchmark run):
+shows mean compute units per call (generated by `scripts/readme-bench.ts` from the benchmark run). The programs,
+scenarios and harness are in [typesol/benchmarks](https://github.com/typesol/benchmarks), which pins the compiler and
+toolchain and records them with every result:
 
 <!-- bench:table -->
 | Instruction | TypeSOL | Pinocchio 0.10 | Native Rust | Anchor 1.0.2 |
@@ -244,9 +247,9 @@ shows mean compute units per call (generated by `scripts/readme-bench.ts` from t
 | vault.withdraw | **315** | 370 | 1,176 | 3,628 |
 | vault.shut | **161** | 167 | 950 | 2,024 |
 | escrow.make | **3,605** | 6,179 | 9,240 | 13,304 |
-| escrow.take | **4,035** | 4,051 | 8,500 | 14,365 |
-| escrow.refund | **2,716** | 2,769 | 5,695 | 8,449 |
-| binary, counter / vault / escrow | 13.1 / 16.5 / 23.9 KB | 19.6 / 22.9 / 29.4 KB | 27.9 / 35.0 / 46.5 KB | 145.2 / 158.9 / 190.7 KB |
+| escrow.take | **4,019** | 4,051 | 8,500 | 14,365 |
+| escrow.refund | **2,696** | 2,769 | 5,695 | 8,449 |
+| binary, counter / vault / escrow | 11.0 / 14.1 / 21.3 KB | 19.6 / 22.9 / 29.4 KB | 27.9 / 35.0 / 46.5 KB | 145.2 / 158.9 / 190.7 KB |
 <!-- /bench:table -->
 
 `initialize`, `open` and `make` include the PDA bump search. TypeSOL hashes PDA candidates with the sha256 and
@@ -307,7 +310,7 @@ Details are in [docs/testing.md](docs/testing.md).
 
 ## Status
 
-**TypeSOL is pre-1.0 (0.24).** Releases follow the organization's
+**TypeSOL is pre-1.0.** Releases follow the organization's
 [versioning policy](https://github.com/typesol/.github/blob/main/VERSIONING.md); [CHANGELOG.md](CHANGELOG.md) lists every
 change.
 - The compiler, runtime and tooling have been through internal security reviews and are covered by the tests above.

package/dist/clientgen.js

@@ -32,6 +32,7 @@ export const TYPESOL_ERRORS = {
     100: "InstructionMissing",
     101: "InstructionFallbackNotFound",
     102: "InstructionDidNotDeserialize",
+    2000: "ConstraintMut",
     2001: "ConstraintHasOne",
     2002: "ConstraintSigner",
     2004: "ConstraintOwner",
@@ -45,6 +46,8 @@ export const TYPESOL_ERRORS = {
     2016: "ConstraintMintMintAuthority",
     2017: "ConstraintMintFreezeAuthority",
     2018: "ConstraintMintDecimals",
+    2021: "ConstraintTokenTokenProgram",
+    2022: "ConstraintMintTokenProgram",
     2040: "ConstraintDuplicateMutableAccount",
     3000: "AccountDiscriminatorAlreadySet",
     3002: "AccountDiscriminatorMismatch",
@@ -1102,7 +1105,10 @@ function generate(idl, opts) {
         // A seed or program path names an account: in the same group first, then at the top level.
         const byPath = (p, group) => flat.find((f) => `${f.group}${f.name}` === `${group}${p}`) ?? flat.find((f) => f.group === "" && f.name === p);
         const argType = new Map(ix.args.map((a) => [a.name, a.type]));
-        const seedExpr = (s, group) => {
+        const seedsProp = (k) => `seeds${NAME.test(k) && !JS_RESERVED.has(k) ? `.${k}` : `[${JSON.stringify(k)}]`}`;
+        const BUILDER = { arg: (n) => `args.${n}`, account: (k) => `$${k}` };
+        const HELPER = { arg: (n) => seedsProp(n), account: (k) => seedsProp(k) };
+        const seedExpr = (s, group, refs = BUILDER) => {
             if (s.kind === "const")
                 return bytes(s.value);
             if (s.kind === "arg") {
@@ -1111,7 +1117,7 @@ function generate(idl, opts) {
                 let t = argType.get(head);
                 if (t === undefined)
                     return { why: `the seed argument ${head} does not exist` };
-                let v = `args.${camel(head)}`;
+                let v = refs.arg(camel(head));
                 for (const part of rest) {
                     const d = defs.get(definedName(t) ?? "");
                     const f = d?.type.kind === "struct" ? (d.type.fields ?? []).find((x) => isField(x) && x.name === part) : undefined;
@@ -1134,25 +1140,30 @@ function generate(idl, opts) {
             if (!target)
                 return { why: `the seed account ${s.path} is not an account of the instruction` };
             use("getAddressEncoder");
-            return `getAddressEncoder().encode(key($${target.key}))`;
+            return `getAddressEncoder().encode(key(${refs.account(target.key)}))`;
         };
-        const resolvable = new Map();
-        for (const a of flat) {
-            if (!a.pda || a.address)
-                continue;
-            const seeds = a.pda.seeds.map((s) => seedExpr(s, a.group));
-            let program;
+        /** A PDA's program as the code being written names it (undefined: this program). */
+        const pdaProgram = (a, refs) => {
             const p = a.pda.program;
             if (p?.kind === "const")
-                program = (use("getAddressDecoder"), `programFromBytes(${bytes(p.value)})`);
-            else if (p?.kind === "account") {
+                return (use("getAddressDecoder"), `programFromBytes(${bytes(p.value)})`);
+            if (p?.kind === "account") {
                 const target = p.path.includes(".") ? undefined : byPath(p.path, a.group);
-                program = target ? `key($${target.key})` : { why: `the PDA program ${p.path} is not an account of the instruction` };
+                return target ? `key(${refs.account(target.key)})` : { why: `the PDA program ${p.path} is not an account of the instruction` };
             }
-            else if (p?.kind === "arg") {
+            if (p?.kind === "arg") {
                 const t = p.path.includes(".") ? undefined : argType.get(p.path);
-                program = t === "pubkey" || t === "publicKey" ? `args.${camel(p.path)}` : { why: "the PDA program comes from an argument that is not a Pubkey" };
+                return t === "pubkey" || t === "publicKey" ? refs.arg(camel(p.path)) : { why: "the PDA program comes from an argument that is not a Pubkey" };
             }
+            return undefined;
+        };
+        const resolvable = new Map();
+        for (const a of flat) {
+            if (!a.pda || a.address)
+                continue;
+            const seeds = a.pda.seeds.map((s) => seedExpr(s, a.group));
+            const program = pdaProgram(a, BUILDER);
+            const p = a.pda.program;
             const why = [...seeds, ...(program === undefined ? [] : [program])].find((x) => typeof x === "object");
             if (why) {
                 notes.push(`instruction ${ix.name}: ${a.name} is not filled in (${why.why}); pass it`);
@@ -1228,11 +1239,13 @@ function generate(idl, opts) {
                     return [k, `${k}: Address | TransactionSigner`];
                 })).values(),
             ];
-            const rewrite = (e) => e.replace(/\bargs\.([A-Za-z0-9_$]+)/g, "seeds.$1").replace(/key\(\$([A-Za-z0-9_]+)\)/g, "key(seeds.$1)");
+            // The same derivation, its inputs named as the helper's `seeds` parameter.
+            const helperSeeds = a.pda.seeds.map((s) => seedExpr(s, a.group, HELPER));
+            const helperProgram = pdaProgram(a, HELPER) ?? "PROGRAM_ADDRESS";
             use("type ProgramDerivedAddress");
             pdaFns.set(pn, {
                 json,
-                source: `    /** The ${a.name} PDA (as ${ix.name} derives it). */\n    ${prop(pn)}(seeds: { ${params.join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${rewrite(r.program ?? "PROGRAM_ADDRESS")}, seeds: [${r.seeds.map(rewrite).join(", ")}] });\n    },`,
+                source: `    /** The ${a.name} PDA (as ${ix.name} derives it). */\n    ${prop(pn)}(seeds: { ${params.join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${helperProgram}, seeds: [${helperSeeds.join(", ")}] });\n    },`,
             });
         }
         const metas = flat.map((a) => {
@@ -1326,6 +1339,7 @@ function generate(idl, opts) {
             }
             const bases = new Map();
             const seeds = [];
+            const helperSeeds = []; // the same seeds, named as a `pdas` helper's `seeds` (for one seeded from its own fields)
             const own = [];
             // Inputs of a `pdas` helper for a PDA seeded from its own fields: its own field values, accounts and arguments.
             const params = new Map();
@@ -1334,13 +1348,14 @@ function generate(idl, opts) {
             let usesArgs = p?.kind === "arg";
             for (const sd of a.pda.seeds) {
                 if (sd.kind === "const")
-                    seeds.push(bytes(sd.value));
+                    (seeds.push(bytes(sd.value)), helperSeeds.push(bytes(sd.value)));
                 else if (sd.kind === "arg") {
                     const e = seedExpr(sd, a.group);
                     if (typeof e !== "string")
                         ok = false;
                     else {
                         seeds.push(e);
+                        helperSeeds.push(seedExpr(sd, a.group, HELPER));
                         usesArgs = true;
                         const head = sd.path.split(".")[0];
                         params.set(camel(head), `${camel(head)}: ${tsType(argType.get(head), "in")}`);
@@ -1353,6 +1368,7 @@ function generate(idl, opts) {
                     else {
                         use("getAddressEncoder");
                         seeds.push(`getAddressEncoder().encode(key(${acc(t)}!))`);
+                        helperSeeds.push(`getAddressEncoder().encode(key(${seedsProp(t.key)}))`);
                         params.set(t.key, `${t.key}: Address | TransactionSigner`);
                         if (auto(t))
                             autoDep = true;
@@ -1370,6 +1386,7 @@ function generate(idl, opts) {
                         own.push({ field: parts[1], type: field.type });
                         params.set(camel(parts[1]), `${camel(parts[1])}: ${tsType(field.type, "in")}`);
                         seeds.push(enc);
+                        helperSeeds.push(enc);
                     }
                     else if (!consts || auto(base))
                         ok = false;
@@ -1399,13 +1416,11 @@ function generate(idl, opts) {
                     continue;
                 if (p?.kind === "arg")
                     params.set(camel(p.path), `${camel(p.path)}: Address`);
-                const rewrite = (e) => e
-                    .replace(/\bargs\.([A-Za-z0-9_$]+)/g, "seeds.$1")
-                    .replace(/key\(ownProp\(acc, "([^"]+)"\)!\)/g, (_, k) => `key(seeds${NAME.test(k) && !JS_RESERVED.has(k) ? `.${k}` : `[${JSON.stringify(k)}]`})`);
+                const helperProgram = p?.kind === "arg" ? seedsProp(camel(p.path)) : program;
                 use("type ProgramDerivedAddress", "getProgramDerivedAddress");
                 pdaFns.set(pn, {
                     json,
-                    source: `    /** The ${a.name} PDA (as ${ix.name} derives it), from the values of its own fields it is seeded with (${own.map((o) => camel(o.field)).join(", ")}). */\n    ${prop(pn)}(seeds: { ${[...params.values()].join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${rewrite(program)}, seeds: [${seeds.map(rewrite).join(", ")}] });\n    },`,
+                    source: `    /** The ${a.name} PDA (as ${ix.name} derives it), from the values of its own fields it is seeded with (${own.map((o) => camel(o.field)).join(", ")}). */\n    ${prop(pn)}(seeds: { ${[...params.values()].join("; ")} }): Promise<ProgramDerivedAddress> {\n      return getProgramDerivedAddress({ programAddress: ${helperProgram}, seeds: [${helperSeeds.join(", ")}] });\n    },`,
                 });
                 continue;
             }

package/dist/compiler/analyze.js

@@ -680,7 +680,7 @@ export function analyze(entry) {
             dataEnums,
             options,
             constants,
-            events: new Set(),
+            events: collectEvents([...functions, ...helperNodes], structs),
             accountStructs,
             argStructs,
             fstrings,
@@ -1164,6 +1164,26 @@ function fnParamType(arrow, checker) {
     }
     return undefined;
 }
+/**
+ * The structs a program emits (`emit<T>(…)` / `emitCpi<T>(…)` anywhere in its functions and helpers), known before
+ * any code is emitted, so the IDL and the event checks do not depend on the order code is emitted in.
+ */
+function collectEvents(sources, structs) {
+    const events = new Set();
+    for (const { node, imports } of sources) {
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+                const name = imports.get(n.expression.text);
+                const t = n.typeArguments?.[0];
+                if ((name === "emit" || name === "emitCpi") && t && ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName) && structs.has(t.typeName.text))
+                    events.add(t.typeName.text);
+            }
+            ts.forEachChild(n, visit);
+        };
+        visit(node);
+    }
+    return events;
+}
 /** Whether a function returns a function: typed so, or its body is (or only returns) an arrow. */
 function returnsFunction(fn) {
     if (fn.type)
@@ -1453,6 +1473,13 @@ function analyzeInstruction(fn, reporter, scope, structs) {
                 if (entry.includes("=")) {
                     if (!accounts.some((o) => o.name === param))
                         reporter.fail(a.node, `add an account parameter named "${param}"`);
+                    if (f === "tokenProgram") {
+                        if (a.kind.kind !== "token" && a.kind.kind !== "mint")
+                            reporter.fail(a.node, "TokenOf / MintOf apply to a TokenAccount / Mint");
+                        if (accounts.find((o) => o.name === param).kind.kind !== "tokenProgram")
+                            reporter.fail(a.node, `"${param}" must be a TokenProgram, Token2022Program or TokenInterface parameter`);
+                        continue;
+                    }
                     if (a.kind.kind === "token" ? f !== "mint" && f !== "owner" : a.kind.kind === "mint" ? false : true)
                         reporter.fail(a.node, a.kind.kind === "token" || a.kind.kind === "mint" ? "TokenOf<…> applies to a TokenAccount" : "TokenOf / MintOf apply to a TokenAccount / Mint");
                     if (a.kind.kind === "mint" && f !== "mintAuthority" && f !== "freezeAuthority")
@@ -1590,12 +1617,15 @@ function unwrapConstraints(node, reporter, imports, out) {
         const one = (t) => (t && t.kind !== ts.SyntaxKind.NeverKeyword ? lit(t)[0] : undefined);
         const p1 = one(args[1]);
         const p2 = one(args[2]);
-        if (!p1 && !p2)
+        const p3 = one(args[3]);
+        if (!p1 && !p2 && !p3)
             reporter.fail(node, `${name}<…> names at least one parameter`);
         if (p1)
             out.hasOne.push(`${first}=${p1}`);
         if (p2)
             out.hasOne.push(`${second}=${p2}`);
+        if (p3)
+            out.hasOne.push(`tokenProgram=${p3}`);
     }
     if (name === "CloseTo")
         out.closeTo = lit(args[1])[0];

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

@@ -24,6 +24,16 @@ export declare abstract class EmitterBase {
     protected readonly pendingInit: Set<string>;
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     protected readonly bumps: Map<string, string>;
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    protected readonly seedArrays: Map<string, {
+        name: string;
+        scope: Map<string, Local>;
+        at: number;
+        text: string;
+    }>;
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     protected inlineFrames: {
         label: string;

package/dist/compiler/emit/base.js

@@ -23,6 +23,11 @@ export class EmitterBase {
     pendingInit = new Set();
     /** Bump temporaries from create()/createIfNeeded(), for `acct.pdaBump`. */
     bumps = new Map();
+    /**
+     * Seed arrays already declared (no spare slot, every seed read in place): the C entries, and where the array is.
+     * An identical list in the same or an inner block reuses it (see seeds()).
+     */
+    seedArrays = new Map();
     /** Closures being expanded, innermost last: a `return` inside one assigns `result` and jumps to `label`. */
     inlineFrames = [];
     /** Closures being expanded (a closure calling itself cannot be expanded). */
@@ -300,6 +305,7 @@ export class EmitterBase {
             created: new Set(this.created),
             pendingInit: new Set(this.pendingInit),
             bumps: new Map(this.bumps),
+            seedArrays: new Map(this.seedArrays),
         };
         try {
             return this.reporter.guard(fn);
@@ -322,6 +328,8 @@ export class EmitterBase {
             }
             this.bumps.clear();
             saved.bumps.forEach((v, k) => this.bumps.set(k, v));
+            this.seedArrays.clear();
+            saved.seedArrays.forEach((v, k) => this.seedArrays.set(k, v));
         }
     }
     fail(node, message) {

package/dist/compiler/emit/calls.js

@@ -3,7 +3,7 @@ import { calleeName, resolveScalarType, resolveValueType } from "../analyze.js";
 import { ANCHOR_ERRORS } from "../anchor-errors.js";
 import { decodeAddress } from "../../keys.js";
 import { INT_INFO, INT_NAMES, isScalar, isWritable, sameType, scalarSize, typeName, } from "../model.js";
-import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, emptySizeC, vecLenCheck, } from "./shared.js";
+import { U64, U8, I64, I32, BOOL, PUBKEY, STRING, HASH, cBytes, cString, scalarC, scalarStorageC, optC, valueC, fieldC, storageDecl, accountMismatch, vecCount, emptySizeC, vecLenCheck, } from "./shared.js";
 import { ExpressionEmitter } from "./expressions.js";
 /**
  * Calls: built-in functions, Vec methods, helpers, remaining accounts, foreign account reads and return data.
@@ -344,29 +344,29 @@ export class CallEmitter extends ExpressionEmitter {
                 return { c: `ts_secp256k1_verify(${h.c}, (uint64_t)${id.c}, ${r.c}, ${sv.c}, ${eth.c})`, type: BOOL };
             }
             case "pythPrice": {
-                if (args.length !== 3)
-                    this.fail(node, "pythPrice(update, feedId, maxAgeSeconds) takes three arguments");
+                if (args.length !== 3 && args.length !== 4)
+                    this.fail(node, "pythPrice(update, feedId, maxAgeSeconds, exponent?) takes three or four arguments");
                 const u = this.accountParam(args[0], "the price update");
                 if (u.kind.kind !== "pyth")
                     this.fail(args[0], "pass a PythPriceUpdate parameter");
-                const [feed, age] = this.lowerInOrder(args.slice(1), [HASH, U64]);
+                const [feed, age, expo] = this.lowerInOrder(args.slice(1), [HASH, U64, I32]);
                 const t = this.tmp("px");
                 this.line(`int64_t ${t};`);
-                this.line(`TS_TRY(ts_pyth_price(a_${u.name}, ${feed.c}, ${age.c}, &${t}));`);
+                this.line(`TS_TRY(ts_pyth_price(a_${u.name}, ${feed.c}, ${age.c}, ${expo ? `true, ${expo.c}` : "false, 0"}, &${t}));`);
                 return { c: t, type: I64 };
             }
             case "switchboardValue": {
                 // Anyone can create a Switchboard feed: like pythPrice's feed id, the expected feed address is required.
-                if (args.length !== 4)
-                    this.fail(node, "switchboardValue(feed, expectedFeed, maxStaleSlots, decimals) takes four arguments");
+                if (args.length !== 4 && args.length !== 5)
+                    this.fail(node, "switchboardValue(feed, expectedFeed, maxStaleSlots, decimals, minSamples?) takes four or five arguments");
                 const f = this.accountParam(args[0], "the feed");
                 if (f.kind.kind !== "switchboard")
                     this.fail(args[0], "pass a SwitchboardFeed parameter");
-                const [expected, stale, dec] = this.lowerInOrder(args.slice(1), [PUBKEY, U64, U8]);
+                const [expected, stale, dec, min] = this.lowerInOrder(args.slice(1), [PUBKEY, U64, U8, U8]);
                 const t = this.tmp("sb");
                 this.line(`int64_t ${t};`);
                 this.line(`if (!ts_key_eq(&a_${f.name}->key, ${expected.c})) TS_FAIL(TS_ERR_ORACLE, "TypeSOL: not the expected Switchboard feed");`);
-                this.line(`TS_TRY(ts_switchboard_value(a_${f.name}, ${stale.c}, ${dec.c}, &${t}));`);
+                this.line(`TS_TRY(ts_switchboard_value(a_${f.name}, ${stale.c}, ${dec.c}, ${min ? min.c : "1"}, &${t}));`);
                 return { c: t, type: I64 };
             }
             case "associatedTokenAddress": {
@@ -980,7 +980,7 @@ export class CallEmitter extends ExpressionEmitter {
                 this.line(l);
         if (mut) {
             this.line(`TS_TRY(ts_check_writable(${h}));`);
-            this.line(`TS_TRY(ts_check_unaliased(params, ${h}));`);
+            this.line(`TS_TRY(ts_claim_mut(params, ${h}));`);
         }
         return { c: `((TSS_${s.name} *)(${h}->data + 8))`, type: { kind: "structRef", struct: s.name, writable: mut } };
     }

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

@@ -103,8 +103,17 @@ export declare abstract class CpiEmitter extends CallEmitter {
     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. */
+    /**
+     * Metaplex Core: assets and collections (with plugins), plugins and external plugin adapters added, updated, written
+     * and removed, transfer and burn. Each method is a row of CORE_OPS below: its accounts in order, its data.
+     */
     protected coreOp(node: ts.CallExpression, core: AccountParam, method: string): undefined;
+    /**
+     * Core instructions: `args` fixed arguments (then an optional plugin list when `plugins`, then optional signer
+     * seeds), accounts in order (`[argument, label, writable, signer]`, or "self": the Core program, Core's "none" for an
+     * optional account), at most `max` bytes of data.
+     */
+    private coreOps;
     /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
     private coreProps;
     /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */