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

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

@@ -0,0 +1,7 @@
+export * from "./createEntityMetadata";
+export * from "./createIpMetadata";
+export * from "./lockEntityMetadata";
+export * from "./lockIpMetadata";
+export * from "./registerSchema";
+export * from "./updateEntityMetadata";
+export * from "./updateIpMetadata";

package/dist/instructions/metadata/index.js

@@ -0,0 +1,7 @@
+export * from "./createEntityMetadata";
+export * from "./createIpMetadata";
+export * from "./lockEntityMetadata";
+export * from "./lockIpMetadata";
+export * from "./registerSchema";
+export * from "./updateEntityMetadata";
+export * from "./updateIpMetadata";

package/dist/instructions/metadata/lockEntityMetadata.d.ts

@@ -0,0 +1,13 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { Program } from "@coral-xyz/anchor";
+import type { Metadata } from "../../types/metadata";
+/**
+ * Build the instruction for locking entity metadata
+ */
+export declare function buildLockEntityMetadataIx(params: {
+    program: Program<Metadata>;
+    metadataPda: anchor.web3.PublicKey;
+    entityPda: anchor.web3.PublicKey;
+    authority: anchor.web3.PublicKey;
+    controllers: anchor.web3.PublicKey[];
+}): Promise<anchor.web3.TransactionInstruction>;

package/dist/instructions/metadata/lockEntityMetadata.js

@@ -0,0 +1,19 @@
+/**
+ * Build the instruction for locking entity metadata
+ */
+export function buildLockEntityMetadataIx(params) {
+    const { program, metadataPda, entityPda, authority, controllers } = params;
+    return program.methods
+        .lockEntityMetadata()
+        .accounts({
+        metadata: metadataPda,
+        entity: entityPda,
+        authority,
+    })
+        .remainingAccounts(controllers.map((kp) => ({
+        pubkey: kp,
+        isSigner: true,
+        isWritable: false,
+    })))
+        .instruction();
+}

package/dist/instructions/metadata/lockIpMetadata.d.ts

@@ -0,0 +1,14 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { Program } from "@coral-xyz/anchor";
+import type { Metadata } from "../../types/metadata";
+/**
+ * Build the instruction for locking IP metadata
+ */
+export declare function buildLockIpMetadataIx(params: {
+    program: Program<Metadata>;
+    metadataPda: anchor.web3.PublicKey;
+    entityPda: anchor.web3.PublicKey;
+    ipAssetPda: anchor.web3.PublicKey;
+    authority: anchor.web3.PublicKey;
+    controllers: anchor.web3.PublicKey[];
+}): Promise<anchor.web3.TransactionInstruction>;

package/dist/instructions/metadata/lockIpMetadata.js

@@ -0,0 +1,20 @@
+/**
+ * Build the instruction for locking IP metadata
+ */
+export function buildLockIpMetadataIx(params) {
+    const { program, metadataPda, entityPda, ipAssetPda, authority, controllers, } = params;
+    return program.methods
+        .lockIpMetadata()
+        .accounts({
+        metadata: metadataPda,
+        entity: entityPda,
+        authority,
+        ipAsset: ipAssetPda,
+    })
+        .remainingAccounts(controllers.map((kp) => ({
+        pubkey: kp,
+        isSigner: true,
+        isWritable: false,
+    })))
+        .instruction();
+}

package/dist/instructions/metadata/registerSchema.d.ts

@@ -0,0 +1,14 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { Program } from "@coral-xyz/anchor";
+import type { Metadata } from "../../types/metadata";
+/**
+ * Build the instruction for registering a schema
+ */
+export declare function buildRegisterSchemaIx(params: {
+    program: Program<Metadata>;
+    schemaUri: string;
+    version: string;
+    schemaJson: string;
+    schemaId: string;
+    creator: anchor.web3.PublicKey;
+}): Promise<anchor.web3.TransactionInstruction>;

package/dist/instructions/metadata/registerSchema.js

