@typesol/cli 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ until 1.0, a minor version may change the language, the IDL layout or error code
 
 ## Unreleased
 
+## 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.19).** 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/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">`

package/dist/compiler/emit/cpi.js

@@ -396,8 +396,6 @@ export class CpiEmitter extends CallEmitter {
         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>");
@@ -438,6 +436,7 @@ export class CpiEmitter extends CallEmitter {
         };
         let mint;
         const extLines = [];
+        const extChecks = [];
         let mintSpace = "TS_MINT_LEN";
         if (isMint) {
             take(a[2], U8);
@@ -447,9 +446,10 @@ export class CpiEmitter extends CallEmitter {
             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);
+                const ext = this.mintExtensions(extArg, tp, acct, ifNeeded);
                 mintSpace = String(ext.space);
                 extLines.push(...ext.lines);
+                extChecks.push(...ext.checks);
             }
         }
         else {
@@ -474,6 +474,8 @@ export class CpiEmitter extends CallEmitter {
                 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"}));`);
+                for (const l of extChecks)
+                    this.line(`  ${l}`);
                 this.line(`}`);
             }
             else
@@ -510,7 +512,7 @@ export 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.
      */
-    mintExtensions(lit, tp, acct) {
+    mintExtensions(lit, tp, acct, ifNeeded = false) {
         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)]
@@ -676,8 +678,60 @@ export class CpiEmitter extends CallEmitter {
                 }
             }
         }
+        // An existing mint (createIfNeeded) is checked as Anchor's `extensions::…` constraints check it: the extension must
+        // be there (its Anchor code) and each key must match (the next codes). Anchor has constraints for these six only.
+        const CHECKS = {
+            groupPointer: {
+                type: 20,
+                code: 2024,
+                fields: [
+                    ["authority", 0],
+                    ["groupAddress", 32],
+                ],
+            },
+            groupMemberPointer: {
+                type: 21,
+                code: 2027,
+                fields: [
+                    ["authority", 0],
+                    ["memberAddress", 32],
+                ],
+            },
+            metadataPointer: {
+                type: 18,
+                code: 2030,
+                fields: [
+                    ["authority", 0],
+                    ["metadataAddress", 32],
+                ],
+            },
+            closeAuthority: { type: 3, code: 2033, fields: [["v", 0]] },
+            permanentDelegate: { type: 12, code: 2035, fields: [["v", 0]] },
+            transferHook: {
+                type: 14,
+                code: 2037,
+                fields: [
+                    ["authority", 0],
+                    ["programId", 32],
+                ],
+            },
+        };
+        const checks = [];
+        if (ifNeeded)
+            for (const [name, v] of held) {
+                const c = CHECKS[name];
+                if (!c)
+                    this.fail(lit, `${name} cannot be checked on an existing mint (Anchor has no constraint for it): create the mint with create(…)`);
+                checks.push(`{ uint64_t eo, el; if (!ts_t22_ext(${acct}, ${c.type}, &eo, &el)) TS_FAIL(${c.code}, "TypeSOL: the mint has no ${name} extension"); }`);
+                c.fields.forEach(([f, at], i) => {
+                    const held = v.get(f);
+                    // The value given: a nonzero-or-zero key, a COption (close authority) or a plain key (permanent delegate).
+                    const want = name === "closeAuthority" ? `(${held}.some ? ${held}.v : (SolPubkey){0})` : held;
+                    checks.push(`{ SolPubkey k, w = ${want}; if (!ts_t22_key(${acct}, ${c.type}, ${at}, &k)) ts_memzero(&k, 32); if (!ts_key_eq(&k, &w)) TS_FAIL(${c.code + 1 + i}, "TypeSOL: the mint's ${name} ${f === "v" ? "key" : f} differs"); }`);
+                });
+            }
         // 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 };
