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

package/dist/accounts/metadata/entityMetadata.js

@@ -0,0 +1,24 @@
+/**
+ * Decode raw buffer into structured EntityMetadata object
+ */
+export function decodeEntityMetadata(program, buffer) {
+    const accountData = program.coder.accounts.decode("EntityMetadata", buffer);
+    return {
+        entity: accountData.entity,
+        schema: accountData.schema,
+        version: accountData.version,
+        uri: accountData.uri,
+        contentHash: Buffer.from(accountData.contentHash),
+        createdAt: accountData.createdAt,
+        locked: accountData.locked,
+    };
+}
+/**
+ * Optional: check if buffer matches EntityMetadata discriminator
+ */
+export function isEntityMetadataDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === ENTITY_METADATA_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with actual IDL discriminator)
+const ENTITY_METADATA_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

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

@@ -0,0 +1,3 @@
+export * from "./entityMetadata";
+export * from "./ipMetadata";
+export * from "./schemaRegistry";

package/dist/accounts/metadata/index.js

@@ -0,0 +1,3 @@
+export * from "./entityMetadata";
+export * from "./ipMetadata";
+export * from "./schemaRegistry";

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

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

package/dist/accounts/metadata/ipMetadata.js

@@ -0,0 +1,24 @@
+/**
+ * Decode raw buffer into structured IpMetadata object
+ */
+export function decodeIpMetadata(program, buffer) {
+    const accountData = program.coder.accounts.decode("IpMetadata", buffer);
+    return {
+        ipAsset: accountData.ipAsset,
+        schema: accountData.schema,
+        version: accountData.version,
+        uri: accountData.uri,
+        contentHash: Buffer.from(accountData.contentHash),
+        createdAt: accountData.createdAt,
+        locked: accountData.locked,
+    };
+}
+/**
+ * Optional: check if buffer matches IpMetadata discriminator
+ */
+export function isIpMetadataDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === IP_METADATA_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with actual IDL discriminator)
+const IP_METADATA_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

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

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Metadata } from "../../types/metadata";
+/**
+ * SchemaRegistry on-chain account type
+ */
+export type SchemaRegistry = {
+    category: string;
+    schemaUri: string;
+    version: number;
+    creator: anchor.web3.PublicKey;
+    bump: number;
+};
+/**
+ * Decode raw buffer into structured SchemaRegistry object
+ */
+export declare function decodeSchemaRegistry(program: Program<Metadata>, buffer: Buffer): SchemaRegistry;
+/**
+ * Optional: check if buffer matches SchemaRegistry discriminator
+ */
+export declare function isSchemaRegistryDiscriminator(buffer: Buffer): boolean;

package/dist/accounts/metadata/schemaRegistry.js

@@ -0,0 +1,22 @@
+/**
+ * Decode raw buffer into structured SchemaRegistry object
+ */
+export function decodeSchemaRegistry(program, buffer) {
+    const accountData = program.coder.accounts.decode("SchemaRegistry", buffer);
+    return {
+        category: accountData.category,
+        schemaUri: accountData.schemaUri,
+        version: accountData.version,
+        creator: accountData.creator,
+        bump: accountData.bump,
+    };
+}
+/**
+ * Optional: check if buffer matches SchemaRegistry discriminator
+ */
+export function isSchemaRegistryDiscriminator(buffer) {
+    const discriminator = buffer.subarray(0, 8);
+    return discriminator.every((byte, i) => byte === SCHEMA_REGISTRY_DISCRIMINATOR[i]);
+}
+// Anchor-generated discriminator placeholder (replace with actual IDL discriminator)
+const SCHEMA_REGISTRY_DISCRIMINATOR = [12, 34, 56, 78, 90, 123, 45, 67];

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./programIds";
+export * from "./seeds";
+export * from "./status";
+export * from "./schema";

package/dist/constants/index.js

@@ -0,0 +1,4 @@
+export * from "./programIds";
+export * from "./seeds";
+export * from "./status";
+export * from "./schema";

package/dist/constants/programIds.d.ts

@@ -0,0 +1,5 @@
+import { PublicKey } from "@solana/web3.js";
+declare const ENTITY_PROGRAM_ID: PublicKey;
+declare const IPCORE_PROGRAM_ID: PublicKey;
+declare const METADATA_PROGRAM_ID: PublicKey;
+export { ENTITY_PROGRAM_ID, IPCORE_PROGRAM_ID, METADATA_PROGRAM_ID };

package/dist/constants/programIds.js