@@ -0,0 +1,18 @@
+import { MAX_SCHEMA_ID_LEN, MAX_SCHEMA_URI_LEN, MAX_VERSION_LEN, } from "../../constants";
+import { encodePaddedAscii, sha256 } from "../../helper";
+/**
+ * Build the instruction for registering a schema
+ */
+export async function buildRegisterSchemaIx(params) {
+    const { program, schemaUri, version, schemaJson, schemaId, creator } = params;
+    const schemaHashResult = sha256(schemaJson);
+    const schemaIdResult = encodePaddedAscii(schemaId, MAX_SCHEMA_ID_LEN);
+    const versionResult = encodePaddedAscii(version, MAX_VERSION_LEN);
+    const schemaUriResult = encodePaddedAscii(schemaUri, MAX_SCHEMA_URI_LEN);
+    return program.methods
+        .registerSchema([...schemaIdResult], [...versionResult], [...schemaHashResult], [...schemaUriResult])
+        .accounts({
+        creator,
+    })
+        .instruction();
+}

package/dist/instructions/metadata/updateEntityMetadata.d.ts

@@ -0,0 +1,16 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { BN, Program } from "@coral-xyz/anchor";
+import type { Metadata } from "../../types/metadata";
+/**
+ * Build the instruction for updating entity metadata
+ */
+export declare function buildUpdateEntityMetadataIx(params: {
+    program: Program<Metadata>;
+    entityPda: anchor.web3.PublicKey;
+    previousMetadataPda: anchor.web3.PublicKey;
+    schemaPda: anchor.web3.PublicKey;
+    payer: anchor.web3.PublicKey;
+    controllers: anchor.web3.PublicKey[];
+    revision: BN;
+    metadataUri: string;
+}): Promise<anchor.web3.TransactionInstruction>;

package/dist/instructions/metadata/updateEntityMetadata.js

@@ -0,0 +1,23 @@
+import { encodePaddedAscii } from "../../helper";
+import { MAX_SCHEMA_URI_LEN } from "../../constants";
+/**
+ * Build the instruction for updating entity metadata
+ */
+export async function buildUpdateEntityMetadataIx(params) {
+    const { program, entityPda, previousMetadataPda, schemaPda, payer, controllers, revision, metadataUri, } = params;
+    const entityUriResult = encodePaddedAscii(metadataUri, MAX_SCHEMA_URI_LEN);
+    return program.methods
+        .updateEntityMetadata(revision, [...entityUriResult])
+        .accounts({
+        entity: entityPda,
+        previousMetadata: previousMetadataPda,
+        schema: schemaPda,
+        payer,
+    })
+        .remainingAccounts(controllers.map((kp) => ({
+        pubkey: kp,
+        isSigner: true,
+        isWritable: false,
+    })))
+        .instruction();
+}

package/dist/instructions/metadata/updateIpMetadata.d.ts

@@ -0,0 +1,17 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { BN, Program } from "@coral-xyz/anchor";
+import type { Metadata } from "../../types/metadata";
+/**
+ * Build the instruction for updating IP metadata
+ */
+export declare function buildUpdateIpMetadataIx(params: {
+    program: Program<Metadata>;
+    ipAssetPda: anchor.web3.PublicKey;
+    entityPda: anchor.web3.PublicKey;
+    previousMetadataPda: anchor.web3.PublicKey;
+    schemaPda: anchor.web3.PublicKey;
+    payer: anchor.web3.PublicKey;
+    version: BN;
+    controllers: anchor.web3.PublicKey[];
+    metadataUri: string;
+}): Promise<anchor.web3.TransactionInstruction>;

package/dist/instructions/metadata/updateIpMetadata.js

@@ -0,0 +1,24 @@
+import { MAX_SCHEMA_URI_LEN } from "../../constants";
+import { encodePaddedAscii } from "../../helper";
+/**
+ * Build the instruction for updating IP metadata
+ */
+export async function buildUpdateIpMetadataIx(params) {
+    const { program, ipAssetPda, entityPda, previousMetadataPda, schemaPda, payer, version, controllers, metadataUri, } = params;
+    const ipUriResult = encodePaddedAscii(metadataUri, MAX_SCHEMA_URI_LEN);
+    return program.methods
+        .updateIpMetadata(version, [...ipUriResult])
+        .accounts({
+        ipAsset: ipAssetPda,
+        entity: entityPda,
+        previousMetadata: previousMetadataPda,
+        schema: schemaPda,
+        payer,
+    })
+        .remainingAccounts(controllers.map((kp) => ({
+        pubkey: kp,
+        isSigner: true,
+        isWritable: false,
+    })))
+        .instruction();
+}