+        return { space: 165 + 1 + space, lines, checks };
     }
     /**
      * `ata.create(payer)` / `ata.createIfNeeded(payer)` on `Ata<Init|InitIfNeeded<TokenAccount>, "owner", "mint">`
@@ -1847,6 +1901,58 @@ export class CpiEmitter extends CallEmitter {
                 this.cpi(p, metas, data.buf, data.len, seedsAt(13));
                 return undefined;
             }
+            case "mintToCollection": {
+                // MintToCollectionV1: MintV1's accounts plus the collection authority (signing), its record PDA (or null),
+                // the collection mint, metadata (writable) and master edition, Bubblegum's signer PDA and Token Metadata;
+                // MetadataArgs with Some({ verified: false, key: collection mint }) (Bubblegum verifies it).
+                if (a.length !== 17 && a.length !== 18)
+                    this.fail(node, "mintToCollection(treeConfig, leafOwner, leafDelegate, merkleTree, payer, treeDelegate, collectionAuthority, collectionAuthorityRecordPda | null, collectionMint, collectionMetadata, collectionEdition, bubblegumSigner, logWrapper, compressionProgram, tokenMetadataProgram, systemProgram, { name, symbol, uri, sellerFeeBasisPoints, creators?, isMutable?, editionNonce? }, signerSeeds?)");
+                const metas = [
+                    acct(0, "the tree config", true, false),
+                    acct(1, "the leaf owner", false, false),
+                    acct(2, "the leaf delegate", false, false),
+                    acct(3, "the merkle tree", true, false),
+                    acct(4, "the payer", false, true),
+                    acct(5, "the tree delegate", false, true),
+                    acct(6, "the collection authority", false, true),
+                    acct(7, "the collection authority record", false, false),
+                    acct(8, "the collection mint", false, false),
+                    acct(9, "the collection metadata", true, false),
+                    acct(10, "the collection edition", false, false),
+                    acct(11, "Bubblegum's signer", false, false),
+                    acct(12, "the log wrapper", false, false),
+                    acct(13, "the compression program", false, false),
+                    acct(14, "Token Metadata", false, false),
+                    acct(15, "the system program", false, false),
+                ];
+                const md = a[16];
+                if (!ts.isObjectLiteralExpression(md))
+                    this.fail(md, "the metadata is { name, symbol, uri, sellerFeeBasisPoints, creators?, isMutable?, editionNonce? }");
+                const props = this.literalProps(md, ["name", "symbol", "uri", "sellerFeeBasisPoints", "creators", "isMutable", "editionNonce"], "the metadata");
+                const need = (k) => props.get(k) ?? this.fail(md, `the metadata needs ${k}`);
+                // `collectionMint.key`, read where the call is.
+                const key = ts.factory.createPropertyAccessExpression(a[8], "key");
+                ts.setTextRange(key, a[8]);
+                key.parent = node;
+                const nonce = props.get("editionNonce");
+                const data = this.mplData(node, 1024, [
+                    { bytes: [153, 18, 178, 47, 197, 158, 86, 15] },
+                    { value: need("name"), type: STRING },
+                    { value: need("symbol"), type: STRING },
+                    { value: need("uri"), type: STRING },
+                    { value: need("sellerFeeBasisPoints"), type: { kind: "int", name: "u16" } },
+                    { bytes: [0] }, // primarySaleHappened
+                    props.get("isMutable") ? { value: props.get("isMutable"), type: BOOL } : { bytes: [1] },
+                    ...(nonce ? [{ bytes: [1] }, { value: nonce, type: U8 }] : [{ bytes: [0] }]),
+                    { bytes: [1, 0] }, // tokenStandard Some(NonFungible)
+                    { bytes: [1, 0] }, // collection Some({ verified: false, … })
+                    { value: key, type: PUBKEY },
+                    { bytes: [0, 0] }, // uses None, tokenProgramVersion Original
+                    ...this.bubblegumCreators(props.get("creators")),
+                ]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(17));
+                return undefined;
+            }
         }
         return this.bubblegumV2(node, bg, method);
     }
@@ -2128,7 +2234,7 @@ export class CpiEmitter extends CallEmitter {
             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}`);
+        this.fail(node.expression, `Bubblegum supports createTree, mint, mintToCollection, createTreeV2, mintV2, transferV2, burnV2, ${Object.keys(BUBBLEGUM_OPS).join(", ")}, not ${method}`);
     }
     /** Object literal properties by name, refusing others. */
     literalProps(o, allowed, what) {

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

@@ -23,6 +23,25 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
     /** Whether TypeScript sees this expression as a string (decides `+` between concatenation and arithmetic). */
     protected looksLikeString(node: ts.Expression): boolean;
     /** A string view of a string, integer or boolean (for concatenation and templates). */
+    /**
+     * A template literal's pieces in order, text known at compile time folded in: all text (`text`), or a C array of
+     * TS_Str (`arr`, `n` entries). When a later piece runs statements, earlier pieces that view account text are copied
+     * first, as JS reads them then.
+     */
+    protected templatePieces(node: ts.TemplateExpression): {
+        text: string;
+        arr?: undefined;
+        n?: undefined;
+    } | {
+        text?: undefined;
+        arr: string;
+        n: number;
+    };
+    /**
+     * The text of `${e}` when it is known at compile time: a string literal or constant, a non-negative integer
+     * literal, a boolean literal, or a Pubkey constant (its base58). Undefined otherwise.
+     */
+    protected constantText(e: ts.Expression): string | undefined;
     protected toText(node: ts.Expression): string;
     /** C statement writing the decimal text of an integer into the TS_Str `out`. */
     protected textOfInt(name: IntName, c: string, out: string): string;

package/dist/compiler/emit/expressions.js

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { base58 } from "../../keys.js";
 import { calleeName, resolveValueType } from "../analyze.js";
 import { INT_INFO, unsignedC, optionKey, sameType, typeName } from "../model.js";
 import { U64, U8, I64, BOOL, PUBKEY, STRING, HASH, cString, intLiteral, scalarStorageC, optC, valueC, vecCount } from "./shared.js";
@@ -151,22 +152,14 @@ export class ExpressionEmitter extends StorageEmitter {
             return { c: `ts_str((const uint8_t *)${cString(node.text)}, ${len})`, type: STRING, stringLiteral: node.text };
         }
         if (ts.isTemplateExpression(node)) {
-            // `a${x}b${y}c` -> concatenations on the heap
-            let acc = this.tmp("tpl");
-            const head = node.head.text;
-            this.line(`TS_Str ${acc} = ts_str((const uint8_t *)${cString(head)}, ${Buffer.byteLength(head, "utf8")});`);
-            for (const span of node.templateSpans) {
-                for (const piece of [
-                    this.toText(span.expression),
-                    `ts_str((const uint8_t *)${cString(span.literal.text)}, ${Buffer.byteLength(span.literal.text, "utf8")})`,
-                ]) {
-                    const next = this.tmp("tpl");
-                    this.line(`TS_Str ${next};`);
-                    this.line(`TS_TRY(ts_str_concat(${acc}, ${piece}, &${next}));`);
-                    acc = next;
-                }
-            }
-            return { c: acc, type: STRING };
+            // `a${x}b${y}c`: one join on the heap (or a literal when every piece is known at compile time).
+            const pieces = this.templatePieces(node);
+            if (pieces.text !== undefined)
+                return { c: `ts_str((const uint8_t *)${cString(pieces.text)}, ${Buffer.byteLength(pieces.text, "utf8")})`, type: STRING, stringLiteral: pieces.text };
+            const t = this.tmp("tpl");
+            this.line(`TS_Str ${t};`);
+            this.line(`TS_TRY(ts_str_join(${pieces.arr}, ${pieces.n}, &${t}));`);
+            return { c: t, type: STRING };
         }
         if (node.kind === ts.SyntaxKind.NullKeyword)
             return { c: "", type: BOOL, isNull: true };
@@ -430,6 +423,68 @@ export class ExpressionEmitter extends StorageEmitter {
         return isText(this.checker.getTypeAtLocation(node));
     }
     /** A string view of a string, integer or boolean (for concatenation and templates). */
+    /**
+     * A template literal's pieces in order, text known at compile time folded in: all text (`text`), or a C array of
+     * TS_Str (`arr`, `n` entries). When a later piece runs statements, earlier pieces that view account text are copied
+     * first, as JS reads them then.
+     */
+    templatePieces(node) {
+        const parts = [];
+        const lit = (text) => {
+            if (!text)
+                return;
+            const last = parts.at(-1);
+            if (last?.text !== undefined)
+                last.text += text;
+            else
+                parts.push({ text });
+        };
+        lit(node.head.text);
+        for (const span of node.templateSpans) {
+            const known = this.constantText(span.expression);
+            if (known !== undefined)
+                lit(known);
+            else {
+                const mark = this.lines.length;
+                const c = this.toText(span.expression);
+                for (const p of parts)
+                    if (p.c !== undefined)
+                        p.c = this.settle({ c: p.c, type: STRING }, mark).c;
+                parts.push({ c });
+            }
+            lit(span.literal.text);
+        }
+        if (parts.every((p) => p.text !== undefined))
+            return { text: parts.map((p) => p.text).join("") };
+        const strOf = (text) => `ts_str((const uint8_t *)${cString(text)}, ${Buffer.byteLength(text, "utf8")})`;
+        const arr = this.tmp("parts");
+        this.line(`TS_Str ${arr}[${parts.length}] = {${parts.map((p) => (p.text !== undefined ? strOf(p.text) : p.c)).join(", ")}};`);
+        return { arr, n: parts.length };
+    }
+    /**
+     * The text of `${e}` when it is known at compile time: a string literal or constant, a non-negative integer
+     * literal, a boolean literal, or a Pubkey constant (its base58). Undefined otherwise.
+     */
+    constantText(e) {
+        if (ts.isParenthesizedExpression(e))
+            return this.constantText(e.expression);
+        if (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e))
+            return e.text;
+        if (e.kind === ts.SyntaxKind.TrueKeyword)
+            return "true";
+        if (e.kind === ts.SyntaxKind.FalseKeyword)
+            return "false";
+        if (ts.isBigIntLiteral(e))
+            return BigInt(e.text.slice(0, -1).replace(/_/g, "")).toString();
+        if (ts.isIdentifier(e) && !this.lookup(e.text)) {
+            const k = this.model.constants.get(e.text);
+            if (k && typeof k.value === "string")
+                return k.value;
+            if (k && typeof k.value === "object")
+                return base58(Uint8Array.from(k.value.pubkey));
+        }
+        return undefined;
+    }
     toText(node) {
         const v = this.expr(node);
         if (v.type.kind === "string")

package/dist/compiler/emit/function.js

@@ -371,15 +371,17 @@ export class FunctionEmitter extends StatementEmitter {
             const k = a.kind.kind;
             if (c.hasOne.length && k !== "account" && k !== "token" && k !== "mint")
                 this.reporter.fail(a.node, "HasOne applies to existing accounts (Account<T> / Mut<T>), TokenAccount and Mint");
-            for (const f of c.hasOne) {
+            for (const entry of c.hasOne) {
+                // "field=param" (TokenOf / MintOf) or a field checked against the parameter of the same name (HasOne).
+                const [f, p = f] = entry.split("=");
                 if (k === "token")
                     out.push(f === "mint"
-                        ? `  if (!ts_key_eq(ts_token_mint(a_${a.name}), &a_${f}->key)) TS_FAIL(TS_ERR_TOKEN_MINT, "TypeSOL: ${a.name} is not a token account of ${f}");`
-                        : `  if (!ts_key_eq(ts_token_owner(a_${a.name}), &a_${f}->key)) TS_FAIL(TS_ERR_TOKEN_OWNER, "TypeSOL: ${a.name} is not owned by ${f}");`);
+                        ? `  if (!ts_key_eq(ts_token_mint(a_${a.name}), &a_${p}->key)) TS_FAIL(TS_ERR_TOKEN_MINT, "TypeSOL: ${a.name} is not a token account of ${p}");`
+                        : `  if (!ts_key_eq(ts_token_owner(a_${a.name}), &a_${p}->key)) TS_FAIL(TS_ERR_TOKEN_OWNER, "TypeSOL: ${a.name} is not owned by ${p}");`);
                 else if (k === "mint") {
                     const at = f === "mintAuthority" ? 0 : 46;
                     const code = f === "mintAuthority" ? "TS_ERR_MINT_AUTHORITY" : "TS_ERR_FREEZE_AUTHORITY";
-                    out.push(`  if (ts_read_le(a_${a.name}->data + ${at}, 4) != 1 || !ts_key_eq((const SolPubkey *)(a_${a.name}->data + ${at + 4}), &a_${f}->key)) TS_FAIL(${code}, "TypeSOL: ${f} is not the ${f} of ${a.name}");`);
+                    out.push(`  if (ts_read_le(a_${a.name}->data + ${at}, 4) != 1 || !ts_key_eq((const SolPubkey *)(a_${a.name}->data + ${at + 4}), &a_${p}->key)) TS_FAIL(${code}, "TypeSOL: ${p} is not the ${f} of ${a.name}");`);
                 }
                 else
                     out.push(`  if (!ts_key_eq(&d_${a.name}->${f}, &a_${f}->key)) TS_FAIL(TS_ERR_CONSTRAINT, "TypeSOL: ${a.name}.${f} must be the ${f} account");`);

package/dist/compiler/emit/statements.js

@@ -842,7 +842,24 @@ export class StatementEmitter extends CpiEmitter {
                     this.line(`TS_Str ${cur};`);
                     this.line(`TS_TRY(ts_str_copy(${current.c}, &${cur}));`);
                 }
+                // A local grows in place when it is the newest heap string (a loop of `s += …` copies each piece once); a
+                // template on the right is appended piece by piece.
+                const local = cur === current.c && place.write("X") === `${cur} = X`;
+                const bare = (e) => (ts.isParenthesizedExpression(e) ? bare(e.expression) : e);
+                const rhsNode = bare(valueNode);
+                if (local && ts.isTemplateExpression(rhsNode)) {
+                    const pieces = this.templatePieces(rhsNode);
+                    if (pieces.text !== undefined)
+                        this.line(`TS_TRY(ts_str_append(&${cur}, ts_str((const uint8_t *)${cString(pieces.text)}, ${Buffer.byteLength(pieces.text, "utf8")})));`);
+                    else
+                        this.line(`TS_TRY(ts_str_append_parts(&${cur}, ${pieces.arr}, ${pieces.n}));`);
+                    return;
+                }
                 const rhs = this.toText(valueNode);
+                if (local) {
+                    this.line(`TS_TRY(ts_str_append(&${cur}, ${rhs}));`);
+                    return;
+                }
                 const t = this.tmp("cat");
                 this.line(`TS_Str ${t};`);
                 this.line(`TS_TRY(ts_str_concat(${cur}, ${rhs}, &${t}));`);

package/docs/language.md

@@ -11,7 +11,7 @@ The full reference. For a tour, start with the [README](../README.md).
 | Integers | `u8` `u16` `u32` `u64` `u128` `i8` `i16` `i32` `i64` `i128` — bigint literals (`1n`), every `+ - * / % **` (and `+=` … `**=`) checked (`**` aborts on a negative exponent, as JS throws); `& \| ^` on equal types, `~` within the width, `<<` / `>>` checked (amount below the width, `<<` may not lose bits) |
 | Integer helpers | `mulDiv(a, b, c)` / `mulDivCeil` (u64 through a 128-bit product, u128 through a 256-bit one), `isqrt(x)` (up to u128), `min(a, b)`, `max(a, b)` |
 | Other scalars | `boolean`, `Pubkey` (compare with `===` or `.equals`) |
-| Errors | `export enum MyError { Name = "message" }` + `require(cond, MyError.Name)` → codes 6000+ |
+| Errors | `export enum MyError { Name = "message" }` + `require(cond, MyError.Name)` → codes 6000+; `require(cond, AnchorError.RequireKeysEqViolated)` fails with one of Anchor's own codes (2502 here; every anchor-lang `ErrorCode`) |
 | Casts | `u8(x)`, `u64(x)`, … abort if the value does not fit |
 | Logging | `log("text")`, `log(value)`, `log(pubkey)` |
 | Arrays | `scores: FixedArray<u64, 8>` in account data — `.get(i)`, `.set(i, v)`, `.length`, bounds-checked; elements can be structs or strings |
@@ -36,7 +36,7 @@ The full reference. For a tour, start with the [README](../README.md).
 | Constants | top-level `const SEED = "vault"`, `const FEE: u16 = 30n`, `const ON = true` — inlined, usable as seeds (and described in the IDL) |
 | Data enums | `export type Action = { kind: "Deposit"; amount: u64 } \| { kind: "Pause" }` — `a.kind === "Deposit"`, `switch (a.kind)`, TypeScript narrowing picks the variant (checked again at runtime, 5112); Borsh enums in arguments/events, fixed `{ tag, payload }` in account data. A variant may hold a `string` (`{ kind: "Say"; text: string }`): such an enum works in arguments, events and locals (Borsh, as Anchor encodes it) but not in account data |
 | Option of structs | `home: Option<Point>` in account data — `=== null`, `p.home.x` after narrowing, `p.home = null` / `{ x, y }` |
-| Strings at runtime | `"hello, " + name`, `` `#${n}` ``, `` `owner ${acct.owner}` `` (a Pubkey or Hash as base58) — built on the 32 KiB heap (5110 when full) |
+| Strings at runtime | `"hello, " + name`, `` `#${n}` ``, `` `owner ${acct.owner}` `` (a Pubkey or Hash as base58) — built on the 32 KiB heap (5110 when full): a template is joined in one allocation, text known at compile time (literals, string and Pubkey constants) is folded in, and `s += …` grows the newest heap string in place |
 | `switch` | on integers (128-bit ones too), enums and data-enum `.kind`, with JS `break` / fallthrough; case labels are literals, constants or enum members |
 | Hashing & signatures | `sha256(...)`, `keccak256(...)` → `Hash`; `findProgramAddress(seeds, program)` → the canonical PDA of any program (Rust `Pubkey::find_program_address(..).0`, e.g. a Bubblegum asset id); `merkleVerify(leaf, proof: Vec<Hash>, root)` (sorted-pair keccak, OpenZeppelin convention); `verifyEd25519(instructionsSysvar, signer, message)` checks an Ed25519 precompile instruction in the same transaction; `verifySecp256k1(keccak256(...message) | ethMessageHash(message), recoveryId, r, s, ethAddress)` (the hash must be computed in the program; a passed-in hash could be forged) |
 | Oracles | `pythPrice(update: PythPriceUpdate, feedId, maxAgeSeconds)` (fully verified, feed-matched, fresh); raw `update.price / conf / exponent / publishTime`; `switchboardValue(feed: SwitchboardFeed, expectedFeed, maxStaleSlots, decimals)` (the feed must be the expected one: anyone can create feeds) (mainnet program unless `SwitchboardFeed<"devnet">`) |
@@ -67,7 +67,7 @@ The full reference. For a tour, start with the [README](../README.md).
 | `Init<T>` | writable; `create(payer, seeds)` derives the PDA, verifies it, funds rent, writes the discriminator (up to 10 KiB); `create(payer, null)` creates a new keypair account that signs the transaction instead (3010 if it did not; a signer in the IDL); a third argument is Anchor's `space = …` (discriminator included, at least 8 + the struct's size) |
 | `InitIfNeeded<T>` | `const created = acct.createIfNeeded(payer, seeds)` — creates once; afterwards re-derives the PDA and checks owner, discriminator and size (Anchor `init_if_needed`); `acct.pdaBump` after create |
 | `HasOne<A, "owner">`, `Seeds<A, ["vault", "@owner"], "bump">`, `CloseTo<A, "owner">` | declarative constraints like Anchor's `has_one`, `seeds`/`bump` and `close`: checked before the body (2001 / 2006), close runs when the instruction succeeds; `"@name"` = account key or argument bytes, `"@acct.field"` = a Pubkey, integer or unit enum field of a struct account parameter (also the account's own: `["offer", "@maker", "@offer.id"]`), other strings are literals; recorded as `relations` / `pda` in the IDL. `acct.pdaBump` is the bump (Anchor `ctx.bumps.acct`): the stored field when one is named, else the canonical bump the check found — use it to sign as the PDA |
-| `HasOne<TokenAccount, "mint" \| "owner">`, `HasOne<Mint, "mintAuthority" \| "freezeAuthority">` | token constraints (2014 / 2015 / 2016 / 2017) against the parameter with that name |
+| `HasOne<TokenAccount, "mint" \| "owner">`, `HasOne<Mint, "mintAuthority" \| "freezeAuthority">` | token constraints (2014 / 2015 / 2016 / 2017) against the parameter with that name; `TokenOf<TokenAccount, "mintParam", "authorityParam">` / `MintOf<Mint, "authorityParam", "freezeParam">` name the parameters, as Anchor's `token::mint = …` / `mint::authority = …` do (`never` leaves one out) |
 | `Ata<TokenAccount, "owner", "mint">` | the account is the associated token account of those parameters (2009; ATA `pda` in the IDL) |
 | `Ata<Init<TokenAccount>, "owner", "mint">`, `Ata<InitIfNeeded<TokenAccount>, "owner", "mint">` | Anchor `init` / `init_if_needed` with `associated_token::…`: `acct.create(payer)` creates the ATA (fails if it exists); `const created = acct.createIfNeeded(payer)` creates it only when missing, otherwise checks it is that ATA (2009). Then it is a `TokenAccount` of that mint and owner (2014 / 2015). Needs `AssociatedTokenProgram`, `SystemProgram` and a token program parameter; call it at the top level before using the account |
 | `Address<A, "4Nd1…">` | exact address (2012; `address` in the IDL) |
@@ -77,7 +77,7 @@ The full reference. For a tour, start with the [README](../README.md).
 | `ProgramData` | this program's ProgramData (address derived from the program id, upgradeable-loader owner and state checked); `upgradeAuthority`, `deploySlot` — gate admin setup on `programData.upgradeAuthority === admin.key` |
 | `EventAuthority`, `SelfProgram` | Anchor's `["__event_authority"]` PDA, and this program's own address, for `emitCpi` |
 | `Zeroed<T>` | large accounts (up to 10 MiB) the client allocated with System `CreateAccount`: owned by this program, big enough, rent-exempt, discriminator still zero — then initialized; like Anchor's zero-copy `zero` |
-| `Init<Mint>`, `InitIfNeeded<Mint>` | Anchor `init` / `init_if_needed` with `mint::decimals` / `mint::authority` / `mint::freeze_authority`: `const bump = mint.create(payer, ["mint", payer.key], 6n, authority, freezeAuthority \| null)` creates the mint at that PDA of this program, or with `null` seeds as a new keypair account that signs (3010 if it did not), under the instruction's token program (exactly one token program parameter, plus `SystemProgram`). Token-2022 extensions (Anchor's `extensions::…`) go after the freeze authority: `mint.create(payer, null, 6n, authority, null, { metadataPointer: { authority, metadataAddress: mint.key }, transferHook: { authority, programId }, closeAuthority, permanentDelegate, nonTransferable: true, defaultAccountState: true, interestBearing: { rateAuthority, rate }, transferFee: { configAuthority, withdrawAuthority, basisPoints, maximumFee }, groupPointer, groupMemberPointer })` sizes the mint for them and initializes each before InitializeMint2. `createIfNeeded(…)` returns whether it created it; an existing one must be that PDA and have those decimals and authorities (2018 / 2016 / 2017) |
+| `Init<Mint>`, `InitIfNeeded<Mint>` | Anchor `init` / `init_if_needed` with `mint::decimals` / `mint::authority` / `mint::freeze_authority`: `const bump = mint.create(payer, ["mint", payer.key], 6n, authority, freezeAuthority \| null)` creates the mint at that PDA of this program, or with `null` seeds as a new keypair account that signs (3010 if it did not), under the instruction's token program (exactly one token program parameter, plus `SystemProgram`). Token-2022 extensions (Anchor's `extensions::…`) go after the freeze authority: `mint.create(payer, null, 6n, authority, null, { metadataPointer: { authority, metadataAddress: mint.key }, transferHook: { authority, programId }, closeAuthority, permanentDelegate, nonTransferable: true, defaultAccountState: true, interestBearing: { rateAuthority, rate }, transferFee: { configAuthority, withdrawAuthority, basisPoints, maximumFee }, groupPointer, groupMemberPointer })` sizes the mint for them and initializes each before InitializeMint2. With `createIfNeeded` an existing mint must carry groupPointer / groupMemberPointer / metadataPointer / closeAuthority / permanentDelegate / transferHook with those keys (Anchor's 2024–2039). `createIfNeeded(…)` returns whether it created it; an existing one must be that PDA and have those decimals and authorities (2018 / 2016 / 2017) |
 | `Init<TokenAccount>`, `InitIfNeeded<TokenAccount>` (no `Ata<…>`) | Anchor `init` / `init_if_needed` with `token::mint` / `token::authority`: `vault.create(payer, ["vault", mint.key], mint, authority)` (the authority may be `vault.key` itself) creates a token account at that PDA (or a keypair account with `null`), sized for the mint's extensions under Token-2022. `createIfNeeded` checks an existing one has that mint and owner (2014 / 2015) |
 | `TokenAccount` / `Mut<TokenAccount>` | owned by SPL Token or Token-2022 (extensions allowed, multisig accounts refused), initialized; `mint`, `owner`, `amount`, `delegate`, `delegatedAmount`, `isFrozen`, `isNative`, `closeAuthority`, `tokenProgram` |
 | `Mint` / `Mut<Mint>` | owned by SPL Token or Token-2022, initialized; `decimals`, `supply`, `mintAuthority`, `freezeAuthority`, `tokenProgram` |
@@ -159,8 +159,7 @@ Growable `Vec`s anywhere but the last account field (use `FixedVec<T, N>`), Fixe
 the next instruction), `?.` on anything but optional accounts and Option<struct> fields, `!` on anything but an Option
 or an optional account, Core's external plugin adapters (oracles, app data, lifecycle hooks: use `invoke`), closures
 stored or returned (they are called or passed to list methods), arrow literals and closures as helper arguments (pass a
-named function), `map` / `filter` (they would build a new list), mint extensions on `InitIfNeeded<Mint>` (create the
-mint with `create(…, extensions)`), floating point (by design).
+named function), `map` / `filter` (they would build a new list), floating point (by design).
 They are rejected at compile time rather than half-supported.
 
 `Init.create` handles a PDA address someone pre-funded: it tops up rent, then allocates and assigns instead of