@@ -0,0 +1,8 @@
+import { PublicKey } from "@solana/web3.js";
+import entityIdl from "../idl/entity.json";
+import ipcoreIdl from "../idl/ipcore.json";
+import metadataIdl from "../idl/metadata.json";
+const ENTITY_PROGRAM_ID = new PublicKey(entityIdl.address);
+const IPCORE_PROGRAM_ID = new PublicKey(ipcoreIdl.address);
+const METADATA_PROGRAM_ID = new PublicKey(metadataIdl.address);
+export { ENTITY_PROGRAM_ID, IPCORE_PROGRAM_ID, METADATA_PROGRAM_ID };

package/dist/constants/schema.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_SCHEMA_ID_LEN = 32;
+export declare const MAX_VERSION_LEN = 16;
+export declare const MAX_SCHEMA_URI_LEN = 96;

package/dist/constants/schema.js

@@ -0,0 +1,3 @@
+export const MAX_SCHEMA_ID_LEN = 32;
+export const MAX_VERSION_LEN = 16;
+export const MAX_SCHEMA_URI_LEN = 96;

package/dist/constants/seeds.d.ts

@@ -0,0 +1,17 @@
+declare const SEEDS: {
+    readonly ENTITY: "entity";
+    readonly ENTITY_TREASURY: "entity_treasury";
+    readonly ENTITY_COUNTER: "entity_counter";
+    readonly IP_ASSET: "ip_asset";
+    readonly IP_COUNTER: "ip_counter";
+    readonly IP_REGISTRY: "ip_registry";
+    readonly DERIVATIVE_LINK: "derivative_link";
+    readonly PROVENANCE: "provenance";
+    readonly ENTITY_METADATA: "entity_metadata";
+    readonly IP_METADATA: "ip_metadata";
+    readonly SCHEMA: "schema";
+    readonly REGISTRY_CONFIG: "registry_config";
+    readonly REGISTRY_CONFIG_TREASURY: "registry_config_treasury";
+    readonly MODULE_CONFIG: "module_config";
+};
+export { SEEDS };

package/dist/constants/seeds.js

@@ -0,0 +1,17 @@
+const SEEDS = {
+    ENTITY: "entity",
+    ENTITY_TREASURY: "entity_treasury",
+    ENTITY_COUNTER: "entity_counter",
+    IP_ASSET: "ip_asset",
+    IP_COUNTER: "ip_counter",
+    IP_REGISTRY: "ip_registry",
+    DERIVATIVE_LINK: "derivative_link",
+    PROVENANCE: "provenance",
+    ENTITY_METADATA: "entity_metadata",
+    IP_METADATA: "ip_metadata",
+    SCHEMA: "schema",
+    REGISTRY_CONFIG: "registry_config",
+    REGISTRY_CONFIG_TREASURY: "registry_config_treasury",
+    MODULE_CONFIG: "module_config",
+};
+export { SEEDS };

package/dist/constants/status.d.ts

@@ -0,0 +1,24 @@
+export declare const ENTITY_STATUS_ACTIVE = 1;
+export declare const ENTITY_STATUS_FROZEN = 2;
+export declare const IP_STATUS_ACTIVE = 1;
+export declare const IP_STATUS_FROZEN = 2;
+export declare const IP_STATE_DERIVATIVE_UNANCHORED = 1;
+export declare const LINK_STATUS_ASSERTED = 1;
+export declare const LINK_STATUS_RESOLVED = 2;
+export declare const LINK_STATUS_DISPUTED = 3;
+export declare enum EntityStatus {
+    ACTIVE = 1,
+    FROZEN = 2
+}
+export declare enum IpStatus {
+    ACTIVE = 1,
+    FROZEN = 2
+}
+export declare enum IpState {
+    DERIVATIVE_UNANCHORED = 1
+}
+export declare enum LinkStatus {
+    ASSERTED = 1,
+    RESOLVED = 2,
+    DISPUTED = 3
+}

package/dist/constants/status.js

