@typesol/cli 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -5,6 +5,43 @@ until 1.0, a minor version may change the language, the IDL layout or error code
 
 ## Unreleased
 
+## 0.20.0 — 2026-10-28
+
+The generated TypeScript clients catch up with Anchor's: remaining accounts, listing and watching accounts, sending
+and simulating, views, `emitCpi` events and every Anchor error by name. Programs and their bytes are unchanged. Not
+externally audited (see SECURITY.md).
+
+### Added
+- Generated clients: remaining accounts on every instruction builder; `accounts.<Name>.fetchMultiple`, `fetchAll`
+  (getProgramAccounts by discriminator, with `{ offset, bytes }` filters) and `watch` (account subscription);
+  `sendInstructions` (send and confirm), `simulate`, and `views.<instruction>` (a return value by simulation, Anchor's
+  `.view()`); `parseCpiEvents` / `eventsOf` for `emitCpi` events, and `watchEvents` (log subscription). Every Anchor
+  framework error has its name in `errors`, so `isError` knows the codes `AnchorError` and the constraints raise.
+
+## 0.19.0 — 2026-10-28
+
+Anchor's error codes where TypeSOL raised its own: `TokenOf` / `MintOf` constraints that name the parameters as
+`token::mint = …` does, every Anchor `ErrorCode` for `require`, and `init_if_needed` mints with extensions checked as
+Anchor checks them. Strings and logs cost up to a third fewer compute units. 30 of the 46 official examples are now
+full ports. Existing programs keep their layouts and error codes. Not externally audited (see SECURITY.md).
+
+### Added
+- `TokenOf<TokenAccount, "mintParam", "authorityParam">` and `MintOf<Mint, "authorityParam", "freezeParam">`: Anchor's
+  `token::mint = …` / `mint::authority = …` naming the parameters (2014 / 2015 / 2016 / 2017).
+- `AnchorError`: Anchor's own error codes for `require(condition, AnchorError.X)` (`RequireKeysEqViolated`,
+  `AccountDidNotDeserialize`, the extension constraints …), as `require!` / `err!` with `ErrorCode` raise them.
+- Extensions on `InitIfNeeded<Mint>`: an existing mint is checked as Anchor's `extensions::…` constraints check it
+  (2024–2039).
+- Bubblegum `mintToCollection` (MintToCollectionV1 on V1 trees, Token Metadata collections).
+
+### Changed
+- Strings are built with less work and heap: a template literal is joined in one allocation (it was copied piece by
+  piece), text known at compile time (literals, string and Pubkey constants) is folded in, `s += …` and `a + b` grow
+  the newest heap string in place, and base58 of a Pubkey is about 20% cheaper. Results are the same; official
+  examples that log addresses use 11–36% fewer compute units (set_favorites 10,244 → 6,601, transfer_tokens
+  9,760 → 8,467, create_system_account 4,664 → 4,075, go_to_park 435 → 372); binaries of programs that build
+  strings grow by up to 2.4 KB.
+
 ## 0.18.0 — 2026-10-28
 
 The remaining Anchor differences, closed: Anchor's argument structs (Strings, Vecs, Options and enums in Borsh),

package/README.md

@@ -306,7 +306,7 @@ Details are in [docs/testing.md](docs/testing.md).
 
 ## Status
 
-**TypeSOL is pre-1.0 (0.18).** Releases follow the organization's
+**TypeSOL is pre-1.0 (0.20).** 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.d.ts