package/docs/migrate-from-anchor.md

@@ -49,7 +49,7 @@ and error codes. Its notes (on stderr) list what an existing Anchor client would
 | `Program<'info, System>` | `SystemProgram` |
 | `Program<'info, Token>` / `Token2022` / `Interface<'info, TokenInterface>` | `TokenProgram` / `Token2022Program` / `TokenInterface` |
 | `Account<'info, TokenAccount>` / `Account<'info, Mint>` (`InterfaceAccount`) | `TokenAccount` / `Mint` (`Mut<…>` when written) |
-| `token::mint = m, token::authority = a` | `HasOne<TokenAccount, "mint" \| "owner">` against parameters with those names |
+| `token::mint = m, token::authority = a` | `TokenOf<TokenAccount, "m", "a">` (2014 / 2015), or `HasOne<TokenAccount, "mint" \| "owner">` when the parameters have those names; `mint::authority = a, mint::freeze_authority = f` on an existing mint: `MintOf<Mint, "a", "f">` (2016 / 2017) |
 | `extensions::metadata_pointer::authority = a, …` (with `mint::…`) | `mint.create(p, …, { metadataPointer: { authority: a.key, metadataAddress: mint.key }, … })`: transferHook, closeAuthority, permanentDelegate, nonTransferable, groupPointer, groupMemberPointer and more |
 | `#[account(init, payer = p, seeds = […], bump, mint::decimals = 6, mint::authority = a, mint::freeze_authority = f)]` | `Init<Mint>`, then `const bump = mint.create(p, […], 6n, a.key, f.key)` (`null` seeds: a keypair mint; `InitIfNeeded<Mint>` + `createIfNeeded`) |
 | `#[account(init, payer = p, seeds = […], bump, token::mint = m, token::authority = a)]` | `Init<TokenAccount>`, then `vault.create(p, […], m, a.key)` (`InitIfNeeded<TokenAccount>` + `createIfNeeded`) |