@@ -0,0 +1,33 @@
+// src/constants/status.ts
+// Entity statuses
+export const ENTITY_STATUS_ACTIVE = 1;
+export const ENTITY_STATUS_FROZEN = 2;
+// IP asset statuses
+export const IP_STATUS_ACTIVE = 1;
+export const IP_STATUS_FROZEN = 2;
+// IP state
+export const IP_STATE_DERIVATIVE_UNANCHORED = 1;
+// Derivative link statuses
+export const LINK_STATUS_ASSERTED = 1;
+export const LINK_STATUS_RESOLVED = 2;
+export const LINK_STATUS_DISPUTED = 3;
+export var EntityStatus;
+(function (EntityStatus) {
+    EntityStatus[EntityStatus["ACTIVE"] = 1] = "ACTIVE";
+    EntityStatus[EntityStatus["FROZEN"] = 2] = "FROZEN";
+})(EntityStatus || (EntityStatus = {}));
+export var IpStatus;
+(function (IpStatus) {
+    IpStatus[IpStatus["ACTIVE"] = 1] = "ACTIVE";
+    IpStatus[IpStatus["FROZEN"] = 2] = "FROZEN";
+})(IpStatus || (IpStatus = {}));
+export var IpState;
+(function (IpState) {
+    IpState[IpState["DERIVATIVE_UNANCHORED"] = 1] = "DERIVATIVE_UNANCHORED";
+})(IpState || (IpState = {}));
+export var LinkStatus;
+(function (LinkStatus) {
+    LinkStatus[LinkStatus["ASSERTED"] = 1] = "ASSERTED";
+    LinkStatus[LinkStatus["RESOLVED"] = 2] = "RESOLVED";
+    LinkStatus[LinkStatus["DISPUTED"] = 3] = "DISPUTED";
+})(LinkStatus || (LinkStatus = {}));

package/dist/helper/index.d.ts

@@ -0,0 +1 @@
+export * from "./schema";

package/dist/helper/index.js

@@ -0,0 +1 @@
+export * from "./schema";

package/dist/helper/schema.d.ts

@@ -0,0 +1,3 @@
+export declare function encodePaddedAscii(input: string, maxLen: number): Uint8Array;
+export declare function sha256(data: string): Uint8Array;
+export declare function decodePaddedAscii(bytes: Uint8Array): string;

package/dist/helper/schema.js

@@ -0,0 +1,28 @@
+import { createHash } from "crypto";
+export function encodePaddedAscii(input, maxLen) {
+    if (!/^[\x00-\x7F]*$/.test(input)) {
+        throw new Error("Non-ASCII characters are not allowed");
+    }
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(input);
+    if (bytes.length > maxLen) {
+        throw new Error(`Input too long. Max length is ${maxLen}`);
+    }
+    const padded = new Uint8Array(maxLen);
+    padded.set(bytes); // remaining bytes stay 0x00
+    return padded;
+}
+export function sha256(data) {
+    const hash = createHash("sha256").update(data).digest();
+    return new Uint8Array(hash);
+}
+export function decodePaddedAscii(bytes) {
+    // Remove trailing 0x00
+    let end = bytes.length;
+    while (end > 0 && bytes[end - 1] === 0) {
+        end--;
+    }
+    const trimmed = bytes.slice(0, end);
+    const decoder = new TextDecoder("utf-8");
+    return decoder.decode(trimmed);
+}

package/dist/idl/entity.json