package/dist/pda/entity.d.ts

@@ -0,0 +1,5 @@
+import { PublicKey } from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+export declare function deriveEntityPda(owner: PublicKey, entityIndex: anchor.BN): [PublicKey, number];
+export declare function deriveEntityCounterPda(): [PublicKey, number];
+export declare function deriveEntityTreasuryPda(entity: PublicKey): [PublicKey, number];

package/dist/pda/entity.js

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+import { ENTITY_PROGRAM_ID, SEEDS } from "../constants";
+export function deriveEntityPda(owner, entityIndex) {
+    return PublicKey.findProgramAddressSync([
+        Buffer.from(SEEDS.ENTITY),
+        owner.toBuffer(),
+        entityIndex.toArrayLike(Buffer, "le", 8),
+    ], ENTITY_PROGRAM_ID);
+}
+export function deriveEntityCounterPda() {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.ENTITY_COUNTER)], ENTITY_PROGRAM_ID);
+}
+export function deriveEntityTreasuryPda(entity) {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.ENTITY_TREASURY), entity.toBuffer()], ENTITY_PROGRAM_ID);
+}

package/dist/pda/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./entity";
+export * from "./ip";
+export * from "./metadata";
+export * from "./schema";

package/dist/pda/index.js

@@ -0,0 +1,4 @@
+export * from "./entity";
+export * from "./ip";
+export * from "./metadata";
+export * from "./schema";

package/dist/pda/ip.d.ts

@@ -0,0 +1,9 @@
+import { PublicKey } from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+export declare function deriveIPAssetPda(entity: PublicKey, ipIndex: anchor.BN): [PublicKey, number];
+export declare function deriveIpCounterPda(): [PublicKey, number];
+export declare function deriveIPRegistryPda(): [PublicKey, number];
+export declare function deriveDerivativeLinkPda(parentIpId: bigint, childIpId: bigint): [PublicKey, number];
+export declare function deriveProvenanceClaimPda(ipAssetPda: PublicKey, evidenceHash: Buffer): [PublicKey, number];
+export declare function deriveRegistryConfigPda(): [PublicKey, number];
+export declare function deriveRegistryConfigTreasuryPda(): [PublicKey, number];

package/dist/pda/ip.js

@@ -0,0 +1,31 @@
+import { PublicKey } from "@solana/web3.js";
+import { IPCORE_PROGRAM_ID, SEEDS } from "../constants";
+export function deriveIPAssetPda(entity, ipIndex) {
+    return PublicKey.findProgramAddressSync([
+        Buffer.from(SEEDS.IP_ASSET),
+        entity.toBuffer(),
+        ipIndex.toArrayLike(Buffer, "le", 8),
+    ], IPCORE_PROGRAM_ID);
+}
+export function deriveIpCounterPda() {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.IP_COUNTER)], IPCORE_PROGRAM_ID);
+}
+export function deriveIPRegistryPda() {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.IP_REGISTRY)], IPCORE_PROGRAM_ID);
+}
+export function deriveDerivativeLinkPda(parentIpId, childIpId) {
+    const parentBuf = Buffer.alloc(8);
+    const childBuf = Buffer.alloc(8);
+    parentBuf.writeBigUInt64LE(parentIpId);
+    childBuf.writeBigUInt64LE(childIpId);
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.DERIVATIVE_LINK), parentBuf, childBuf], IPCORE_PROGRAM_ID);
+}
+export function deriveProvenanceClaimPda(ipAssetPda, evidenceHash) {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.PROVENANCE), ipAssetPda.toBuffer(), evidenceHash], IPCORE_PROGRAM_ID);
+}
+export function deriveRegistryConfigPda() {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.REGISTRY_CONFIG)], IPCORE_PROGRAM_ID);
+}
+export function deriveRegistryConfigTreasuryPda() {
+    return PublicKey.findProgramAddressSync([Buffer.from(SEEDS.REGISTRY_CONFIG_TREASURY)], IPCORE_PROGRAM_ID);
+}