@@ -91,6 +91,8 @@ Anchor instruction that takes or returns a struct with `String` / `Vec` / `Optio
 | `-> Result<u64>` / a struct | `: u64` / a struct: sent as return data, listed in the IDL |
 | `#[error_code] enum MyError { #[msg("…")] X }` | `export enum MyError { X = "…" }` (codes from 6000, in order) |
 | `require!(c, MyError::X)`, `err!(MyError::X)` | `require(c, MyError.X)`, `require(false, MyError.X)` |
+| `require_keys_eq!(a, b)`, `err!(ErrorCode::AccountDidNotDeserialize)` (Anchor's own codes) | `require(a === b, AnchorError.RequireKeysEqViolated)`, `require(false, AnchorError.AccountDidNotDeserialize)` |
+| `init_if_needed` + `extensions::…` on a mint | `mint.createIfNeeded(…, { metadataPointer: {…}, … })`: an existing mint is checked as Anchor checks it (2024–2039) |
 | `require_keys_eq!(a, b)` | `require(a === b, …)` |
 | `a.checked_add(b).ok_or(…)?` | `a + b` (every operation is checked; overflow aborts with 5100) |
 | `emit!(Ev { … })` / `emit_cpi!` | `emit<Ev>({ … })` / `emitCpi<Ev>({ … }, eventAuthority, self)` |

package/lib/typesol.d.ts

@@ -517,6 +517,20 @@ export type InitIfNeeded<T> = T extends TokenAccount
           freezeAuthority: Pubkey | null,
           tokenProgram?: TokenProgram | Token2022Program | TokenInterface,
         ): boolean;