@@ -0,0 +1,373 @@
+{
+    "address": "8DpEe29Fw6gBHzEo3pKJL4YffJWgvq2N61ShXWhLjt1k",
+    "metadata": {
+        "name": "entity",
+        "version": "0.1.0",
+        "spec": "0.1.0",
+        "description": "Created with Anchor"
+    },
+    "instructions": [
+        {
+            "name": "activate_entity",
+            "discriminator": [179, 185, 27, 83, 195, 230, 123, 9],
+            "accounts": [
+                {
+                    "name": "entity",
+                    "writable": true
+                },
+                {
+                    "name": "authority",
+                    "signer": true
+                }
+            ],
+            "args": []
+        },
+        {
+            "name": "assert_controller_threshold",
+            "discriminator": [195, 68, 103, 16, 222, 131, 246, 134],
+            "accounts": [
+                {
+                    "name": "entity"
+                }
+            ],
+            "args": []
+        },
+        {
+            "name": "freeze_entity",
+            "discriminator": [159, 136, 30, 2, 67, 167, 214, 147],
+            "accounts": [
+                {
+                    "name": "entity",
+                    "writable": true
+                },
+                {
+                    "name": "authority",
+                    "signer": true
+                }
+            ],
+            "args": []
+        },
+        {
+            "name": "init_entity_counter",
+            "discriminator": [192, 181, 149, 83, 121, 120, 190, 113],
+            "accounts": [
+                {
+                    "name": "entity_counter",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    101, 110, 116, 105, 116, 121, 95, 99, 111, 117, 110, 116, 101,
+                                    114
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "payer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": []
+        },
+        {
+            "name": "init_entity_treasury",
+            "discriminator": [66, 233, 24, 140, 15, 239, 108, 43],
+            "accounts": [
+                {
+                    "name": "entity"
+                },
+                {
+                    "name": "treasury",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    101, 110, 116, 105, 116, 121, 95, 116, 114, 101, 97, 115, 117,
+                                    114, 121
+                                ]
+                            },
+                            {
+                                "kind": "account",
+                                "path": "entity"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "payer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": []
+        },
+        {
+            "name": "register_entity",
+            "discriminator": [166, 52, 122, 244, 214, 116, 215, 255],
+            "accounts": [
+                {
+                    "name": "entity_counter",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    101, 110, 116, 105, 116, 121, 95, 99, 111, 117, 110, 116, 101,
+                                    114
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "entity",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [101, 110, 116, 105, 116, 121]
+                            },
+                            {
+                                "kind": "account",
+                                "path": "payer"
+                            },
+                            {
+                                "kind": "account",
+                                "path": "entity_counter.next_entity_index",
+                                "account": "EntityCounter"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "payer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "controllers",
+                    "type": {
+                        "vec": "pubkey"
+                    }
+                },
+                {
+                    "name": "threshold",
+                    "type": "u8"
+                }
+            ]
+        },
+        {
+            "name": "update_controllers",
+            "discriminator": [71, 2, 167, 69, 145, 109, 42, 139],
+            "accounts": [
+                {
+                    "name": "entity",
+                    "writable": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "new_controllers",
+                    "type": {
+                        "vec": "pubkey"
+                    }
+                },
+                {
+                    "name": "new_threshold",
+                    "type": "u8"
+                }
+            ]
+        }
+    ],
+    "accounts": [
+        {
+            "name": "EntityAccount",
+            "discriminator": [46, 132, 149, 104, 229, 39, 46, 87]
+        },
+        {
+            "name": "EntityCounter",
+            "discriminator": [101, 1, 28, 203, 184, 98, 155, 3]
+        },
+        {
+            "name": "EntityTreasury",
+            "discriminator": [158, 97, 79, 97, 49, 235, 122, 123]
+        }
+    ],
+    "events": [
+        {
+            "name": "EntityRegistered",
+            "discriminator": [207, 100, 27, 194, 243, 88, 104, 198]
+        }
+    ],
+    "errors": [
+        {
+            "code": 6000,
+            "name": "UnauthorizedController",
+            "msg": "Signer is not a controller of this entity"
+        },
+        {
+            "code": 6001,
+            "name": "InvalidControllerThreshold",
+            "msg": "Invalid controller threshold"
+        },
+        {
+            "code": 6002,
+            "name": "EmptyControllerSet",
+            "msg": "Controller list cannot be empty"
+        },
+        {
+            "code": 6003,
+            "name": "DuplicateControllers",
+            "msg": "Duplicate controllers are not allowed"
+        },
+        {
+            "code": 6004,
+            "name": "EntityFrozen",
+            "msg": "Entity is frozen"
+        },
+        {
+            "code": 6005,
+            "name": "EntityActive",
+            "msg": "Entity is active"
+        },
+        {
+            "code": 6006,
+            "name": "NotEnoughControllerSigners",
+            "msg": "Not enough controller signers"
+        }
+    ],
+    "types": [
+        {
+            "name": "EntityAccount",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "status",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "controller_threshold",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "controllers",
+                        "type": {
+                            "vec": "pubkey"
+                        }
+                    },
+                    {
+                        "name": "created_at",
+                        "type": "i64"
+                    },
+                    {
+                        "name": "creator",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "updated_at",
+                        "type": "i64"
+                    },
+                    {
+                        "name": "entity_index",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "EntityCounter",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "authority",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "next_entity_index",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "EntityRegistered",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "entity",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "entity_index",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "creator",
+                        "type": "pubkey"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "EntityTreasury",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "entity",
+                        "docs": ["Entity this treasury belongs to"],
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "version",
+                        "docs": ["Versioning for future upgrades"],
+                        "type": "u8"
+                    },
+                    {
+                        "name": "created_at",
+                        "docs": ["Created timestamp"],
+                        "type": "i64"
+                    }
+                ]
+            }
+        }
+    ],
+    "constants": [
+        {
+            "name": "ENTITY_STATUS_ACTIVE",
+            "type": "u8",
+            "value": "1"
+        },
+        {
+            "name": "ENTITY_STATUS_FROZEN",
+            "type": "u8",
+            "value": "2"
+        }
+    ]
+}