@typesol/cli 0.17.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;
@@ -82,7 +103,7 @@ export interface Vec<T> {
  * 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> {
+export interface FixedVec<T, N extends number> extends ListMethods<T> {
   readonly length: u64;
   get(index: bigint): T;
   set(index: bigint, value: T): void;
@@ -403,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. */
@@ -421,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;
@@ -460,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):
@@ -533,7 +592,13 @@ export declare function emitCpi<T>(event: T, eventAuthority: EventAuthority, sel
 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 }[] }
+  | {
+      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" }
@@ -547,8 +612,13 @@ export type CorePlugin = (
   | { 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"] | "MasterEdition" | "VerifiedCreators" | "Autograph";
+export type CorePluginKind = CorePlugin["kind"] | "Groups";
 
 export interface MplCoreProgram extends AccountMeta {
   readonly __mpl_core: void;
@@ -785,6 +855,180 @@ export interface BubblegumProgram extends AccountMeta {
     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 {
@@ -795,6 +1039,37 @@ export interface CompressedMetadata {
   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;
@@ -819,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,
@@ -882,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;
@@ -904,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,
@@ -937,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. */
@@ -1053,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;

package/package.json

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