+        /**
+         * With extensions: created with them, or an existing mint must carry them with these keys, as Anchor's
+         * `extensions::…` constraints check (2024–2039). groupPointer, groupMemberPointer, metadataPointer,
+         * closeAuthority, permanentDelegate and transferHook only.
+         */
+        createIfNeeded(
+          payer: Mut<Signer>,
+          seeds: Seed[] | null,
+          decimals: u8,
+          mintAuthority: Pubkey,
+          freezeAuthority: Pubkey | null,
+          extensions: MintExtensions,
+          tokenProgram?: Token2022Program | TokenInterface,
+        ): boolean;
         readonly pdaBump: u8;
       }
     : T &
@@ -539,6 +553,15 @@ export type InitIfNeeded<T> = T extends TokenAccount
  * They nest: `CloseTo<HasOne<Mut<Vault>, "owner">, "owner">`.
  */
 export type HasOne<A, Field extends string> = A & { readonly __hasOne?: Field };
+/**
+ * Anchor's `token::mint = mintParam, token::authority = authorityParam` on an existing token account, naming the
+ * parameters (2014 / 2015); `never` leaves one out.
+ */
+export type TokenOf<A, MintParam extends string, AuthorityParam extends string = never> = A & { readonly __tokenOf?: [MintParam, AuthorityParam] };
+/** Anchor's `mint::authority = a, mint::freeze_authority = f` on an existing mint, naming the parameters (2016 / 2017). */
+export type MintOf<A, AuthorityParam extends string, FreezeAuthorityParam extends string = never> = A & {
+  readonly __mintOf?: [AuthorityParam, FreezeAuthorityParam];
+};
 export type Seeds<A, Names extends readonly string[], Bump extends string = never, ProgramId extends string = never> = A & {
   readonly __seeds?: [Names, Bump, ProgramId];
   /** The PDA's bump (Anchor `ctx.bumps.<account>`): the stored bump field when one is named, else the canonical bump found. */
@@ -774,6 +797,31 @@ export interface BubblegumProgram extends AccountMeta {
     sellerFeeBasisPoints: u16,
     signerSeeds?: Seed[] | SignerSeeds,
   ): void;
+  /**
+   * MintToCollectionV1 on a V1 tree: the leaf joins a Token Metadata collection (Bubblegum verifies it; the collection
+   * authority signs, its record PDA is `null` when it is the update authority itself). Creators default to none,
+   * `isMutable` to true, `editionNonce` to None.
+   */
+  mintToCollection(
+    treeConfig: AccountMeta,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    payer: Signer,
+    treeDelegate: AccountMeta,
+    collectionAuthority: AccountMeta,
+    collectionAuthorityRecordPda: AccountMeta | null,
+    collectionMint: AccountMeta,
+    collectionMetadata: AccountMeta,
+    collectionEdition: AccountMeta,
+    bubblegumSigner: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    tokenMetadataProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    metadata: CompressedMetadata & { editionNonce?: u8 },
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
   /**
    * CreateTreeConfigV2: a tree on mpl-account-compression (mcmt6…, allocated by the client and owned by it) with the
    * mpl-noop log wrapper (mnoop…). `treeCreator` `null`: the payer.
@@ -1382,7 +1430,90 @@ export declare function invoke(
 ): void;
 
 /** Abort with the given error unless `condition` holds. Use a string enum member or a string literal. */
-export declare function require(condition: boolean, error: string): asserts condition;
+/**
+ * Anchor's own error codes (anchor-lang `ErrorCode`): `require(condition, AnchorError.AccountDidNotDeserialize)` fails
+ * with that code, as `require!(condition, ErrorCode::AccountDidNotDeserialize)` does. Not listed in the IDL's errors.
+ */
+export declare enum AnchorError {
+  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,
+}
+export declare function require(condition: boolean, error: string | AnchorError): asserts condition;
 
 /** Write a string, integer or pubkey to the program log. */
 export declare function log(value: string | bigint | Pubkey | Hash): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typesol/cli",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Compile a TypeScript-syntax language directly to Solana SBF programs.",
   "type": "module",
   "license": "MIT",

package/runtime/typesol_rt.h

@@ -1105,48 +1105,124 @@ static inline uint64_t ts_alloc(uint64_t n, uint8_t **out) {
 static uint64_t ts_base58_32(const uint8_t *in, TS_Str *out) {
   static const char digits[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
   const uint64_t D = 656356768ULL; /* 58^5 */
-  uint32_t limb[8];
-  for (int i = 0; i < 8; i++)
-    limb[i] = (uint32_t)in[4 * i] << 24 | (uint32_t)in[4 * i + 1] << 16 | (uint32_t)in[4 * i + 2] << 8 | (uint32_t)in[4 * i + 3];
-  uint8_t rev[50]; /* base-58 digits, least significant first; 32 bytes need at most 44 */
-  uint64_t len = 0;
+  uint64_t limb[8];
+  for (int i = 0; i < 8; i++) limb[i] = __builtin_bswap32(*(const ts_u32_unaligned *)(in + 4 * i)); /* big-endian words */
+  /* Digits are written as characters from the end of `buf`, five per pass; 32 bytes need at most 44. */
+  char buf[50];
+  uint64_t pos = sizeof(buf);
   int start = 0;
   while (start < 8 && limb[start] == 0) start++;
   while (start < 8) {
     uint64_t rem = 0;
-    for (int i = start; i < 8; i++) {
-      uint64_t cur = (rem << 32) | limb[i];
-      uint64_t q = cur / D;
-      rem = cur - q * D;
-      limb[i] = (uint32_t)q;
+    /* One long-division pass from the first nonzero limb, unrolled. */
+#define TS_B58_STEP(i)                       \
+  {                                          \
+    uint64_t cur = (rem << 32) | limb[i];    \
+    uint64_t q = cur / D;                    \
+    rem = cur - q * D;                       \
+    limb[i] = q;                             \
+  }
+    switch (start) {
+      case 0: TS_B58_STEP(0) /* fallthrough */
+      case 1: TS_B58_STEP(1) /* fallthrough */
+      case 2: TS_B58_STEP(2) /* fallthrough */
+      case 3: TS_B58_STEP(3) /* fallthrough */
+      case 4: TS_B58_STEP(4) /* fallthrough */
+      case 5: TS_B58_STEP(5) /* fallthrough */
+      case 6: TS_B58_STEP(6) /* fallthrough */
+      default: TS_B58_STEP(7)
     }
+#undef TS_B58_STEP
     while (start < 8 && limb[start] == 0) start++;
-    for (int k = 0; k < 5; k++) {
-      uint64_t q = rem / 58;
-      rev[len++] = (uint8_t)(rem - q * 58);
-      rem = q;
-    }
+    uint64_t q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    q = rem / 58; buf[--pos] = digits[rem - q * 58]; rem = q;
+    buf[--pos] = digits[rem];
   }
-  while (len > 0 && rev[len - 1] == 0) len--;
+  /* Leading zero digits of the number are not printed; each leading zero byte is a '1'. */
+  while (pos < sizeof(buf) && buf[pos] == '1') pos++;
   uint64_t zeros = 0;
   while (zeros < 32 && in[zeros] == 0) zeros++;
+  uint64_t len = sizeof(buf) - pos;
   uint8_t *p;
   TS_TRY(ts_alloc(zeros + len, &p));
   for (uint64_t i = 0; i < zeros; i++) p[i] = '1';
-  for (uint64_t j = 0; j < len; j++) p[zeros + j] = (uint8_t)digits[rev[len - 1 - j]];
+  ts_memcpy(p + zeros, buf + pos, len);
   *out = ts_str(p, zeros + len);
   return SUCCESS;
 }
 
-static inline uint64_t ts_str_concat(TS_Str a, TS_Str b, TS_Str *out) {
+/*
+ * `s += …` on a local string: the pieces are copied right after `s` when it ends where the heap's free space starts
+ * (it was the last thing allocated), and `s` grows in place; otherwise `s` and the pieces are joined into a new string.
+ * Other views of the old `s` keep their length, so they still read the same bytes. The bytes written are past the
+ * heap's top, where no view can point (ts_alloc is the only source of heap pointers and never hands out memory past
+ * the top), so no piece is overwritten while it is copied.
+ */
+static uint64_t ts_str_append_parts(TS_Str *s, const TS_Str *parts, uint64_t n) {
+  uint64_t *next = (uint64_t *)HEAP_START_ADDRESS;
+  uint64_t add = 0;
+  for (uint64_t i = 0; i < n; i++) add += parts[i].len;
+  if (*next != 0 && s->len > 0 && (uint64_t)(s->ptr + s->len) == HEAP_START_ADDRESS + *next && *next + add <= TS_HEAP_LENGTH) {
+    for (uint64_t i = 0; i < n; i++) {
+      ts_memcpy((uint8_t *)s->ptr + s->len, parts[i].ptr, parts[i].len);
+      s->len += parts[i].len;
+    }
+    *next += add;
+    return SUCCESS;
+  }
   uint8_t *p;
-  TS_TRY(ts_alloc(a.len + b.len, &p));
-  ts_memcpy(p, a.ptr, a.len);
-  ts_memcpy(p + a.len, b.ptr, b.len);
-  *out = ts_str(p, a.len + b.len);
+  TS_TRY(ts_alloc(s->len + add, &p));
+  ts_memcpy(p, s->ptr, s->len);
+  uint64_t at = s->len;
+  for (uint64_t i = 0; i < n; i++) {
+    ts_memcpy(p + at, parts[i].ptr, parts[i].len);
+    at += parts[i].len;
+  }
+  *s = ts_str(p, at);
   return SUCCESS;
 }
 
+/* `s += b` (and `a + b`, with `s` a copy of `a`): the one-piece case of ts_str_append_parts. */
+static uint64_t ts_str_append(TS_Str *s, TS_Str b) {
+  uint64_t *next = (uint64_t *)HEAP_START_ADDRESS;
+  if (*next != 0 && s->len > 0 && (uint64_t)(s->ptr + s->len) == HEAP_START_ADDRESS + *next && *next + b.len <= TS_HEAP_LENGTH) {
+    ts_memcpy((uint8_t *)s->ptr + s->len, b.ptr, b.len);
+    *next += b.len;
+    s->len += b.len;
+    return SUCCESS;
+  }
+  uint8_t *p;
+  TS_TRY(ts_alloc(s->len + b.len, &p));
+  ts_memcpy(p, s->ptr, s->len);
+  ts_memcpy(p + s->len, b.ptr, b.len);
+  *s = ts_str(p, s->len + b.len);
+  return SUCCESS;
+}
+
+/* The pieces of a template literal, joined with one heap allocation and one copy each. */
+static uint64_t ts_str_join(const TS_Str *parts, uint64_t n, TS_Str *out) {
+  uint64_t total = 0;
+  for (uint64_t i = 0; i < n; i++) total += parts[i].len;
+  uint8_t *p;
+  TS_TRY(ts_alloc(total, &p));
+  uint64_t at = 0;
+  for (uint64_t i = 0; i < n; i++) {
+    ts_memcpy(p + at, parts[i].ptr, parts[i].len);
+    at += parts[i].len;
+  }
+  *out = ts_str(p, total);
+  return SUCCESS;
+}
+
+/* `a + b`: a new string (`a` grows in place when it is the newest heap string; its own view keeps its length). */
+static inline uint64_t ts_str_concat(TS_Str a, TS_Str b, TS_Str *out) {
+  *out = a;
+  return ts_str_append(out, b);
+}
+
 /* Decimal text of an integer, on the heap. */
 /* Copy a string's bytes to the heap (a stable value, independent of where the view pointed). */
 static inline uint64_t ts_str_copy(TS_Str a, TS_Str *out) {