package/dist/pda/metadata.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function deriveEntityMetadataPda(entity: PublicKey, version: number): [PublicKey, number];
+export declare function deriveIPMetadataPda(ipAsset: PublicKey, version: number): [PublicKey, number];

package/dist/pda/metadata.js

@@ -0,0 +1,19 @@
+import { PublicKey } from "@solana/web3.js";
+import { METADATA_PROGRAM_ID, SEEDS } from "../constants";
+import * as anchor from "@coral-xyz/anchor";
+export function deriveEntityMetadataPda(entity, version) {
+    const versionBN = new anchor.BN(version);
+    return PublicKey.findProgramAddressSync([
+        Buffer.from(SEEDS.ENTITY_METADATA),
+        entity.toBuffer(),
+        versionBN.toArrayLike(Buffer, "le", 8),
+    ], METADATA_PROGRAM_ID);
+}
+export function deriveIPMetadataPda(ipAsset, version) {
+    const versionBN = new anchor.BN(version);
+    return PublicKey.findProgramAddressSync([
+        Buffer.from(SEEDS.IP_METADATA),
+        ipAsset.toBuffer(),
+        versionBN.toArrayLike(Buffer, "le", 8),
+    ], METADATA_PROGRAM_ID);
+}

package/dist/pda/schema.d.ts

@@ -0,0 +1,2 @@
+import * as anchor from "@coral-xyz/anchor";
+export declare const deriveSchemaPda: (schemaId: string, version: string) => [anchor.web3.PublicKey, number];

package/dist/pda/schema.js

@@ -0,0 +1,12 @@
+import { MAX_SCHEMA_ID_LEN, MAX_VERSION_LEN, METADATA_PROGRAM_ID, SEEDS, } from "../constants";
+import * as anchor from "@coral-xyz/anchor";
+import { encodePaddedAscii } from "../helper";
+export const deriveSchemaPda = (schemaId, version) => {
+    const schemaIdResult = encodePaddedAscii(schemaId, MAX_SCHEMA_ID_LEN);
+    const versionResult = encodePaddedAscii(version, MAX_VERSION_LEN);
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(SEEDS.SCHEMA),
+        Buffer.from(schemaIdResult),
+        Buffer.from(versionResult), // u16 LE
+    ], METADATA_PROGRAM_ID);
+};

package/dist/programs/programIds.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const PROGRAM_IDS: {
+    devnet: {
+        entity: PublicKey;
+        metadata: PublicKey;
+        ipcore: PublicKey;
+    };
+    mainnet: {
+        entity: PublicKey;
+        metadata: PublicKey;
+        ipcore: PublicKey;
+    };
+};
+export type ProgramIds = {
+    entity: PublicKey;
+    metadata: PublicKey;
+    ipcore: PublicKey;
+};

package/dist/programs/programIds.js

@@ -0,0 +1,16 @@
+import { PublicKey } from "@solana/web3.js";
+import entityIdl from "../idl/entity.json";
+import ipcoreIdl from "../idl/ipcore.json";
+import metadataIdl from "../idl/metadata.json";
+export const PROGRAM_IDS = {
+    devnet: {
+        entity: new PublicKey(entityIdl.address),
+        metadata: new PublicKey(metadataIdl.address),
+        ipcore: new PublicKey(ipcoreIdl.address),
+    },
+    mainnet: {
+        entity: new PublicKey(entityIdl.address),
+        metadata: new PublicKey(metadataIdl.address),
+        ipcore: new PublicKey(ipcoreIdl.address),
+    },
+};

package/dist/sdk/MyceliumSDK.d.ts

@@ -0,0 +1,15 @@
+import type { MyceliumSDKConfig } from "./MyceliumSDK.types";
+import { type ProgramIds } from "../programs/programIds";
+import { EntityNamespace } from "./namespaces/entity";
+import { MetadataNamespace } from "./namespaces/metadata";
+import { IpcoreNamespace } from "./namespaces/ipcore";
+import { AdminNamespace } from "./namespaces/admin";
+export declare class MyceliumSDK {
+    readonly chain: MyceliumSDKConfig["chain"];
+    readonly programIds: ProgramIds;
+    readonly entity: EntityNamespace;
+    readonly metadata: MetadataNamespace;
+    readonly ipcore: IpcoreNamespace;
+    readonly admin: AdminNamespace;
+    constructor(config: MyceliumSDKConfig);
+}

