@typesol/cli 0.16.0 → 0.17.0

package/lib/typesol.d.ts

@@ -77,6 +77,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> {
+  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 +251,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 +267,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. */
@@ -473,9 +526,36 @@ 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 }[] }
+  | { 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" }
+) & { authority?: CorePluginAuthority };
+export type CorePluginKind = CorePlugin["kind"] | "MasterEdition" | "VerifiedCreators" | "Autograph";
+
 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 +567,28 @@ 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,
+    payer: Mut<Signer>,
+    systemProgram: SystemProgram,
+    name: string,
+    uri: string,
+    signerSeeds?: Seed[] | SignerSeeds,
+  ): void;
+  /** With plugins every asset of the collection inherits (Royalties, PermanentFreezeDelegate, …). */
   createCollection(
     collection: AccountMeta,
     updateAuthority: AccountMeta | null,
@@ -494,6 +596,60 @@ export interface MplCoreProgram extends AccountMeta {
     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). */
@@ -548,6 +704,106 @@ 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;
+}
+/** 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;
+}
+/** 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). */

package/package.json

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

package/runtime/typesol_rt.h

@@ -34,6 +34,7 @@
 #define TS_ERR_ALREADY_INITIALIZED 3000    /* AccountDiscriminatorAlreadySet */
 #define TS_ERR_DISCRIMINATOR 3002          /* AccountDiscriminatorMismatch */
 #define TS_ERR_ACCOUNT_TOO_SMALL 3003      /* AccountDidNotDeserialize */
+#define TS_ERR_DID_NOT_SERIALIZE 3004      /* AccountDidNotSerialize */
 #define TS_ERR_TOKEN_ACCOUNT 3003          /* AccountDidNotDeserialize (not an initialized token account) */
 #define TS_ERR_MINT 3003                   /* AccountDidNotDeserialize (not an initialized mint) */
 #define TS_ERR_NOT_ENOUGH_ACCOUNTS 3005    /* AccountNotEnoughKeys */
