@mycelium-ip/core-sdk 0.1.0-alpha.1

package/README.md

@@ -0,0 +1,176 @@
+# Mycelium Core SDK (Stateless Transaction Factory)
+
+This is the core, stateless SDK for building deterministic Solana transactions for the Mycelium protocol. It generates instructions and transactions offline. It does not create RPC connections, providers, wallets, or send anything.
+
+- Stateless and offline-capable
+- Chain-aware program ID resolution
+- Thin SDK wrapper around existing transaction builders
+
+## Installation
+
+```bash
+pnpm add @mycelium/core-sdk
+```
+
+## Quickstart
+
+Initialize the SDK for a chain, then use namespaces to generate unsigned transactions.
+
+```ts
+import { MyceliumSDK } from "@mycelium/core-sdk";
+
+// 1) Initialize the SDK (no network, no wallet required)
+const sdk = new MyceliumSDK({ chain: "devnet" });
+
+// 2) Prepare your Anchor Programs elsewhere (not handled by core-sdk)
+// These are placeholders — you should construct them in your app.
+const entityProgram = /* Program<Entity> */ undefined as any;
+const metadataProgram = /* Program<Metadata> */ undefined as any;
+const ipcoreProgram = /* Program<Ipcore> */ undefined as any;
+
+// Common inputs (replace with your keys)
+const payer = /* PublicKey */ undefined as any;
+const controllers = [
+  /* PublicKey[] */
+];
+```
+
+### Register an Entity
+
+Creates an unsigned transaction with a registerEntity instruction and a createEntityMetadata instruction (metadata v1) when applicable.
+
+```ts
+const { transaction } = await sdk.entity.generateRegisterTransaction({
+  program: entityProgram,
+  metadataProgram,
+  controllers,
+  threshold: 1,
+  metadataUri: "ipfs://...", // your URI
+  payer,
+});
+// transaction has NO fee payer, NO blockhash, and is UNSIGNED
+```
+
+### Register a Root IP Asset
+
+Creates an unsigned transaction with a registerRootIp instruction and createIpMetadata v1.
+
+```ts
+const { transaction: ipTx, ipAssetPda } =
+  await sdk.ipcore.generateRegisterIpAssetTransaction({
+    program: ipcoreProgram,
+    metadataProgram,
+    payer,
+    entityIndex: 0, // your entity index
+    registrationFee: 0.1, // in SOL (converted inside)
+    metadataUri: "ipfs://...", // your URI
+    controllers,
+  });
+```
+
+### Create Entity Metadata (v1)
+
+```ts
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+
+const entityPda = /* PublicKey */ undefined as any;
+const schemaPda = /* PublicKey */ undefined as any;
+
+const { transaction: createEntityMetaTx } =
+  await sdk.metadata.generateCreateEntityMetadataTransaction({
+    program: metadataProgram,
+    entityPda: entityPda as PublicKey,
+    schemaPda: schemaPda as PublicKey,
+    version: new BN(1),
+    metadataUri: "ipfs://...",
+    payer,
+    controllers,
+  });
+```
+
+### Create IP Metadata (v1)
+
+```ts
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+
+const ipAssetPda = /* PublicKey */ undefined as any;
+const entityPda = /* PublicKey */ undefined as any;
+const schemaPda = /* PublicKey */ undefined as any;
+
+const { transaction: createIpMetaTx } =
+  await sdk.metadata.generateCreateIpMetadataTransaction({
+    program: metadataProgram,
+    ipAssetPda: ipAssetPda as PublicKey,
+    entityPda: entityPda as PublicKey,
+    schemaPda: schemaPda as PublicKey,
+    version: new BN(1),
+    metadataUri: "ipfs://...",
+    payer,
+    controllers,
+  });
+```
+
+### Update Entity Metadata
+
+```ts
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+
+const entityPda = /* PublicKey */ undefined as any;
+const previousMetadataPda = /* PublicKey */ undefined as any;
+const newMetadataPda = /* PublicKey */ undefined as any;
+const schemaPda = /* PublicKey */ undefined as any;
+const authority = /* PublicKey */ undefined as any;
+
+const { transaction: updateEntityMetaTx } =
+  await sdk.metadata.generateUpdateEntityMetadataTransaction({
+    program: metadataProgram,
+    entityPda: entityPda as PublicKey,
+    previousMetadataPda: previousMetadataPda as PublicKey,
+    payer,
+    metadataUri: "ipfs://...",
+    controllers,
+  });
+```
+
+### Update IP Metadata
+
+```ts
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+
+const ipAssetPda = /* PublicKey */ undefined as any;
+const entityPda = /* PublicKey */ undefined as any;
+const previousMetadataPda = /* PublicKey */ undefined as any;
+const newMetadataPda = /* PublicKey */ undefined as any;
+const schemaPda = /* PublicKey */ undefined as any;
+const authority = /* PublicKey */ undefined as any;
+
+const { transaction: updateIpMetaTx } =
+  await sdk.metadata.generateUpdateIpMetadataTransaction({
+    program: metadataProgram,
+    ipAssetPda: ipAssetPda as PublicKey,
+    entityPda: entityPda as PublicKey,
+    previousMetadataPda: previousMetadataPda as PublicKey,
+    newMetadataPda: newMetadataPda as PublicKey,
+    schemaPda: schemaPda as PublicKey,
+    authority: authority as PublicKey,
+    payer,
+    version: new BN(2),
+    metadataUri: "ipfs://...",
+    controllers,
+  });
+```
+
+## Important Notes
+
+- Returns unsigned transactions without fee payer or blockhash. Set those in your app before signing and sending.
+- Core SDK does not create Connection, AnchorProvider, or Program. You must supply Program instances if your chosen transaction builder expects them.
+- No on-chain data is fetched by the SDK itself. Some existing transaction builders may check account state via program.account.\*; construct those programs and providers externally if you use those helpers.
+
+## Next Steps
+
+- Sign and send transactions using your own client or higher-level packages (e.g., client-sdk, react-sdk).
+- See the full list of builders in sdk/namespaces and transactions/.