package/dist/sdk/MyceliumSDK.js

@@ -0,0 +1,15 @@
+import { PROGRAM_IDS } from "../programs/programIds";
+import { EntityNamespace } from "./namespaces/entity";
+import { MetadataNamespace } from "./namespaces/metadata";
+import { IpcoreNamespace } from "./namespaces/ipcore";
+import { AdminNamespace } from "./namespaces/admin";
+export class MyceliumSDK {
+    constructor(config) {
+        this.chain = config.chain;
+        this.programIds = PROGRAM_IDS[this.chain];
+        this.entity = new EntityNamespace(this.programIds);
+        this.metadata = new MetadataNamespace(this.programIds);
+        this.ipcore = new IpcoreNamespace(this.programIds);
+        this.admin = new AdminNamespace(this.programIds);
+    }
+}

package/dist/sdk/MyceliumSDK.types.d.ts

@@ -0,0 +1,3 @@
+export type MyceliumSDKConfig = {
+    chain: "devnet" | "mainnet";
+};

package/dist/sdk/MyceliumSDK.types.js

@@ -0,0 +1 @@
+export {};

package/dist/sdk/namespaces/admin.d.ts

@@ -0,0 +1,23 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, Transaction } from "@solana/web3.js";
+import type { ProgramIds } from "../../programs/programIds";
+import type { Entity } from "../../types/entity";
+import type { Metadata } from "../../types/metadata";
+import type { Ipcore } from "../../types/ipcore";
+export declare class AdminNamespace {
+    private readonly programIds;
+    constructor(programIds: ProgramIds);
+    generateInitAdminTransaction(params: {
+        schemaUri: string;
+        entityProgram: Program<Entity>;
+        metadataProgram: Program<Metadata>;
+        ipcoreProgram: Program<Ipcore>;
+        payer: PublicKey;
+        registrationFee: number;
+        schemaVersion: string;
+        schemaJson: string;
+        schemaId: string;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+}

package/dist/sdk/namespaces/admin.js

@@ -0,0 +1,9 @@
+import { initAdminInstructions } from "../../transactions/admin/adminTransaction";
+export class AdminNamespace {
+    constructor(programIds) {
+        this.programIds = programIds;
+    }
+    async generateInitAdminTransaction(params) {
+        return initAdminInstructions(params);
+    }
+}

package/dist/sdk/namespaces/entity.d.ts

@@ -0,0 +1,53 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { ProgramIds } from "../../programs/programIds";
+import type { Entity } from "../../types/entity";
+import type { Metadata } from "../../types/metadata";
+export declare class EntityNamespace {
+    private readonly programIds;
+    constructor(programIds: ProgramIds);
+    generateRegisterTransaction(params: {
+        program: Program<Entity>;
+        metadataProgram: Program<Metadata>;
+        controllers: anchor.web3.PublicKey[];
+        threshold: number;
+        metadataUri: string;
+        payer: anchor.web3.PublicKey;
+    }): Promise<{
+        transaction: anchor.web3.Transaction;
+    }>;
+    generateInitCounterTransaction(params: {
+        program: Program<Entity>;
+        payer: anchor.web3.PublicKey;
+    }): Promise<{
+        transaction: anchor.web3.Transaction;
+    }>;
+    generateInitTreasuryTransaction(params: {
+        program: Program<Entity>;
+        entityPda: anchor.web3.PublicKey;
+        payer: anchor.web3.PublicKey;
+        controllers: anchor.web3.PublicKey[];
+    }): Promise<{
+        transaction: anchor.web3.Transaction;
+    }>;
+    generateUpdateControllersTransaction(params: {
+        program: Program<Entity>;
+        owner: anchor.web3.PublicKey;
+        entityIndex: anchor.BN;
+        newControllers: anchor.web3.PublicKey[];
+        newThreshold: number;
+        controllers: anchor.web3.PublicKey[];
+    }): Promise<{
+        transaction: anchor.web3.Transaction;
+        entityPda: anchor.web3.PublicKey;
+    }>;
+    generateAssertControllerThresholdTransaction(params: {
+        program: Program<Entity>;
+        owner: anchor.web3.PublicKey;
+        entityIndex: anchor.BN;
+        controllers: anchor.web3.PublicKey[];
+    }): Promise<{
+        transaction: anchor.web3.Transaction;
+        entityPda: anchor.web3.PublicKey;
+    }>;
+}

package/dist/sdk/namespaces/entity.js

@@ -0,0 +1,21 @@
+import { assertControllerThresholdTransaction, initEntityCounterTransaction, initEntityTreasuryTransaction, updateControllersTransaction, createEntityTransaction, } from "../../transactions/entity";
+export class EntityNamespace {
+    constructor(programIds) {
+        this.programIds = programIds;
+    }
+    async generateRegisterTransaction(params) {
+        return createEntityTransaction(params);
+    }
+    async generateInitCounterTransaction(params) {
+        return initEntityCounterTransaction(params);
+    }
+    async generateInitTreasuryTransaction(params) {
+        return initEntityTreasuryTransaction(params);
+    }
+    async generateUpdateControllersTransaction(params) {
+        return updateControllersTransaction(params);
+    }
+    async generateAssertControllerThresholdTransaction(params) {
+        return assertControllerThresholdTransaction(params);
+    }
+}

package/dist/sdk/namespaces/ipcore.d.ts

@@ -0,0 +1,111 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, Transaction } from "@solana/web3.js";
+import type { ProgramIds } from "../../programs/programIds";
+import type { Ipcore } from "../../types/ipcore";
+import { BN } from "@coral-xyz/anchor";
+export declare class IpcoreNamespace {
+    private readonly programIds;
+    constructor(programIds: ProgramIds);
+    generateAddDerivativeLinkTransaction(params: {
+        program: Program<Ipcore>;
+        derivativeLink: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateAddIpAssetTransaction(params: {
+        program: Program<Ipcore>;
+        registryPda: PublicKey;
+        ipAsset: PublicKey;
+        authority: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateCreateDerivativeLinkTransaction(params: {
+        program: Program<Ipcore>;
+        parentIpId: BN;
+        childIpId: BN;
+        authority: PublicKey;
+        entityPda: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+        derivativeLinkPda: PublicKey;
+    }>;
+    generateCreateProvenanceClaimTransaction(params: {
+        program: Program<Ipcore>;
+        ipAssetPda: PublicKey;
+        entity: PublicKey;
+        payer: PublicKey;
+        evidenceHash: Buffer;
+        uri: string;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+        provenancePda: PublicKey;
+    }>;
+    generateInitIpRegistryTransaction(params: {
+        program: Program<Ipcore>;
+        payer: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+        registryPda: PublicKey;
+    }>;
+    generateInitializeRegistryConfigTransaction(params: {
+        program: Program<Ipcore>;
+        authority: PublicKey;
+        feeLamports: BN;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateInitializeRegistryConfigTreasuryTransaction(params: {
+        program: Program<Ipcore>;
+        registryConfig: PublicKey;
+        authority: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateInitModuleConfigTransaction(params: {
+        program: Program<Ipcore>;
+        ipAsset: PublicKey;
+        payer: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+        moduleConfigPda: PublicKey;
+    }>;
+    generateRegisterIpAssetTransaction(params: {
+        program: Program<Ipcore>;
+        metadataProgram: Program<import("../../types").Metadata>;
+        payer: PublicKey;
+        entityIndex: number;
+        registrationFee: number;
+        metadataUri: string;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+        ipAssetPda: PublicKey;
+    }>;
+    generateResolveParentTransaction(params: {
+        program: Program<Ipcore>;
+        parentIpId: BN;
+        derivativeIpId: BN;
+        parentIp: PublicKey;
+        derivativeIp: PublicKey;
+        parentEntityAuthority: PublicKey;
+        signer: import("@solana/web3.js").Signer;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateUpdateRegistryConfigTransaction(params: {
+        program: Program<Ipcore>;
+        registryConfig: PublicKey;
+        authority: PublicKey;
+        newFeeLamports: BN;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateInitIpCounterTransaction(params: {
+        program: Program<Ipcore>;
+        payer: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+}