@typesol/cli 0.16.0 → 0.18.0

package/lib/typesol.d.ts

@@ -31,7 +31,28 @@ export interface Pubkey {
  * A fixed-length array stored inline in account data, e.g. `scores: FixedArray<u64, 8>`.
  * Indexes are bounds-checked; out of range aborts the instruction.
  */
-export interface FixedArray<T, N extends number> {
+/**
+ * Callback methods of Vec, FixedArray and FixedVec. Each expands into a loop over the elements (as `list.get(i)` gives
+ * them: structs by reference) with the arrow written at the call; it may read and write the function's variables.
+ */
+export interface ListMethods<T> {
+  forEach(fn: (x: T, index: u64) => void): void;
+  /** Whether `fn` holds for some element (stops at the first). */
+  some(fn: (x: T, index: u64) => boolean): boolean;
+  /** Whether `fn` holds for every element (stops at the first that fails). */
+  every(fn: (x: T, index: u64) => boolean): boolean;
+  /** The first element `fn` holds for, or null (integer, boolean, Pubkey and enum elements). */
+  find(fn: (x: T, index: u64) => boolean): T | null;
+  /** The index of the first element `fn` holds for, or -1. */
+  findIndex(fn: (x: T, index: u64) => boolean): i64;
+  reduce<A>(fn: (acc: A, x: T, index: u64) => A, initial: A): A;
+  /** Whether an element equals `value` (===). */
+  includes(value: T): boolean;
+  /** The index of the first element equal to `value`, or -1. */
+  indexOf(value: T): i64;
+}
+
+export interface FixedArray<T, N extends number> extends ListMethods<T> {
   readonly length: u64;
   get(index: bigint): T;
   set(index: bigint, value: T): void;
@@ -63,7 +84,7 @@ export type Option<T> = T | null;
  * A growable list. As the last field of an account struct it is stored Borsh-style (u32 length + elements)
  * and the account is resized as it grows. As an instruction argument it is a read-only view.
  */
-export interface Vec<T> {
+export interface Vec<T> extends ListMethods<T> {
   readonly length: u64;
   get(index: bigint): T;
   set(index: bigint, value: T): void;
@@ -77,6 +98,24 @@ export interface Vec<T> {
   [Symbol.iterator](): Iterator<T>;
 }
 
+/**
+ * A list stored inline with room for N elements: a u32 length, then N slots (Anchor `Vec<T>` with `#[max_len(N)]`, but
+ * always 4 + N × size(T) bytes). Unlike `Vec<T>` it can be any field, any number of times, and in nested structs;
+ * `push` fails (5104) when it is full. Write a whole one with `fixedVec([a, b])`.
+ */
+export interface FixedVec<T, N extends number> extends ListMethods<T> {
+  readonly length: u64;
+  get(index: bigint): T;
+  set(index: bigint, value: T): void;
+  push(value: T): void;
+  pop(): T;
+  clear(): void;
+  [Symbol.iterator](): Iterator<T>;
+  readonly __capacity?: N;
+}
+/** A FixedVec value holding these elements (`acct.owners = fixedVec([a, b])`, `{ owners: fixedVec([]) }`). */
+export declare function fixedVec<T>(items: T[]): FixedVec<T, never>;
+
 /** One extra account passed after the declared ones. Nothing about it is checked until you check it. */
 export interface RemainingAccount {
   readonly key: Pubkey;
@@ -233,7 +272,10 @@ export interface TokenMetadataProgram extends AccountMeta {
     isMutable: boolean,
     signerSeeds?: Seed[] | SignerSeeds,
   ): void;
-  /** With creators (1–5, shares adding up to 100) and/or an unverified collection mint. */
+  /**
+   * With creators (1–5, shares adding up to 100), an unverified collection mint, and/or `isCollection: true`
+   * (CollectionDetails::V1: this NFT is a sized collection other NFTs are verified into).
+   */
   createV3(
     metadata: AccountMeta,
     mint: AccountMeta,
@@ -246,10 +288,42 @@ export interface TokenMetadataProgram extends AccountMeta {
     uri: string,
     sellerFeeBasisPoints: u16,
     isMutable: boolean,
-    extras: { creators?: MetadataCreator[]; collection?: Pubkey },
+    extras: { creators?: MetadataCreator[]; collection?: Pubkey; isCollection?: boolean },
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /**
+   * CreateMasterEditionV3: makes `mint` (supply 1, decimals 0) a master edition; the mint and freeze authorities move
+   * to the edition. `maxSupply` 0n is a one of one, `null` allows unlimited prints.
+   */
+  createMasterEditionV3(
+    edition: AccountMeta,
+    mint: AccountMeta,
+    updateAuthority: AccountMeta,
+    mintAuthority: AccountMeta,
+    payer: Mut<Signer>,
+    metadata: AccountMeta,
+    tokenProgram: TokenProgram,
+    systemProgram: SystemProgram,
+    maxSupply: u64 | null,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /**
+   * Verify with CollectionV1: marks `metadata`'s collection (set with createV3's `collection`) verified. `authority` is
+   * the collection's update authority; the collection is a master edition created with `isCollection: true`.
+   */
+  verifyCollection(
+    authority: AccountMeta,
+    metadata: AccountMeta,
+    collectionMint: AccountMeta,
+    collectionMetadata: AccountMeta,
+    collectionMasterEdition: AccountMeta,
+    systemProgram: SystemProgram,
+    instructionsSysvar: AccountMeta,
     signerSeeds?: Seed[] | SignerSeeds,
   ): void;
 }
+/** The Metaplex master edition address of a mint (PDA ["metadata", program, mint, "edition"]). */
+export declare function masterEditionAddress(mint: Pubkey): Pubkey;
 /** The canonical program address of `seeds` under `program` (Rust `Pubkey::find_program_address(seeds, program).0`). */
 export declare function findProgramAddress(seeds: Seed[], program: Pubkey): Pubkey;
 /** The Metaplex metadata account address of a mint. */
@@ -350,6 +424,13 @@ export declare function realloc(account: AccountMeta, newSize: u64, payer: Mut<S
 export declare function transferFee(mint: AccountMeta | RemainingAccount, amount: u64): u64;
 /** The TransferHook extension's program, if any. */
 export declare function transferHookProgram(mint: AccountMeta | RemainingAccount): Option<Pubkey>;
+/** The TransferHook extension's authority (who may change the hook program), if any. */
+export declare function transferHookAuthority(mint: AccountMeta | RemainingAccount): Option<Pubkey>;
+/**
+ * Whether Token-2022 is transferring from this token account right now (its TransferHookAccount `transferring` flag):
+ * true inside a transfer hook called by Token-2022, false when the hook is invoked directly.
+ */
+export declare function isTransferring(tokenAccount: AccountMeta | RemainingAccount): boolean;
 /** The PermanentDelegate extension's delegate, if any (it can move or burn anyone's tokens). */
 export declare function permanentDelegate(mint: AccountMeta | RemainingAccount): Option<Pubkey>;
 /** The MintCloseAuthority extension's authority, if any. */
@@ -368,6 +449,11 @@ export interface Signer extends AccountMeta {
   readonly __signer: void;
 }
 
+/** An account owned by the System Program, e.g. a wallet (Anchor `SystemAccount`; 3011 otherwise). `Mut<SystemAccount>` to change lamports. */
+export interface SystemAccount extends AccountMeta {
+  readonly __systemAccount?: void;
+}
+
 /** Any account, no ownership or data checks. Wrap in `Mut<AccountInfo>` to change lamports. */
 export interface AccountInfo extends AccountMeta {
   readonly __info: void;
@@ -407,13 +493,39 @@ export type InitIfNeeded<T> = T extends TokenAccount
        * An existing account must be that ATA, of that mint and owner.
        */
       createIfNeeded(payer: Mut<Signer>): boolean;
+      /**
+       * Anchor `init_if_needed` + `token::…`: create it as `create(payer, seeds, mint, authority)` does unless it exists;
+       * an existing one must be that PDA, a token account of `mint` owned by `authority`. True when it created it now.
+       */
+      createIfNeeded(
+        payer: Mut<Signer>,
+        seeds: Seed[] | null,
+        mint: AccountMeta,
+        authority: Pubkey,
+        tokenProgram?: TokenProgram | Token2022Program | TokenInterface,
+      ): boolean;
+      readonly pdaBump: u8;
     }
-  : T &
-      AccountMeta & {
-        createIfNeeded(payer: Mut<Signer>, seeds: Seed[]): boolean;
-        /** The PDA bump, after createIfNeeded(). */
+  : T extends Mint
+    ? T & {
+        /** Anchor `init_if_needed` + `mint::…`: an existing mint must have these decimals and authorities. */
+        createIfNeeded(
+          payer: Mut<Signer>,
+          seeds: Seed[] | null,
+          decimals: u8,
+          mintAuthority: Pubkey,
+          freezeAuthority: Pubkey | null,
+          tokenProgram?: TokenProgram | Token2022Program | TokenInterface,
+        ): boolean;
         readonly pdaBump: u8;
-      };
+      }
+    : T &
+        AccountMeta & {
+          /** Like create(payer, seeds, space?), unless the account exists (then it must be this PDA and a T). */
+          createIfNeeded(payer: Mut<Signer>, seeds: Seed[], space?: u64): boolean;
+          /** The PDA bump, after createIfNeeded(). */
+          readonly pdaBump: u8;
+        };
 
 /**
  * Declarative constraints, checked before your code runs (like Anchor's account attributes):
@@ -473,9 +585,47 @@ export declare function emitCpi<T>(event: T, eventAuthority: EventAuthority, sel
  * account out. Accounts that sign (the new asset/collection, authorities) are keypair Signers, or PDAs of this
  * program covered by `signerSeeds`.
  */
+/**
+ * Who manages a Metaplex Core plugin: `"owner"`, `"updateAuthority"`, `"none"` (nobody: fixed), or an address. Left out,
+ * the plugin type's default (the owner for owner-managed plugins, the update authority for the others).
+ */
+export type CorePluginAuthority = "none" | "owner" | "updateAuthority" | Pubkey;
+/** A Metaplex Core plugin, written as an object literal (Core's Plugin enum, with its authority when it is added). */
+export type CorePlugin = (
+  | {
+      kind: "Royalties";
+      basisPoints: u16;
+      creators: { address: Pubkey; percentage: u8 }[];
+      /** Programs allowed (or denied) to move the asset; none by default. */
+      ruleSet?: { programAllowList: Pubkey[] } | { programDenyList: Pubkey[] };
+    }
+  | { kind: "FreezeDelegate"; frozen: boolean }
+  | { kind: "BurnDelegate" }
+  | { kind: "TransferDelegate" }
+  | { kind: "UpdateDelegate"; additionalDelegates?: Pubkey[] }
+  | { kind: "PermanentFreezeDelegate"; frozen: boolean }
+  | { kind: "Attributes"; attributes: { key: string; value: string }[] }
+  | { kind: "PermanentTransferDelegate" }
+  | { kind: "PermanentBurnDelegate" }
+  | { kind: "Edition"; number: u32 }
+  | { kind: "AddBlocker" }
+  | { kind: "ImmutableMetadata" }
+  /** On a collection: lets Bubblegum mint compressed NFTs into it (mintV2 with a collection). */
+  | { kind: "BubblegumV2" }
+  | { kind: "MasterEdition"; maxSupply?: u32 | null; name?: string | null; uri?: string | null }
+  | { kind: "VerifiedCreators"; signatures: { address: Pubkey; verified: boolean }[] }
+  | { kind: "Autograph"; signatures: { address: Pubkey; message: string }[] }
+  | { kind: "FreezeExecute"; frozen: boolean }
+  | { kind: "PermanentFreezeExecute"; frozen: boolean }
+) & { authority?: CorePluginAuthority };
+export type CorePluginKind = CorePlugin["kind"] | "Groups";
+
 export interface MplCoreProgram extends AccountMeta {
   readonly __mpl_core: void;
-  /** CreateV1. In a collection, `authority` is the collection's update authority; `owner` defaults to the payer. */
+  /**
+   * CreateV1. In a collection, `authority` is the collection's update authority; `owner` defaults to the payer.
+   * `plugins` (a literal list, one of each kind) are created with the asset.
+   */
   createAsset(
     asset: AccountMeta,
     collection: AccountMeta | null,
@@ -487,6 +637,18 @@ export interface MplCoreProgram extends AccountMeta {
     uri: string,
     signerSeeds?: Seed[] | SignerSeeds,
   ): void;
+  createAsset(
+    asset: AccountMeta,
+    collection: AccountMeta | null,
+    authority: AccountMeta | null,
+    payer: Mut<Signer>,
+    owner: AccountMeta | null,
+    systemProgram: SystemProgram,
+    name: string,
+    uri: string,
+    plugins: CorePlugin[],
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
   createCollection(
     collection: AccountMeta,
     updateAuthority: AccountMeta | null,
@@ -496,6 +658,70 @@ export interface MplCoreProgram extends AccountMeta {
     uri: string,
     signerSeeds?: Seed[] | SignerSeeds,
   ): void;
+  /** With plugins every asset of the collection inherits (Royalties, PermanentFreezeDelegate, …). */
+  createCollection(
+    collection: AccountMeta,
+    updateAuthority: AccountMeta | null,
+    payer: Mut<Signer>,
+    systemProgram: SystemProgram,
+    name: string,
+    uri: string,
+    plugins: CorePlugin[],
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** AddPluginV1, signed by `authority` (`null`: the payer): the owner for owner-managed plugins, else the update authority. */
+  addPlugin(
+    asset: AccountMeta,
+    collection: AccountMeta | null,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    plugin: CorePlugin,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** UpdatePluginV1: new values for a plugin the asset has (no `authority`), e.g. `{ kind: "FreezeDelegate", frozen: true }`. */
+  updatePlugin(
+    asset: AccountMeta,
+    collection: AccountMeta | null,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    plugin: CorePlugin,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  removePlugin(
+    asset: AccountMeta,
+    collection: AccountMeta | null,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    kind: CorePluginKind,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  addCollectionPlugin(
+    collection: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    plugin: CorePlugin,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  updateCollectionPlugin(
+    collection: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    plugin: CorePlugin,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  removeCollectionPlugin(
+    collection: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    systemProgram: SystemProgram,
+    kind: CorePluginKind,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
   /** TransferV1, signed by the owner (or a delegate) as `authority` (`null`: the payer). */
   transferAsset(
     asset: AccountMeta,
@@ -548,6 +774,311 @@ export interface BubblegumProgram extends AccountMeta {
     sellerFeeBasisPoints: u16,
     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.
+   */
+  createTreeV2(
+    treeConfig: AccountMeta,
+    merkleTree: AccountMeta,
+    payer: Mut<Signer>,
+    treeCreator: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    maxDepth: u32,
+    maxBufferSize: u32,
+    isPublic: boolean,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** MintV2 of a leaf, optionally into a Metaplex Core collection (whose update authority signs as `authority`). */
+  mintV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    treeDelegate: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    mplCoreProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    metadata: CompressedMetadata,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  mintV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    treeDelegate: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    mplCoreProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    metadata: CompressedMetadata,
+    collection: { collection: AccountMeta; authority: AccountMeta; cpiSigner: AccountMeta },
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** TransferV2, signed by the owner or delegate as `authority` (`null`: the payer); `proof` is the leaf's Merkle proof. */
+  transferV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    newLeafOwner: AccountMeta,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  burnV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    mplCoreCpiSigner: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    mplCoreProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** DelegateV2: the owner (null: the payer) sets a new leaf delegate. */
+  delegateV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    leafOwner: AccountMeta | null,
+    previousLeafDelegate: AccountMeta | null,
+    newLeafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf & { collectionHash?: Hash | null },
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** FreezeV2 / ThawV2: the leaf delegate (as `authority`, null: the payer) freezes or thaws the leaf. */
+  freezeV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  thawV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** SetNonTransferableV2 (soulbound), by the collection's permanent freeze delegate. */
+  setNonTransferableV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeaf,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** UpdateMetadataV2: the tree creator / delegate (or the collection's update authority) changes the metadata. */
+  updateMetadataV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafRef,
+    currentMetadata: CompressedMetadataV2,
+    update: CompressedMetadataUpdate,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** VerifyCreatorV2 / UnverifyCreatorV2: a creator (signing) marks itself verified or not. */
+  verifyCreatorV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    creator: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafRef,
+    metadata: CompressedMetadataV2,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  unverifyCreatorV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    creator: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafRef,
+    metadata: CompressedMetadataV2,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** SetCollectionV2: move the leaf into (or out of) a Core collection. */
+  setCollectionV2(
+    treeConfig: AccountMeta,
+    payer: Mut<Signer>,
+    authority: AccountMeta | null,
+    newCollectionAuthority: AccountMeta | null,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta | null,
+    merkleTree: AccountMeta,
+    coreCollection: AccountMeta | null,
+    newCoreCollection: AccountMeta | null,
+    mplCoreCpiSigner: AccountMeta | null,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    mplCoreProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafRef,
+    metadata: CompressedMetadataV2,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /**
+   * V1 trees (SPL Account Compression): Transfer / Burn, signed by the leaf owner or delegate (a PDA owner signs with
+   * `signerSeeds`), and Delegate by the owner.
+   */
+  transfer(
+    treeConfig: AccountMeta,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta,
+    newLeafOwner: AccountMeta,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafV1,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  burn(
+    treeConfig: AccountMeta,
+    leafOwner: AccountMeta,
+    leafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafV1,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  delegate(
+    treeConfig: AccountMeta,
+    leafOwner: AccountMeta,
+    previousLeafDelegate: AccountMeta,
+    newLeafDelegate: AccountMeta,
+    merkleTree: AccountMeta,
+    logWrapper: AccountMeta,
+    compressionProgram: AccountMeta,
+    systemProgram: SystemProgram,
+    leaf: CompressedLeafV1,
+    proof: RemainingAccounts | RemainingSlice,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+}
+/** Bubblegum V2 leaf metadata (MetadataArgsV2): non-fungible, primary sale not happened, mutable unless `isMutable: false`. */
+export interface CompressedMetadata {
+  name: string;
+  symbol: string;
+  uri: string;
+  sellerFeeBasisPoints: u16;
+  creators?: { address: Pubkey; verified: boolean; share: u8 }[];
+  isMutable?: boolean;
+}
+/** A leaf whose data and creator hashes the instruction computes from the metadata passed with it. */
+export interface CompressedLeafRef {
+  root: Hash;
+  assetDataHash?: Hash | null;
+  flags?: u8 | null;
+  nonce: u64;
+  index: u32;
+}
+/** A V1 tree's leaf. */
+export interface CompressedLeafV1 {
+  root: Hash;
+  dataHash: Hash;
+  creatorHash: Hash;
+  nonce: u64;
+  index: u32;
+}
+/** A leaf's full MetadataArgsV2, as it is now (with its creators' verified flags and its collection). */
+export interface CompressedMetadataV2 extends CompressedMetadata {
+  primarySaleHappened?: boolean;
+  collection?: Pubkey | null;
+}
+/** UpdateArgs: what to change (left out: unchanged). */
+export interface CompressedMetadataUpdate {
+  name?: string;
+  symbol?: string;
+  uri?: string;
+  creators?: { address: Pubkey; verified: boolean; share: u8 }[];
+  sellerFeeBasisPoints?: u16;
+  primarySaleHappened?: boolean;
+  isMutable?: boolean;
+}
+/** The leaf a transfer or burn replaces, as an indexer (DAS getAssetProof / getAsset) reports it. */
+export interface CompressedLeaf {
+  root: Hash;
+  dataHash: Hash;
+  creatorHash: Hash;
+  assetDataHash?: Hash | null;
+  flags?: u8 | null;
+  nonce: u64;
+  index: u32;
 }
 
 /** The current slot and epoch (Clock sysvar). */
@@ -563,17 +1094,60 @@ export type Init<T> = T extends TokenAccount
        * account of those parameters, with `payer` funding rent. Fails if it already exists.
        */
       create(payer: Mut<Signer>): void;
+      /**
+       * Anchor `init` + `token::mint` / `token::authority`: create a token account of `mint` owned by `authority`, at the
+       * PDA of `seeds` (or, with `null`, a new keypair account that signs), under the instruction's token program, with
+       * `payer` funding rent. Returns the bump (0 for a keypair).
+       */
+      create(
+        payer: Mut<Signer>,
+        seeds: Seed[] | null,
+        mint: AccountMeta,
+        authority: Pubkey,
+        tokenProgram?: TokenProgram | Token2022Program | TokenInterface,
+      ): u8;
+      /** The PDA bump, after create(seeds, …). */
+      readonly pdaBump: u8;
     }
-  : T &
-      AccountMeta & {
+  : T extends Mint
+    ? T & {
         /**
-         * Derive the PDA from `seeds`, verify it matches this account, create it with
-         * `payer` funding rent, and write the discriminator. Returns the bump.
+         * Anchor `init` + `mint::decimals` / `mint::authority` / `mint::freeze_authority`: create a mint at the PDA of
+         * `seeds` (or, with `null`, a new keypair account that signs) under the instruction's token program, with `payer`
+         * funding rent. Returns the bump (0 for a keypair).
          */
-        create(payer: Mut<Signer>, seeds: Seed[]): u8;
-        /** The PDA bump, after create(). */
+        create(
+          payer: Mut<Signer>,
+          seeds: Seed[] | null,
+          decimals: u8,
+          mintAuthority: Pubkey,
+          freezeAuthority: Pubkey | null,
+          tokenProgram?: TokenProgram | Token2022Program | TokenInterface,
+        ): u8;
+        /** With Token-2022 extensions (Anchor's `extensions::…`): the mint is sized for them and each is initialized first. */
+        create(
+          payer: Mut<Signer>,
+          seeds: Seed[] | null,
+          decimals: u8,
+          mintAuthority: Pubkey,
+          freezeAuthority: Pubkey | null,
+          extensions: MintExtensions,
+          tokenProgram?: Token2022Program | TokenInterface,
+        ): u8;
         readonly pdaBump: u8;
-      };
+      }
+    : T &
+        AccountMeta & {
+          /**
+           * Derive the PDA from `seeds`, verify it matches this account, create it with
+           * `payer` funding rent, and write the discriminator. Returns the bump.
+           * With `null`: a new keypair account that signs the transaction (Anchor's `init` without seeds); returns 0.
+           * `space` (Anchor's `space = …`, discriminator included) reserves more than 8 + the struct's size, up to 10240.
+           */
+          create(payer: Mut<Signer>, seeds: Seed[] | null, space?: u64): u8;
+          /** The PDA bump, after create(). */
+          readonly pdaBump: u8;
+        };
 
 /**
  * A large account (over 10 KiB, up to 10 MiB) the client already allocated with System CreateAccount,
@@ -626,9 +1200,11 @@ export interface SystemProgram extends AccountMeta {
 interface TokenOps {
   transfer(from: TokenAccount, to: TokenAccount, authority: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
   transferChecked(from: TokenAccount, mint: Mint, to: TokenAccount, authority: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
-  mintTo(mint: Mint, to: TokenAccount, authority: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** `mint`: a Mut<Mint>, or a mint this instruction created and initialized (Mut<Signer> / Mut<AccountInfo>). */
+  mintTo(mint: Mint | AccountMeta, to: TokenAccount, authority: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
   burn(from: TokenAccount, mint: Mint, authority: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
-  closeAccount(account: TokenAccount, destination: AccountMeta, authority: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** Close a token account (empty), or under Token-2022 a mint with no supply left (its MintCloseAuthority signs). */
+  closeAccount(account: TokenAccount | Mint, destination: AccountMeta, authority: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
   /** Let `delegate` move up to `amount` from `source`. */
   approve(source: TokenAccount, delegate: AccountMeta, owner: AccountMeta, amount: u64, signerSeeds?: Seed[] | SignerSeeds): void;
   revoke(source: TokenAccount, owner: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
@@ -648,7 +1224,7 @@ interface TokenOps {
 interface Token2022Ops {
   /** Token-2022 only: write name/symbol/uri into a mint whose MetadataPointer points at itself (the mint needs lamports for the larger size). */
   initializeMetadata(
-    mint: Mint,
+    mint: AccountMeta,
     updateAuthority: AccountMeta,
     mintAuthority: AccountMeta,
     name: string,
@@ -681,6 +1257,61 @@ interface Token2022Ops {
   initializeInterestBearingMint(mint: AccountMeta, rateAuthority: Pubkey | null, rate: i16): void;
   /** ImmutableOwner on a token account (before initializeAccount3): its owner can never change. */
   initializeImmutableOwner(account: AccountMeta): void;
+
+  // Token-2022 extension instructions on mints and accounts that have the extension.
+  /** DefaultAccountState Update: new token accounts start frozen (true) or initialized (false). */
+  updateDefaultAccountState(mint: AccountMeta, freezeAuthority: AccountMeta, frozen: boolean, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** TransferHook Update: the program invoked on every transfer (null: none). */
+  updateTransferHook(mint: AccountMeta, authority: AccountMeta, programId: Pubkey | null, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** MemoTransfer Enable: incoming transfers to `account` need a memo instruction before them. */
+  enableRequiredMemoTransfers(account: AccountMeta, owner: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** MemoTransfer Disable. */
+  disableRequiredMemoTransfers(account: AccountMeta, owner: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** InterestBearingMint UpdateRate (basis points per year). */
+  updateInterestRate(mint: AccountMeta, rateAuthority: AccountMeta, rate: i16, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** TransferFee TransferCheckedWithFee: `fee` must be the fee Token-2022 computes for `amount`; decimals are the mint's. */
+  transferCheckedWithFee(
+    from: TokenAccount,
+    mint: Mint,
+    to: TokenAccount,
+    authority: AccountMeta,
+    amount: u64,
+    fee: u64,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** TransferFee HarvestWithheldTokensToMint: move withheld fees from the given token accounts (passed on writable as they were passed) to the mint. */
+  harvestWithheldTokensToMint(mint: AccountMeta, sources: RemainingAccounts | RemainingSlice): void;
+  /** TransferFee WithdrawWithheldTokensFromMint: the fees held by the mint to `destination`. */
+  withdrawWithheldTokensFromMint(mint: AccountMeta, destination: TokenAccount, withdrawAuthority: AccountMeta, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** TransferFee SetTransferFee: takes effect two epochs later. */
+  setTransferFee(mint: AccountMeta, configAuthority: AccountMeta, basisPoints: u16, maximumFee: u64, signerSeeds?: Seed[] | SignerSeeds): void;
+
+  // The Token Metadata interface, for metadata stored in the mint (after initializeMetadata).
+  /** Set "name", "symbol" or "uri", or any other key as an additional field. */
+  updateMetadataField(mint: AccountMeta, updateAuthority: AccountMeta, field: string, value: string, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** Remove an additional field; with `idempotent` false a missing key fails. */
+  removeMetadataKey(mint: AccountMeta, updateAuthority: AccountMeta, key: string, idempotent: boolean, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** Hand the update authority to `newAuthority`, or make the metadata immutable with null. */
+  updateMetadataAuthority(mint: AccountMeta, updateAuthority: AccountMeta, newAuthority: Pubkey | null, signerSeeds?: Seed[] | SignerSeeds): void;
+  /** Emit: the whole TokenMetadata as Token-2022's return data. */
+  emitMetadata(mint: AccountMeta): void;
+}
+
+/**
+ * Token-2022 extensions for `mint.create(…, extensions)`: Anchor's `extensions::…` constraints. `null` authorities
+ * mean none; `defaultAccountState: true` starts new token accounts frozen (it needs a freeze authority).
+ */
+export interface MintExtensions {
+  transferFee?: { configAuthority: Pubkey | null; withdrawAuthority: Pubkey | null; basisPoints: u16; maximumFee: u64 };
+  closeAuthority?: Pubkey | null;
+  defaultAccountState?: boolean;
+  nonTransferable?: true;
+  interestBearing?: { rateAuthority: Pubkey | null; rate: i16 };
+  permanentDelegate?: Pubkey;
+  transferHook?: { authority: Pubkey | null; programId: Pubkey | null };
+  metadataPointer?: { authority: Pubkey | null; metadataAddress: Pubkey | null };
+  groupPointer?: { authority: Pubkey | null; groupAddress: Pubkey | null };
+  groupMemberPointer?: { authority: Pubkey | null; memberAddress: Pubkey | null };
 }
 
 /** The SPL Token program (Tokenkeg). Its address is checked. */
@@ -797,7 +1428,7 @@ export declare function i128(value: bigint): i128;
  * << aborts when bits would be lost or the amount is not below the width; >> is arithmetic on signed types;
  * ~ flips the bits within the type's width.
  */
-/** floor(a * b / c) with a 128-bit intermediate; aborts if c is 0 or the result does not fit in u64. */
+/** floor(a * b / c) with a double-width intermediate (all u64, or all u128); aborts if c is 0 or the result does not fit. */
 export declare function mulDiv(a: u64, b: u64, c: u64): u64;
 /** ceil(a * b / c), like mulDiv. */
 export declare function mulDivCeil(a: u64, b: u64, c: u64): u64;