package/dist/accounts/entity/entity.d.ts

@@ -0,0 +1,24 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Entity } from "../../types/entity";
+/**
+ * EntityAccount type definition
+ * Represents what is stored on-chain for an entity
+ */
+export type EntityAccount = {
+    status: number;
+    controllerThreshold: number;
+    controllers: anchor.web3.PublicKey[];
+    creator: anchor.web3.PublicKey;
+    createdAt: anchor.BN;
+    updatedAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw account buffer into a structured EntityAccount object
+ */
+export declare function decodeEntityAccount(program: Program<Entity>, buffer: Buffer): EntityAccount;
+/**
+ * Optional: check if a buffer matches the EntityAccount discriminator
+ */
+export declare function isEntityAccountDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/entity/entity.js

@@ -0,0 +1,24 @@
+/**
+ * Decode raw account buffer into a structured EntityAccount object
+ */
+export function decodeEntityAccount(program, buffer) {
+    const accountData = program.coder.accounts.decode("EntityAccount", buffer);
+    return {
+        status: accountData.status,
+        controllerThreshold: accountData.controllerThreshold,
+        controllers: accountData.controllers,
+        creator: accountData.creator,
+        createdAt: accountData.createdAt,
+        updatedAt: accountData.updatedAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if a buffer matches the EntityAccount discriminator
+ */
+export function isEntityAccountDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === ENTITY_ACCOUNT_DISCRIMINATOR[i]);
+}
+// Example discriminator (anchor generates this)
+const ENTITY_ACCOUNT_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/entity/entityTreasury.d.ts

@@ -0,0 +1,22 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Entity } from "../../types/entity";
+/**
+ * EntityTreasury type definition
+ * Represents what is stored on-chain for an entity's treasury
+ */
+export type EntityTreasury = {
+    entity: anchor.web3.PublicKey;
+    version: number;
+    balance: anchor.BN;
+    createdAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw account buffer into a structured EntityTreasury object
+ */
+export declare function decodeEntityTreasury(program: Program<Entity>, buffer: Buffer): EntityTreasury;
+/**
+ * Optional: check if a buffer matches the EntityTreasury discriminator
+ */
+export declare function isEntityTreasuryDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/entity/entityTreasury.js

@@ -0,0 +1,25 @@
+// src/accounts/entityTreasury.ts
+import * as anchor from "@coral-xyz/anchor";
+/**
+ * Decode raw account buffer into a structured EntityTreasury object
+ */
+export function decodeEntityTreasury(program, buffer) {
+    var _a;
+    const accountData = program.coder.accounts.decode("EntityTreasury", buffer);
+    return {
+        entity: accountData.entity,
+        version: accountData.version,
+        balance: (_a = accountData.balance) !== null && _a !== void 0 ? _a : new anchor.BN(0),
+        createdAt: accountData.createdAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if a buffer matches the EntityTreasury discriminator
+ */
+export function isEntityTreasuryDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === ENTITY_TREASURY_DISCRIMINATOR[i]);
+}
+// Example discriminator (anchor generates this automatically in the IDL)
+const ENTITY_TREASURY_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./entity";
+export * from "./entityTreasury";

package/dist/accounts/entity/index.js

@@ -0,0 +1,2 @@
+export * from "./entity";
+export * from "./entityTreasury";

package/dist/accounts/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./entity";
+export * from "./ipcore";
+export * from "./metadata";

package/dist/accounts/index.js

@@ -0,0 +1,3 @@
+export * from "./entity";
+export * from "./ipcore";
+export * from "./metadata";

package/dist/accounts/ipcore/derivativeLink.d.ts

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * DerivativeLink on-chain account type
+ */
+export type DerivativeLink = {
+    parentIpId: anchor.BN;
+    childIpId: anchor.BN;
+    status: number;
+    createdAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured DerivativeLink object
+ */
+export declare function decodeDerivativeLink(program: Program<Ipcore>, buffer: Buffer): DerivativeLink;
+/**
+ * Optional: check if buffer matches DerivativeLink discriminator
+ */
+export declare function isDerivativeLinkDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/derivativeLink.js

@@ -0,0 +1,22 @@
+/**
+ * Decode raw buffer into structured DerivativeLink object
+ */
+export function decodeDerivativeLink(program, buffer) {
+    const accountData = program.coder.accounts.decode("DerivativeLink", buffer);
+    return {
+        parentIpId: accountData.parentIpId,
+        childIpId: accountData.childIpId,
+        status: accountData.status,
+        createdAt: accountData.createdAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches DerivativeLink discriminator
+ */
+export function isDerivativeLinkDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === DERIVATIVE_LINK_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator (example; replace with actual)
+const DERIVATIVE_LINK_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./derivativeLink";
+export * from "./ipAsset";
+export * from "./ipRegistry";
+export * from "./moduleConfig";
+export * from "./provenanceClaim";
+export * from "./registryConfig";
+export * from "./registryConfigTreasury";

package/dist/accounts/ipcore/index.js

@@ -0,0 +1,7 @@
+export * from "./derivativeLink";
+export * from "./ipAsset";
+export * from "./ipRegistry";
+export * from "./moduleConfig";
+export * from "./provenanceClaim";
+export * from "./registryConfig";
+export * from "./registryConfigTreasury";

package/dist/accounts/ipcore/ipAsset.d.ts

@@ -0,0 +1,25 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * IpAsset on-chain account type
+ */
+export type IpAsset = {
+    entity: anchor.web3.PublicKey;
+    parent: anchor.web3.PublicKey | null;
+    category: number;
+    metadataUri: string;
+    provenance: string | null;
+    status: number;
+    createdAt: anchor.BN;
+    updatedAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured IpAsset object
+ */
+export declare function decodeIpAsset(program: Program<Ipcore>, buffer: Buffer): IpAsset;
+/**
+ * Optional: check if buffer matches IpAsset discriminator
+ */
+export declare function isIpAssetDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/ipAsset.js

@@ -0,0 +1,26 @@
+/**
+ * Decode raw buffer into structured IpAsset object
+ */
+export function decodeIpAsset(program, buffer) {
+    const accountData = program.coder.accounts.decode("IpAsset", buffer);
+    return {
+        entity: accountData.entity,
+        parent: accountData.parent,
+        category: accountData.category,
+        metadataUri: accountData.metadataUri,
+        provenance: accountData.provenance,
+        status: accountData.status,
+        createdAt: accountData.createdAt,
+        updatedAt: accountData.updatedAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches IpAsset discriminator
+ */
+export function isIpAssetDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === IP_ASSET_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder
+const IP_ASSET_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/ipRegistry.d.ts

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * IPRegistry on-chain account type
+ */
+export type IpRegistry = {
+    totalIps: anchor.BN;
+    ipAssets: anchor.web3.PublicKey[];
+    derivativeLinks: anchor.web3.PublicKey[];
+    createdAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured IpRegistry object
+ */
+export declare function decodeIpRegistry(program: Program<Ipcore>, buffer: Buffer): IpRegistry;
+/**
+ * Optional: check if buffer matches IpRegistry discriminator
+ */
+export declare function isIpRegistryDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/ipRegistry.js

@@ -0,0 +1,22 @@
+/**
+ * Decode raw buffer into structured IpRegistry object
+ */
+export function decodeIpRegistry(program, buffer) {
+    const accountData = program.coder.accounts.decode("IpRegistry", buffer);
+    return {
+        totalIps: accountData.totalIps,
+        ipAssets: accountData.ipAssets,
+        derivativeLinks: accountData.derivativeLinks,
+        createdAt: accountData.createdAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches IpRegistry discriminator
+ */
+export function isIpRegistryDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === IP_REGISTRY_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator (for reference)
+const IP_REGISTRY_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/moduleConfig.d.ts

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * ModuleConfig on-chain account type
+ */
+export type ModuleConfig = {
+    ipAsset: anchor.web3.PublicKey;
+    allowedModules: anchor.web3.PublicKey[];
+    createdAt: anchor.BN;
+    updatedAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured ModuleConfig object
+ */
+export declare function decodeModuleConfig(program: Program<Ipcore>, buffer: Buffer): ModuleConfig;
+/**
+ * Optional: check if buffer matches ModuleConfig discriminator
+ */
+export declare function isModuleConfigDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/moduleConfig.js

@@ -0,0 +1,22 @@
+/**
+ * Decode raw buffer into structured ModuleConfig object
+ */
+export function decodeModuleConfig(program, buffer) {
+    const accountData = program.coder.accounts.decode("ModuleConfig", buffer);
+    return {
+        ipAsset: accountData.ipAsset,
+        allowedModules: accountData.allowedModules,
+        createdAt: accountData.createdAt,
+        updatedAt: accountData.updatedAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches ModuleConfig discriminator
+ */
+export function isModuleConfigDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === MODULE_CONFIG_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with real one from IDL)
+const MODULE_CONFIG_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/provenanceClaim.d.ts

@@ -0,0 +1,25 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * ProvenanceClaim on-chain account type
+ */
+export type ProvenanceClaim = {
+    ipAsset: anchor.web3.PublicKey;
+    entity: anchor.web3.PublicKey;
+    creator: anchor.web3.PublicKey;
+    evidenceHash: Buffer;
+    uri: string;
+    status: number;
+    createdAt: anchor.BN;
+    updatedAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured ProvenanceClaim object
+ */
+export declare function decodeProvenanceClaim(program: Program<Ipcore>, buffer: Buffer): ProvenanceClaim;
+/**
+ * Optional: check if buffer matches ProvenanceClaim discriminator
+ */
+export declare function isProvenanceClaimDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/provenanceClaim.js

@@ -0,0 +1,26 @@
+/**
+ * Decode raw buffer into structured ProvenanceClaim object
+ */
+export function decodeProvenanceClaim(program, buffer) {
+    const accountData = program.coder.accounts.decode("ProvenanceClaim", buffer);
+    return {
+        ipAsset: accountData.ipAsset,
+        entity: accountData.entity,
+        creator: accountData.creator,
+        evidenceHash: accountData.evidenceHash,
+        uri: accountData.uri,
+        status: accountData.status,
+        createdAt: accountData.createdAt,
+        updatedAt: accountData.updatedAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches ProvenanceClaim discriminator
+ */
+export function isProvenanceClaimDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === PROVENANCE_CLAIM_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder
+const PROVENANCE_CLAIM_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/registryConfig.d.ts

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * RegistryConfig on-chain account type
+ */
+export type RegistryConfig = {
+    authority: anchor.web3.PublicKey;
+    ipRegistrationFeeLamports: anchor.BN;
+    createdAt: anchor.BN;
+    updatedAt: anchor.BN;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured RegistryConfig object
+ */
+export declare function decodeRegistryConfig(program: Program<Ipcore>, buffer: Buffer): RegistryConfig;
+/**
+ * Optional: check if buffer matches RegistryConfig discriminator
+ */
+export declare function isRegistryConfigDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/registryConfig.js

@@ -0,0 +1,22 @@
+/**
+ * Decode raw buffer into structured RegistryConfig object
+ */
+export function decodeRegistryConfig(program, buffer) {
+    const accountData = program.coder.accounts.decode("RegistryConfig", buffer);
+    return {
+        authority: accountData.authority,
+        ipRegistrationFeeLamports: accountData.ipRegistrationFeeLamports,
+        createdAt: accountData.createdAt,
+        updatedAt: accountData.updatedAt,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches RegistryConfig discriminator
+ */
+export function isRegistryConfigDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === REGISTRY_CONFIG_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with real one from IDL)
+const REGISTRY_CONFIG_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/accounts/ipcore/registryConfigTreasury.d.ts

@@ -0,0 +1,18 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Ipcore } from "../../types/ipcore";
+/**
+ * RegistryConfigTreasury on-chain account type
+ */
+export type RegistryConfigTreasury = {
+    authority: anchor.web3.PublicKey;
+    createdAt: anchor.BN;
+};
+/**
+ * Decode raw buffer into structured RegistryConfigTreasury object
+ */
+export declare function decodeRegistryConfigTreasury(program: Program<Ipcore>, buffer: Buffer): RegistryConfigTreasury;
+/**
+ * Optional: check if buffer matches RegistryConfigTreasury discriminator
+ */
+export declare function isRegistryConfigTreasuryDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/ipcore/registryConfigTreasury.js

@@ -0,0 +1,21 @@
+/**
+ * Decode raw buffer into structured RegistryConfigTreasury object
+ */
+export function decodeRegistryConfigTreasury(program, buffer) {
+    const accountData = program.coder.accounts.decode("RegistryConfigTreasury", buffer);
+    return {
+        authority: accountData.authority,
+        createdAt: accountData.createdAt,
+    };
+}
+/**
+ * Optional: check if buffer matches RegistryConfigTreasury discriminator
+ */
+export function isRegistryConfigTreasuryDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === REGISTRY_CONFIG_TREASURY_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with actual IDL discriminator)
+const REGISTRY_CONFIG_TREASURY_DISCRIMINATOR = [
+    12, 34, 56, 78, 90, 123, 45, 67,
+];

package/dist/accounts/metadata/entityMetadata.d.ts

@@ -0,0 +1,23 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Metadata } from "../../types/metadata";
+/**
+ * EntityMetadata on-chain account type
+ */
+export type EntityMetadata = {
+    entity: anchor.web3.PublicKey;
+    schema: anchor.web3.PublicKey;
+    version: anchor.BN;
+    uri: string;
+    contentHash: Buffer;
+    createdAt: anchor.BN;
+    locked: boolean;
+};
+/**
+ * Decode raw buffer into structured EntityMetadata object
+ */
+export declare function decodeEntityMetadata(program: Program<Metadata>, buffer: Buffer): EntityMetadata;
+/**
+ * Optional: check if buffer matches EntityMetadata discriminator
+ */
+export declare function isEntityMetadataDiscriminator(buffer: Buffer): boolean;