@@ -162,8 +163,11 @@ static inline TS_Str ts_str(const uint8_t *ptr, uint64_t len) {
 static inline bool ts_utf8_valid(const uint8_t *p, uint64_t n) {
   uint64_t i = 0;
   while (i < n) {
+    /* ASCII eight bytes at a time (no high bit set), then byte by byte up to the next multi-byte sequence. */
+    while (i + 8 <= n && (ts_ld64(p + i) & 0x8080808080808080ULL) == 0) i += 8;
+    while (i < n && p[i] < 0x80) i++;
+    if (i == n) break;
     uint8_t c = p[i];
-    if (c < 0x80) { i++; continue; }
     uint64_t len;
     uint32_t cp;
     if (c >= 0xc2 && c <= 0xdf) { len = 2; cp = c & 0x1f; }
@@ -670,16 +674,17 @@ static inline uint64_t ts_realloc(TsParams *params, TsAccount *payer, TsAccount
   return ts_resize(params, payer, acct, new_len, entry_len);
 }
 
+/* `space` for a new account; an existing one needs `min_space` (less for a @layout borsh account). */
 static inline uint64_t ts_create_pda_if_needed(TsParams *params, TsAccount *payer, TsAccount *acct,
                                                SolSignerSeed *seeds, int n, const uint8_t disc[8], uint64_t space,
-                                               uint8_t *bump_out, bool *created) {
+                                               uint64_t min_space, uint8_t *bump_out, bool *created) {
   if (ts_key_eq(&acct->owner, params->program_id)) {
     SolPubkey derived;
     uint8_t bump;
     if (ts_find_pda(seeds, n, params->program_id, &derived, &bump) != SUCCESS ||
         !ts_key_eq(&derived, &acct->key))
       TS_FAIL(TS_ERR_SEEDS, "TypeSOL: PDA seeds do not match account");
-    if (acct->data_len < space) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account data too small");
+    if (acct->data_len < min_space) TS_FAIL(TS_ERR_ACCOUNT_TOO_SMALL, "TypeSOL: account data too small");
     if (!ts_mem_eq(acct->data, disc, 8)) TS_FAIL(TS_ERR_DISCRIMINATOR, "TypeSOL: account discriminator mismatch");
     *bump_out = bump;
     *created = false;
@@ -1209,9 +1214,21 @@ static inline uint64_t ts_metadata_address(const SolPubkey *mint, SolPubkey *out
   return SUCCESS;
 }
 
+static inline uint64_t ts_master_edition_address(const SolPubkey *mint, SolPubkey *out) {
+  SolSignerSeed seeds[4] = {{(const uint8_t *)"metadata", 8},
+                            {(const uint8_t *)&TS_MPL_METADATA_ID, 32},
+                            {(const uint8_t *)mint, 32},
+                            {(const uint8_t *)"edition", 7}};
+  uint8_t bump;
+  if (ts_find_pda(seeds, 4, &TS_MPL_METADATA_ID, out, &bump) != SUCCESS)
+    TS_FAIL(TS_ERR_SEEDS, "TypeSOL: cannot derive the master edition address");
+  return SUCCESS;
+}
+
 /*
  * Metaplex CreateMetadataAccountV3 (instruction 33): DataV2 { name, symbol, uri, seller_fee_basis_points u16,
- * creators Option<Vec<Creator>>, collection Option<Collection>, uses None }, is_mutable bool, collection_details None.
+ * creators Option<Vec<Creator>>, collection Option<Collection>, uses None }, is_mutable bool, collection_details
+ * None, or Some(V1 { size: 0 }) when `sized_collection`.
  * `creators` holds `ncreators` packed Creator records (address, verified, share: 34 bytes); ncreators < 0 is None.
  * `collection` (NULL for None) is written unverified, as Metaplex requires at creation.
  * Accounts: metadata (w), mint, mint authority (s), payer (ws), update authority, system program.
@@ -1220,10 +1237,10 @@ static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *progr
                                         TsAccount *mint, TsAccount *mint_authority, TsAccount *payer,
                                         TsAccount *update_authority, TsAccount *system, TS_Str name, TS_Str symbol,
                                         TS_Str uri, uint16_t fee_bps, bool is_mutable, const uint8_t *creators, int ncreators,
-                                        const SolPubkey *collection, const SolSignerSeed *seeds, int n) {
+                                        const SolPubkey *collection, bool sized_collection, const SolSignerSeed *seeds, int n) {
   uint8_t *data;
   uint64_t ncr = ncreators > 0 ? (uint64_t)ncreators : 0;
-  TS_TRY(ts_alloc(1 + 12 + name.len + symbol.len + uri.len + 2 + (1 + 4 + 34 * ncr) + (1 + 33) + 1 + 1 + 1, &data));
+  TS_TRY(ts_alloc(1 + 12 + name.len + symbol.len + uri.len + 2 + (1 + 4 + 34 * ncr) + (1 + 33) + 1 + 1 + (1 + 9), &data));
   uint64_t at = 0;
   data[at++] = 33;
   ts_put_str(data, &at, name);
@@ -1251,7 +1268,15 @@ static inline uint64_t ts_mpl_create_v3(TsParams *params, const TsAccount *progr
   }
   data[at++] = 0; /* uses: None */
   data[at++] = is_mutable ? 1 : 0;
-  data[at++] = 0; /* collection_details: None */
+  if (sized_collection) {
+    /* collection_details: Some(V1 { size: 0 }): this NFT is a collection items can be verified into */
+    data[at++] = 1;
+    data[at++] = 0;
+    ts_memzero(data + at, 8);
+    at += 8;
+  } else {
+    data[at++] = 0; /* collection_details: None */
+  }
   bool ua_signs = update_authority->is_signer || ts_key_eq(&update_authority->key, &mint_authority->key);
   SolAccountMeta metas[6] = {{&metadata->key, true, false},          {&mint->key, false, false},
                              {&mint_authority->key, false, true},     {&payer->key, true, true},