@@ -90,7 +90,10 @@ export interface ClientGenResult {
 /** An IDL the generator refuses: malformed, unsafe to embed, or older than the 0.30 IDL format. */
 export declare class ClientIdlError extends Error {
 }
-/** TypeSOL runtime and Anchor framework errors a TypeSOL program can return, by code (runtime/typesol_rt.h). */
+/**
+ * Errors a TypeSOL program can return, by code: every Anchor framework error (`AnchorError` raises any of them, and
+ * the constraints raise their Anchor codes), then TypeSOL's own runtime errors (runtime/typesol_rt.h).
+ */
 export declare const TYPESOL_ERRORS: Record<number, string>;
 export declare function generateClient(idl: ClientIdl, opts?: {
     address?: string;

package/dist/clientgen.js

@@ -18,12 +18,17 @@
  * sanitized comments.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
+import { ANCHOR_ERRORS } from "./compiler/anchor-errors.js";
 import path from "node:path";
 /** An IDL the generator refuses: malformed, unsafe to embed, or older than the 0.30 IDL format. */
 export class ClientIdlError extends Error {
 }
-/** TypeSOL runtime and Anchor framework errors a TypeSOL program can return, by code (runtime/typesol_rt.h). */
+/**
+ * Errors a TypeSOL program can return, by code: every Anchor framework error (`AnchorError` raises any of them, and
+ * the constraints raise their Anchor codes), then TypeSOL's own runtime errors (runtime/typesol_rt.h).
+ */
 export const TYPESOL_ERRORS = {
+    ...Object.fromEntries(Object.entries(ANCHOR_ERRORS).map(([name, code]) => [code, name])),
     100: "InstructionMissing",
     101: "InstructionFallbackNotFound",
     102: "InstructionDidNotDeserialize",
@@ -164,7 +169,24 @@ const TAKEN = [
     "globalThis",
 ];
 const KIT_TYPES = [
+    "AccountMeta",
+    "AccountNotificationsApi",
     "Address",
+    "Base58EncodedBytes",
+    "Commitment",
+    "FetchAccountsConfig",
+    "GetEpochInfoApi",
+    "GetLatestBlockhashApi",
+    "GetMultipleAccountsApi",
+    "GetProgramAccountsApi",
+    "GetSignatureStatusesApi",
+    "LogsNotificationsApi",
+    "RpcSubscriptions",
+    "SendTransactionApi",
+    "Signature",
+    "SignatureNotificationsApi",
+    "SimulateTransactionApi",
+    "SlotNotificationsApi",
     "Codec",
     "FetchAccountConfig",
     "GetAccountInfoApi",
@@ -176,6 +198,21 @@ const KIT_TYPES = [
 ];
 const KIT_VALUES = [
     "AccountRole",
+    "appendTransactionMessageInstructions",
+    "assertIsTransactionWithBlockhashLifetime",
+    "compileTransaction",
+    "createTransactionMessage",
+    "fetchEncodedAccounts",
+    "getBase58Decoder",
+    "getBase58Encoder",
+    "getBase64EncodedWireTransaction",
+    "getSignatureFromTransaction",
+    "pipe",
+    "sendAndConfirmTransactionFactory",
+    "setTransactionMessageFeePayer",
+    "setTransactionMessageFeePayerSigner",
+    "setTransactionMessageLifetimeUsingBlockhash",
+    "signTransactionMessageWithSigners",
     "SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM",
     "addCodecSizePrefix",
     "address",
@@ -214,7 +251,22 @@ const KIT_VALUES = [
     "transformCodec",
 ];
 // Keys of the program object that instructions must not take.
-const PROGRAM_KEYS = new Set(["address", "accounts", "pdas", "returns", "errors", "errorCode", "isError", "parseEvents"]);
+const PROGRAM_KEYS = new Set([
+    "address",
+    "accounts",
+    "pdas",
+    "returns",
+    "views",
+    "errors",
+    "errorCode",
+    "isError",
+    "parseEvents",
+    "parseCpiEvents",
+    "eventsOf",
+    "watchEvents",
+    "sendInstructions",
+    "simulate",
+]);
 // snake_case → camelCase by splitting (linear time, whatever the input): "taker_token_a" → "takerTokenA".
 const camel = (s) => s
     .split("_")
@@ -699,6 +751,24 @@ export function generateClient(idl, opts = {}) {
             `    const found = await fetchEncodedAccount(rpc, at, config);\n` +
             `    return found.exists ? ${A}.decode(found.data) : null;\n` +
             `  },\n` +
+            `  /** Several accounts in one request, in order; null where one does not exist. */\n` +
+            `  async fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, at: readonly Address[], config?: FetchAccountsConfig): Promise<(${T} | null)[]> {\n` +
+            `    const found = await fetchEncodedAccounts(rpc, [...at], config);\n` +
+            `    return found.map((a) => (a.exists ? ${A}.decode(a.data) : null));\n` +
+            `  },\n` +
+            `  /** Every ${commentText(a.name)} account of the program (getProgramAccounts by discriminator), optionally where \`bytes\` are at \`offset\` of the data. */\n` +
+            `  async fetchAll(rpc: Rpc<GetProgramAccountsApi>, filters: readonly { offset: number; bytes: ReadonlyUint8Array }[] = []): Promise<{ address: Address; data: ${T} }[]> {\n` +
+            `    const found = await rpc.getProgramAccounts(PROGRAM_ADDRESS, { encoding: "base64", filters: memcmp([{ offset: 0, bytes: ${A}_DISCRIMINATOR }, ...filters]) }).send();\n` +
+            `    return found.map((a) => ({ address: a.pubkey, data: ${A}.decode(getBase64Encoder().encode(a.account.data[0])) }));\n` +
+            `  },\n` +
+            `  /** Each change of the account, decoded (null once it is closed), until \`abortSignal\` aborts. */\n` +
+            `  async *watch(rpcSubscriptions: RpcSubscriptions<AccountNotificationsApi>, at: Address, options: { abortSignal: AbortSignal; commitment?: Commitment }): AsyncGenerator<${T} | null> {\n` +
+            `    const updates = await rpcSubscriptions.accountNotifications(at, { encoding: "base64", ...(options.commitment ? { commitment: options.commitment } : {}) }).subscribe({ abortSignal: options.abortSignal });\n` +
+            `    for await (const u of updates) {\n` +
+            `      const data = getBase64Encoder().encode(u.value.data[0]);\n` +
+            `      yield data.length === 0 ? null : ${A}.decode(data);\n` +
+            `    }\n` +
+            `  },\n` +
             `};\n`);
         accountKeys.push(`${prop(a.name)}: ${A}`);
     }
@@ -724,6 +794,7 @@ export function generateClient(idl, opts = {}) {
     const ixKeys = [];
     const pdaFns = new Map();
     const returnKeys = [];
+    const viewKeys = [];
     const usedKeys = new Set();
     for (const ix of idl.instructions) {
         const argIssue = ix.args.map((a) => issue(a.type)).find(Boolean);
@@ -825,7 +896,7 @@ export function generateClient(idl, opts = {}) {
             resolvable.delete(a.key);
         }
         const auto = (a) => Boolean(a.address) || resolvable.has(a.key);
-        use("type Address", "type TransactionSigner", "type Instruction", "AccountRole");
+        use("type Address", "type TransactionSigner", "type Instruction", "type AccountMeta", "AccountRole");
         const accType = (a) => `${a.signer ? "TransactionSigner | Address" : "Address"}${a.optional ? " | null" : ""}`;
         const accountsIface = `export interface ${P}Accounts {\n` +
             flat.map((a) => `${doc(a.docs, "  ")}  ${prop(a.key)}${auto(a) || a.optional ? "?" : ""}: ${accType(a)};`).join("\n") +
@@ -896,16 +967,25 @@ export function generateClient(idl, opts = {}) {
             : bytes(ix.discriminator);
         ixOut.push(accountsIface +
             argsIface +
-            `${doc(ix.docs)}async function build${P}(input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}): Promise<Instruction> {\n` +
+            `${doc(ix.docs)}async function build${P}(input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}, remaining: readonly AccountMeta[] = []): Promise<Instruction> {\n` +
             lines.join("\n") +
-            `\n  return {\n    programAddress: PROGRAM_ADDRESS,\n    accounts: [\n${metas.join("\n")}\n    ],\n    data: ${data},\n  } as Instruction;\n}\n`);
+            `\n  return {\n    programAddress: PROGRAM_ADDRESS,\n    accounts: [\n${metas.join("\n")}\n      ...remaining,\n    ],\n    data: ${data},\n  } as Instruction;\n}\n`);
         ixKeys.push(`${prop(fn)}: build${P}`);
         if (ix.returns !== undefined) {
             const why = issue(ix.returns);
             if (why)
                 notes.push(`instruction ${ix.name}: the return value is not decoded (${why})`);
-            else
+            else {
                 returnKeys.push(`    ${prop(fn)}: (data: ReadonlyUint8Array): ${tsType(ix.returns, "out")} => ${codec(ix.returns)}.decode(data),`);
+                // Read-only call: simulate the instruction and decode what it returns (Anchor's `.view()`).
+                viewKeys.push(`    /** ${ix.name}'s return value, by simulation (nothing is sent). */\n` +
+                    `    async ${prop(fn)}(rpc: Rpc<SimulateTransactionApi & GetLatestBlockhashApi>, feePayer: Address | TransactionSigner, input: ${P}Accounts${argsField.length ? `, args: ${P}Args` : ""}): Promise<${tsType(ix.returns, "out")}> {\n` +
+                    `      const res = await simulate(rpc, feePayer, [await build${P}(input${argsField.length ? ", args" : ""})]);\n` +
+                    `      if (res.err !== null) throw new Error(${JSON.stringify(`${ix.name} failed in simulation: `)} + JSON.stringify(res.err, (_, v) => (typeof v === "bigint" ? v.toString() : v)) + "\\n" + res.logs.join("\\n"));\n` +
+                    `      if (res.returnData === null) throw new Error(${JSON.stringify(`${ix.name} returned nothing`)});\n` +
+                    `      return ${codec(ix.returns)}.decode(res.returnData);\n` +
+                    `    },`);
+            }
         }
     }
     // ---- Assemble ---------------------------------------------------------------------------------------------
@@ -961,6 +1041,13 @@ export function generateClient(idl, opts = {}) {
             ],
         },
         { name: "programFromBytes", lines: [`const programFromBytes = (b: Uint8Array): Address => getAddressDecoder().decode(b);`] },
+        {
+            name: "memcmp",
+            lines: [
+                `const memcmp = (filters: readonly { offset: number; bytes: ReadonlyUint8Array }[]) =>`,
+                `  filters.map((f) => ({ memcmp: { offset: BigInt(f.offset), bytes: getBase58Decoder().decode(f.bytes) as Base58EncodedBytes, encoding: "base58" as const } }));`,
+            ],
+        },
     ];
     if (needsFixedString)
         helperDefs.push({
@@ -1078,30 +1165,113 @@ export function generateClient(idl, opts = {}) {
         "",
         `// ---- Events ----`,
         `export type Event = ${events.length ? events.map((e) => `{ name: ${JSON.stringify(e.name)}; data: ${tsName(e.name)} }`).join(" | ") : "never"};`,
+        `/** One event's bytes (discriminator, then the fields), or null when they are not one of this program's events. */`,
+        `function decodeEvent(data: ReadonlyUint8Array): Event | null {`,
+        events.length
+            ? [
+                `  try {`,
+                ...events.map((e) => `    if (hasPrefix(data, ${bytes(e.discriminator)})) return { name: ${JSON.stringify(e.name)}, data: get${tsName(e.name)}Codec().decode(data, ${e.discriminator.length}) };`),
+                `  } catch {`,
+                `    // not one of this program's events`,
+                `  }`,
+                `  return null;`,
+            ].join("\n")
+            : `  void data;\n  return null;`,
+        `}`,
         `/**`,
         ` * Events in a transaction's log messages (\`Program data:\` lines, as \`emit\` writes them). Lines are matched by`,
         ` * discriminator, whichever program wrote them; lines that do not decode are skipped. \`emitCpi\` events travel in inner`,
-        ` * instructions, not logs.`,
+        ` * instructions: see parseCpiEvents and eventsOf.`,
         ` */`,
         `export function parseEvents(logs: readonly string[]): Event[] {`,
-        events.length
-            ? [
-                `  const found: Event[] = [];`,
-                `  for (const line of logs) {`,
-                `    if (!line.startsWith("Program data: ")) continue;`,
-                `    try {`,
-                `      const data = getBase64Encoder().encode(line.slice("Program data: ".length));`,
-                ...events.map((e) => `      if (hasPrefix(data, ${bytes(e.discriminator)})) found.push({ name: ${JSON.stringify(e.name)}, data: get${tsName(e.name)}Codec().decode(data, ${e.discriminator.length}) });`),
-                `    } catch {`,
-                `      // not one of this program's events`,
-                `    }`,
-                `  }`,
-                `  return found;`,
-            ].join("\n")
-            : `  void logs;\n  return [];`,
+        `  const found: Event[] = [];`,
+        `  for (const line of logs) {`,
+        `    if (!line.startsWith("Program data: ")) continue;`,
+        `    let data: ReadonlyUint8Array;`,
+        `    try {`,
+        `      data = getBase64Encoder().encode(line.slice("Program data: ".length));`,
+        `    } catch {`,
+        `      continue;`,
+        `    }`,
+        `    const e = decodeEvent(data);`,
+        `    if (e) found.push(e);`,
+        `  }`,
+        `  return found;`,
+        `}`,
+        `/** \`emitCpi\` events: the data of inner instructions (bytes, or base58 as RPC returns them) that carry one. */`,
+        `export function parseCpiEvents(instructionData: Iterable<ReadonlyUint8Array | string>): Event[] {`,
+        `  const tag = new Uint8Array([228, 69, 165, 46, 81, 203, 154, 29]);`,
+        `  const found: Event[] = [];`,
+        `  for (const item of instructionData) {`,
+        `    let data: ReadonlyUint8Array;`,
+        `    try {`,
+        `      data = typeof item === "string" ? getBase58Encoder().encode(item) : item;`,
+        `    } catch {`,
+        `      continue;`,
+        `    }`,
+        `    if (!hasPrefix(data, tag)) continue;`,
+        `    const e = decodeEvent(data.slice(tag.length));`,
+        `    if (e) found.push(e);`,
+        `  }`,
+        `  return found;`,
+        `}`,
+        `/** Every event of a fetched transaction (getTransaction, json encoding): its logs, then its inner instructions. */`,
+        `export function eventsOf(tx: { meta: { logMessages?: readonly string[] | null; innerInstructions?: readonly { instructions: readonly { data: string }[] }[] | null } | null } | null): Event[] {`,
+        `  const meta = tx?.meta;`,
+        `  if (!meta) return [];`,
+        `  return [...parseEvents(meta.logMessages ?? []), ...parseCpiEvents((meta.innerInstructions ?? []).flatMap((g) => g.instructions.map((i) => i.data)))];`,
+        `}`,
+        `/** Events of every transaction that mentions the program, as their logs arrive, until \`abortSignal\` aborts. */`,
+        `export async function* watchEvents(rpcSubscriptions: RpcSubscriptions<LogsNotificationsApi>, options: { abortSignal: AbortSignal; commitment?: Commitment }): AsyncGenerator<{ signature: Signature; event: Event }> {`,
+        `  const logs = await rpcSubscriptions.logsNotifications({ mentions: [PROGRAM_ADDRESS] }, options.commitment ? { commitment: options.commitment } : {}).subscribe({ abortSignal: options.abortSignal });`,
+        `  for await (const n of logs) for (const event of parseEvents(n.value.logs)) yield { signature: n.value.signature, event };`,
         `}`,
         "",
-        `/** The ${displayName} program: instructions, accounts, PDAs, errors, events and return values. */`,
+        `// ---- Transactions ----`,
+        `/** Send instructions in one transaction paid by \`feePayer\` (signers in the accounts sign too) and wait for confirmation. */`,
+        `export async function sendInstructions(`,
+        `  connection: { rpc: Rpc<GetEpochInfoApi & GetLatestBlockhashApi & GetSignatureStatusesApi & SendTransactionApi>; rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi> },`,
+        `  feePayer: TransactionSigner,`,
+        `  instructions: readonly Instruction[],`,
+        `  options: { commitment?: Commitment; abortSignal?: AbortSignal } = {},`,
+        `): Promise<Signature> {`,
+        `  const { value: latestBlockhash } = await connection.rpc.getLatestBlockhash().send();`,
+        `  const message = pipe(`,
+        `    createTransactionMessage({ version: 0 }),`,
+        `    (m) => setTransactionMessageFeePayerSigner(feePayer, m),`,
+        `    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),`,
+        `    (m) => appendTransactionMessageInstructions(instructions, m),`,
+        `  );`,
+        `  const signed = await signTransactionMessageWithSigners(message);`,
+        `  assertIsTransactionWithBlockhashLifetime(signed);`,
+        `  await sendAndConfirmTransactionFactory(connection)(signed, { commitment: options.commitment ?? "confirmed", ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}) });`,
+        `  return getSignatureFromTransaction(signed);`,
+        `}`,
+        `/** Simulate instructions (nothing is sent, signatures are not checked): the error if any, logs, units and the program's return data. */`,
+        `export async function simulate(`,
+        `  rpc: Rpc<SimulateTransactionApi & GetLatestBlockhashApi>,`,
+        `  feePayer: Address | TransactionSigner,`,
+        `  instructions: readonly Instruction[],`,
+        `): Promise<{ err: unknown; logs: readonly string[]; unitsConsumed: bigint | null; returnData: ReadonlyUint8Array | null }> {`,
+        `  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();`,
+        `  const message = pipe(`,
+        `    createTransactionMessage({ version: 0 }),`,
+        `    (m) => setTransactionMessageFeePayer(key(feePayer), m),`,
+        `    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),`,
+        `    (m) => appendTransactionMessageInstructions(instructions, m),`,
+        `  );`,
+        `  const wire = getBase64EncodedWireTransaction(compileTransaction(message));`,
+        `  const { value } = await rpc.simulateTransaction(wire, { encoding: "base64", sigVerify: false, replaceRecentBlockhash: true }).send();`,
+        `  const ret = value.returnData;`,
+        `  return {`,
+        `    err: value.err,`,
+        `    logs: value.logs ?? [],`,
+        `    unitsConsumed: value.unitsConsumed ?? null,`,
+        `    returnData: ret && ret.programId === PROGRAM_ADDRESS ? getBase64Encoder().encode(ret.data[0]) : null,`,
+        `  };`,
+        `}`,
+        "",
+        `/** The ${displayName} program: instructions, accounts, PDAs, errors, events, return values and transactions. */`,
         `export const ${programName} = {`,
         `  address: PROGRAM_ADDRESS,`,
         ...ixKeys.map((k) => `  ${k},`),
@@ -1112,10 +1282,18 @@ export function generateClient(idl, opts = {}) {
         `  returns: {`,
         ...returnKeys,
         `  },`,
+        `  views: {`,
+        ...viewKeys,
+        `  },`,
         `  errors: ERRORS,`,
         `  errorCode,`,
         `  isError,`,
         `  parseEvents,`,
+        `  parseCpiEvents,`,
+        `  eventsOf,`,
+        `  watchEvents,`,
+        `  sendInstructions,`,
+        `  simulate,`,
         `};`,
         "",
     ];

package/dist/compiler/analyze.js

@@ -77,6 +77,8 @@ const TYPE_EXPORTS = new Set([
     "TokenMetadataProgram",
     "SwitchboardFeed",
     "HasOne",
+    "TokenOf",
+    "MintOf",
     "Seeds",
     "CloseTo",
     "Address",
@@ -1120,7 +1122,13 @@ function analyzeHelper(fn, name, display, reporter, scope, structs, skip = new S
             return { name: p.name.text, type: { kind: "signerSeeds" }, node: p };
         // Accounts the caller already checked: Signer, AccountInfo, Account<T>/Mut<T>, token accounts, programs.
         const wrapped = typesolName(p.type, scope.imports);
-        if (wrapped === "HasOne" || wrapped === "Seeds" || wrapped === "CloseTo" || wrapped === "Address" || wrapped === "Ata")
+        if (wrapped === "HasOne" ||
+            wrapped === "TokenOf" ||
+            wrapped === "MintOf" ||
+            wrapped === "Seeds" ||
+            wrapped === "CloseTo" ||
+            wrapped === "Address" ||
+            wrapped === "Ata")
             reporter.fail(p.type, "constraints belong on instruction parameters; helpers take the plain account type");
         const account = resolveAccountKind(p.type, reporter, scope.imports, structs);
         if (account.kind === "init" || account.kind === "initIfNeeded" || account.kind === "zeroed")
@@ -1270,7 +1278,17 @@ function analyzeInstruction(fn, reporter, scope, structs) {
             continue;
         const struct = a.kind.kind === "account" || a.kind.kind === "init" || a.kind.kind === "initIfNeeded" || a.kind.kind === "zeroed" ? a.kind.struct : undefined;
         reporter.guard(() => {
-            for (const f of c.hasOne) {
+            for (const entry of c.hasOne) {
+                const [f, param = f] = entry.split("=");
+                if (entry.includes("=")) {
+                    if (!accounts.some((o) => o.name === param))
+                        reporter.fail(a.node, `add an account parameter named "${param}"`);
+                    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")
+                        reporter.fail(a.node, "MintOf<…> applies to a Mint");
+                    continue;
+                }
                 if (!accounts.some((o) => o.name === f))
                     reporter.fail(a.node, `HasOne<…, "${f}">: add an account parameter named "${f}"`);
                 if (a.kind.kind === "token") {
@@ -1321,7 +1339,7 @@ function analyzeInstruction(fn, reporter, scope, structs) {
     for (const a of accounts) {
         const c = a.constraints;
         const refs = [
-            ...c.hasOne,
+            ...c.hasOne.map((e) => e.split("=").at(-1)),
             ...(c.seeds?.names ?? []).filter((n) => n.startsWith("@")).map((n) => n.slice(1).split(".")[0]),
             ...(c.seeds?.program?.startsWith("@") ? [c.seeds.program.slice(1)] : []),
             ...(c.closeTo ? [c.closeTo] : []),
@@ -1381,7 +1399,7 @@ function analyzeInstruction(fn, reporter, scope, structs) {
 /** Peel HasOne / Seeds / CloseTo wrappers off a parameter type, recording what they ask for. */
 function unwrapConstraints(node, reporter, imports, out) {
     const name = typesolName(node, imports);
-    if (!["HasOne", "Seeds", "CloseTo", "Address", "Ata", "Owner", "Executable"].includes(name ?? ""))
+    if (!["HasOne", "TokenOf", "MintOf", "Seeds", "CloseTo", "Address", "Ata", "Owner", "Executable"].includes(name ?? ""))
         return node;
     const args = node.typeArguments ?? [];
     const lit = (t) => {
@@ -1395,6 +1413,20 @@ function unwrapConstraints(node, reporter, imports, out) {
     };
     if (name === "HasOne")
         out.hasOne.push(...lit(args[1]));
+    // Anchor's `token::mint = m, token::authority = a` / `mint::authority = a, mint::freeze_authority = f` naming the
+    // parameters: recorded as "field=param" (`never` leaves one out).
+    if (name === "TokenOf" || name === "MintOf") {
+        const [first, second] = name === "TokenOf" ? ["mint", "owner"] : ["mintAuthority", "freezeAuthority"];
+        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)
+            reporter.fail(node, `${name}<…> names at least one parameter`);
+        if (p1)
+            out.hasOne.push(`${first}=${p1}`);
+        if (p2)
+            out.hasOne.push(`${second}=${p2}`);
+    }
     if (name === "CloseTo")
         out.closeTo = lit(args[1])[0];
     if (name === "Owner") {

package/dist/compiler/anchor-errors.d.ts

@@ -0,0 +1 @@
+export declare const ANCHOR_ERRORS: Record<string, number>;

package/dist/compiler/anchor-errors.js

@@ -0,0 +1,80 @@
+// Anchor's own error codes (anchor-lang ErrorCode), for `require(condition, AnchorError.X)`.
+export const ANCHOR_ERRORS = {
+    InstructionMissing: 100,
+    InstructionFallbackNotFound: 101,
+    InstructionDidNotDeserialize: 102,
+    InstructionDidNotSerialize: 103,
+    IdlInstructionStub: 1000,
+    IdlInstructionInvalidProgram: 1001,
+    IdlAccountNotEmpty: 1002,
+    EventInstructionStub: 1500,
+    ConstraintMut: 2000,
+    ConstraintHasOne: 2001,
+    ConstraintSigner: 2002,
+    ConstraintRaw: 2003,
+    ConstraintOwner: 2004,
+    ConstraintRentExempt: 2005,
+    ConstraintSeeds: 2006,
+    ConstraintExecutable: 2007,
+    ConstraintState: 2008,
+    ConstraintAssociated: 2009,
+    ConstraintAssociatedInit: 2010,
+    ConstraintClose: 2011,
+    ConstraintAddress: 2012,
+    ConstraintZero: 2013,
+    ConstraintTokenMint: 2014,
+    ConstraintTokenOwner: 2015,
+    ConstraintMintMintAuthority: 2016,
+    ConstraintMintFreezeAuthority: 2017,
+    ConstraintMintDecimals: 2018,
+    ConstraintSpace: 2019,
+    ConstraintAccountIsNone: 2020,
+    ConstraintTokenTokenProgram: 2021,
+    ConstraintMintTokenProgram: 2022,
+    ConstraintAssociatedTokenTokenProgram: 2023,
+    ConstraintMintGroupPointerExtension: 2024,
+    ConstraintMintGroupPointerExtensionAuthority: 2025,
+    ConstraintMintGroupPointerExtensionGroupAddress: 2026,
+    ConstraintMintGroupMemberPointerExtension: 2027,
+    ConstraintMintGroupMemberPointerExtensionAuthority: 2028,
+    ConstraintMintGroupMemberPointerExtensionMemberAddress: 2029,
+    ConstraintMintMetadataPointerExtension: 2030,
+    ConstraintMintMetadataPointerExtensionAuthority: 2031,
+    ConstraintMintMetadataPointerExtensionMetadataAddress: 2032,
+    ConstraintMintCloseAuthorityExtension: 2033,
+    ConstraintMintCloseAuthorityExtensionAuthority: 2034,
+    ConstraintMintPermanentDelegateExtension: 2035,
+    ConstraintMintPermanentDelegateExtensionDelegate: 2036,
+    ConstraintMintTransferHookExtension: 2037,
+    ConstraintMintTransferHookExtensionAuthority: 2038,
+    ConstraintMintTransferHookExtensionProgramId: 2039,
+    RequireViolated: 2500,
+    RequireEqViolated: 2501,
+    RequireKeysEqViolated: 2502,
+    RequireNeqViolated: 2503,
+    RequireKeysNeqViolated: 2504,
+    RequireGtViolated: 2505,
+    RequireGteViolated: 2506,
+    AccountDiscriminatorAlreadySet: 3000,
+    AccountDiscriminatorNotFound: 3001,
+    AccountDiscriminatorMismatch: 3002,
+    AccountDidNotDeserialize: 3003,
+    AccountDidNotSerialize: 3004,
+    AccountNotEnoughKeys: 3005,
+    AccountNotMutable: 3006,
+    AccountOwnedByWrongProgram: 3007,
+    InvalidProgramId: 3008,
+    InvalidProgramExecutable: 3009,
+    AccountNotSigner: 3010,
+    AccountNotSystemOwned: 3011,
+    AccountNotInitialized: 3012,
+    AccountNotProgramData: 3013,
+    AccountNotAssociatedTokenAccount: 3014,
+    AccountSysvarMismatch: 3015,
+    AccountReallocExceedsLimit: 3016,
+    AccountDuplicateReallocs: 3017,
+    DeclaredProgramIdMismatch: 4100,
+    TryingToInitPayerAsProgramAccount: 4101,
+    InvalidNumericConversion: 4102,
+    Deprecated: 5000,
+};

package/dist/compiler/emit/calls.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { calleeName, resolveScalarType } 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, } from "./shared.js";
@@ -1091,6 +1092,13 @@ export class CallEmitter extends ExpressionEmitter {
         this.fail(n, "pass signer([...seeds with the bump]) or a SignerSeeds parameter");
     }
     errorRef(node) {
+        // `AnchorError.X`: one of Anchor's own codes (not one of this program's errors, so not in the IDL).
+        if (ts.isPropertyAccessExpression(node) && this.exportName(node.expression) === "AnchorError") {
+            const code = ANCHOR_ERRORS[node.name.text];
+            if (code === undefined)
+                this.fail(node.name, `AnchorError has no ${node.name.text}`);
+            return { code, name: node.name.text, msg: node.name.text };
+        }
         if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
             const def = this.model.errorEnums.get(node.expression.text)?.get(node.name.text);
             if (def)

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

@@ -41,9 +41,10 @@ export declare abstract class CpiEmitter extends CallEmitter {
      * 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): {
+    protected mintExtensions(lit: ts.ObjectLiteralExpression, tp: string, acct: string, ifNeeded?: boolean): {
         space: number;
         lines: string[];
+        checks: string[];
     };
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`