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

package/dist/sdk/namespaces/ipcore.js

@@ -0,0 +1,42 @@
+import { addDerivativeLinkTransaction, addIpAssetTransaction, createDerivativeLinkTransaction, createProvenanceClaimTransaction, createInitIpRegistryTransaction, createInitializeRegistryConfigTransaction, createInitializeRegistryConfigTreasuryTransaction, createInitModuleConfigTransaction, createRegisterIpAssetTransaction, createResolveParentTransaction, createUpdateRegistryConfigTransaction, initIpCounterTransaction, } from "../../transactions/ipcore";
+export class IpcoreNamespace {
+    constructor(programIds) {
+        this.programIds = programIds;
+    }
+    async generateAddDerivativeLinkTransaction(params) {
+        return addDerivativeLinkTransaction(params);
+    }
+    async generateAddIpAssetTransaction(params) {
+        return addIpAssetTransaction(params);
+    }
+    async generateCreateDerivativeLinkTransaction(params) {
+        return createDerivativeLinkTransaction(params);
+    }
+    async generateCreateProvenanceClaimTransaction(params) {
+        return createProvenanceClaimTransaction(params);
+    }
+    async generateInitIpRegistryTransaction(params) {
+        return createInitIpRegistryTransaction(params);
+    }
+    async generateInitializeRegistryConfigTransaction(params) {
+        return createInitializeRegistryConfigTransaction(params);
+    }
+    async generateInitializeRegistryConfigTreasuryTransaction(params) {
+        return createInitializeRegistryConfigTreasuryTransaction(params);
+    }
+    async generateInitModuleConfigTransaction(params) {
+        return createInitModuleConfigTransaction(params);
+    }
+    async generateRegisterIpAssetTransaction(params) {
+        return createRegisterIpAssetTransaction(params);
+    }
+    async generateResolveParentTransaction(params) {
+        return createResolveParentTransaction(params);
+    }
+    async generateUpdateRegistryConfigTransaction(params) {
+        return createUpdateRegistryConfigTransaction(params);
+    }
+    async generateInitIpCounterTransaction(params) {
+        return initIpCounterTransaction(params);
+    }
+}

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

@@ -0,0 +1,86 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, Transaction } from "@solana/web3.js";
+import type { ProgramIds } from "../../programs/programIds";
+import type { Metadata } from "../../types/metadata";
+import { BN } from "@coral-xyz/anchor";
+export declare class MetadataNamespace {
+    private readonly programIds;
+    constructor(programIds: ProgramIds);
+    generateCreateEntityMetadataTransaction(params: {
+        program: Program<Metadata>;
+        entityPda: PublicKey;
+        schemaPda: PublicKey;
+        version: BN;
+        metadataUri: string;
+        payer: PublicKey;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateCreateIpMetadataTransaction(params: {
+        program: Program<Metadata>;
+        ipAssetPda: PublicKey;
+        schemaPda: PublicKey;
+        entityPda: PublicKey;
+        version: BN;
+        metadataUri: string;
+        payer: PublicKey;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateLockEntityMetadataTransaction(params: {
+        program: Program<Metadata>;
+        metadataPda: PublicKey;
+        entityPda: PublicKey;
+        authority: PublicKey;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateLockIpMetadataTransaction(params: {
+        program: Program<Metadata>;
+        metadataPda: PublicKey;
+        ipAssetPda: PublicKey;
+        entityPda: PublicKey;
+        authority: PublicKey;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateRegisterSchemaTransaction(params: {
+        program: Program<Metadata>;
+        schemaUri: string;
+        version: string;
+        schemaJson: string;
+        schemaId: string;
+        creator: PublicKey;
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateUpdateEntityMetadataTransaction(params: {
+        program: Program<Metadata>;
+        entityPda: PublicKey;
+        previousMetadataPda: PublicKey;
+        payer: PublicKey;
+        metadataUri: string;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+    generateUpdateIpMetadataTransaction(params: {
+        program: Program<Metadata>;
+        ipAssetPda: PublicKey;
+        entityPda: PublicKey;
+        previousMetadataPda: PublicKey;
+        newMetadataPda: PublicKey;
+        schemaPda: PublicKey;
+        authority: PublicKey;
+        payer: PublicKey;
+        version: BN;
+        metadataUri: string;
+        controllers: PublicKey[];
+    }): Promise<{
+        transaction: Transaction;
+    }>;
+}

package/dist/sdk/namespaces/metadata.js

@@ -0,0 +1,27 @@
+import { createEntityMetadataTransaction, createIpMetadataTransaction, createLockEntityMetadataTransaction, createLockIpMetadataTransaction, createRegisterSchemaTransaction, createUpdateEntityMetadataTransaction, createUpdateIpMetadataTransaction, } from "../../transactions/metadata";
+export class MetadataNamespace {
+    constructor(programIds) {
+        this.programIds = programIds;
+    }
+    async generateCreateEntityMetadataTransaction(params) {
+        return createEntityMetadataTransaction(params);
+    }
+    async generateCreateIpMetadataTransaction(params) {
+        return createIpMetadataTransaction(params);
+    }
+    async generateLockEntityMetadataTransaction(params) {
+        return createLockEntityMetadataTransaction(params);
+    }
+    async generateLockIpMetadataTransaction(params) {
+        return createLockIpMetadataTransaction(params);
+    }
+    async generateRegisterSchemaTransaction(params) {
+        return createRegisterSchemaTransaction(params);
+    }
+    async generateUpdateEntityMetadataTransaction(params) {
+        return createUpdateEntityMetadataTransaction(params);
+    }
+    async generateUpdateIpMetadataTransaction(params) {
+        return createUpdateIpMetadataTransaction(params);
+    }
+}

package/dist/transactions/admin/adminTransaction.d.ts

@@ -0,0 +1,18 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import { Entity, Ipcore, Metadata } from "../../types";
+import { PublicKey } from "@solana/web3.js";
+export type AdminTransactionParams = {
+    schemaUri: string;
+    entityProgram: Program<Entity>;
+    metadataProgram: Program<Metadata>;
+    ipcoreProgram: Program<Ipcore>;
+    payer: PublicKey;
+    registrationFee: number;
+    schemaVersion: string;
+    schemaJson: string;
+    schemaId: string;
+};
+export declare function initAdminInstructions({ schemaUri, schemaId, schemaJson, schemaVersion, entityProgram, metadataProgram, ipcoreProgram, payer, registrationFee, }: AdminTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+}>;

package/dist/transactions/admin/adminTransaction.js

@@ -0,0 +1,43 @@
+import * as anchor from "@coral-xyz/anchor";
+import { deriveRegistryConfigPda } from "../../pda";
+import { buildInitEntityCounterInstruction, buildInitializeRegistryConfigIx, buildInitializeRegistryConfigTreasuryIx, buildInitIpRegistryInstruction, buildRegisterSchemaIx, } from "../../instructions";
+import { LAMPORTS_PER_SOL } from "@solana/web3.js";
+import { buildInitIpCounterInstruction } from "../../instructions/ipcore/initIpCounter";
+export async function initAdminInstructions({ schemaUri, schemaId, schemaJson, schemaVersion, entityProgram, metadataProgram, ipcoreProgram, payer, registrationFee, }) {
+    const [registryConfigPda] = deriveRegistryConfigPda();
+    const schemaInstruction = await buildRegisterSchemaIx({
+        program: metadataProgram,
+        version: schemaVersion,
+        creator: payer,
+        schemaUri: schemaUri,
+        schemaJson,
+        schemaId,
+    });
+    const registryConfigIx = await buildInitializeRegistryConfigIx({
+        program: ipcoreProgram,
+        authority: payer,
+        feeLamports: new anchor.BN(registrationFee * LAMPORTS_PER_SOL),
+    });
+    const registryConfigTreasuryIx = await buildInitializeRegistryConfigTreasuryIx({
+        program: ipcoreProgram,
+        registryConfig: registryConfigPda,
+        authority: payer,
+    });
+    const entityCounterIx = await buildInitEntityCounterInstruction({
+        program: entityProgram,
+        payer,
+    });
+    const ipCounterIx = await buildInitIpCounterInstruction({
+        program: ipcoreProgram,
+        payer,
+    });
+    const { instruction: ipRegistryInstruction } = await buildInitIpRegistryInstruction(ipcoreProgram, payer);
+    const transaction = new anchor.web3.Transaction()
+        .add(schemaInstruction)
+        .add(registryConfigIx)
+        .add(registryConfigTreasuryIx)
+        .add(entityCounterIx)
+        .add(ipCounterIx)
+        .add(ipRegistryInstruction);
+    return { transaction };
+}

package/dist/transactions/admin/index.d.ts

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

package/dist/transactions/admin/index.js

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

package/dist/transactions/entity/assertControllerThreshold.d.ts

@@ -0,0 +1,17 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { Entity } from "../../types/entity";
+export type AssertControllerThresholdTransactionParams = {
+    program: Program<Entity>;
+    owner: anchor.web3.PublicKey;
+    entityIndex: anchor.BN;
+    controllers: anchor.web3.PublicKey[];
+};
+/**
+ * Returns a Transaction containing an AssertControllerThreshold instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function assertControllerThresholdTransaction({ program, owner, entityIndex, controllers, }: AssertControllerThresholdTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+    entityPda: anchor.web3.PublicKey;
+}>;

package/dist/transactions/entity/assertControllerThreshold.js

@@ -0,0 +1,18 @@
+import * as anchor from "@coral-xyz/anchor";
+import { buildAssertControllerThresholdInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing an AssertControllerThreshold instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function assertControllerThresholdTransaction({ program, owner, entityIndex, controllers, }) {
+    // Build the instruction
+    const { instruction, entityPda } = buildAssertControllerThresholdInstruction({
+        program,
+        owner,
+        controllers,
+        entityIndex,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new anchor.web3.Transaction().add(await instruction);
+    return { transaction, entityPda };
+}

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

@@ -0,0 +1,5 @@
+export * from "./assertControllerThreshold";
+export * from "./initEntityTreasury";
+export * from "./registerEntity";
+export * from "./updateControllers";
+export * from "./initEntityCounter";

package/dist/transactions/entity/index.js

@@ -0,0 +1,5 @@
+export * from "./assertControllerThreshold";
+export * from "./initEntityTreasury";
+export * from "./registerEntity";
+export * from "./updateControllers";
+export * from "./initEntityCounter";

package/dist/transactions/entity/initEntityCounter.d.ts

@@ -0,0 +1,14 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { Entity } from "../../types/entity";
+export type InitEntityCounterTransactionParams = {
+    program: Program<Entity>;
+    payer: anchor.web3.PublicKey;
+};
+/**
+ * Returns a Transaction containing an InitEntityCounter instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function initEntityCounterTransaction({ program, payer, }: InitEntityCounterTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+}>;

package/dist/transactions/entity/initEntityCounter.js

@@ -0,0 +1,16 @@
+import * as anchor from "@coral-xyz/anchor";
+import { buildInitEntityCounterInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing an InitEntityCounter instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function initEntityCounterTransaction({ program, payer, }) {
+    // Build the instruction
+    const instruction = await buildInitEntityCounterInstruction({
+        program,
+        payer,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new anchor.web3.Transaction().add(instruction);
+    return { transaction };
+}

package/dist/transactions/entity/initEntityTreasury.d.ts

@@ -0,0 +1,16 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { Entity } from "../../types/entity";
+export type InitEntityTreasuryTransactionParams = {
+    program: Program<Entity>;
+    entityPda: anchor.web3.PublicKey;
+    payer: anchor.web3.PublicKey;
+    controllers: anchor.web3.PublicKey[];
+};
+/**
+ * Returns a Transaction containing an InitEntityTreasury instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function initEntityTreasuryTransaction({ program, entityPda, payer, controllers, }: InitEntityTreasuryTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+}>;

package/dist/transactions/entity/initEntityTreasury.js

@@ -0,0 +1,18 @@
+import * as anchor from "@coral-xyz/anchor";
+import { buildInitEntityTreasuryInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing an InitEntityTreasury instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function initEntityTreasuryTransaction({ program, entityPda, payer, controllers, }) {
+    // Build the instruction
+    const { instruction } = buildInitEntityTreasuryInstruction({
+        program,
+        entityPda,
+        payer,
+        controllers,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new anchor.web3.Transaction().add(await instruction);
+    return { transaction };
+}

package/dist/transactions/entity/registerEntity.d.ts

@@ -0,0 +1,19 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { Entity } from "../../types/entity";
+import { Metadata } from "../../types";
+export type CreateEntityTransactionParams = {
+    program: Program<Entity>;
+    metadataProgram: Program<Metadata>;
+    controllers: anchor.web3.PublicKey[];
+    threshold: number;
+    metadataUri: string;
+    payer: anchor.web3.PublicKey;
+};
+/**
+ * Returns a Transaction containing a RegisterEntity instruction
+ * Does NOT sign or send the transaction
+ */
+export declare function createEntityTransaction({ program, metadataProgram, controllers, threshold, metadataUri, payer, }: CreateEntityTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+}>;

package/dist/transactions/entity/registerEntity.js

@@ -0,0 +1,44 @@
+import * as anchor from "@coral-xyz/anchor";
+import { buildCreateEntityMetadataIx, buildRegisterEntityInstruction, } from "../../instructions";
+import { deriveEntityCounterPda, deriveEntityPda, deriveSchemaPda, } from "../../pda";
+/**
+ * Returns a Transaction containing a RegisterEntity instruction
+ * Does NOT sign or send the transaction
+ */
+export async function createEntityTransaction({ program, metadataProgram, controllers, threshold, metadataUri, payer, }) {
+    let entityIndex = new anchor.BN(0);
+    const [entityCounterPda] = deriveEntityCounterPda();
+    const currentCounter = await program.account.entityCounter.fetchNullable(entityCounterPda);
+    if (currentCounter) {
+        entityIndex = currentCounter.nextEntityIndex;
+    }
+    // Build the instruction using our reusable helper
+    const instruction = await buildRegisterEntityInstruction({
+        program,
+        controllers,
+        threshold,
+        payer,
+    });
+    const [entityPda] = deriveEntityPda(payer, entityIndex);
+    const schemaId = "metadata.registry";
+    const schemaVersion = "1.0.0";
+    const [schemaPda] = deriveSchemaPda(schemaId, schemaVersion);
+    const currentSchema = await metadataProgram.account.schemaRegistry.fetchNullable(schemaPda);
+    if (!currentSchema) {
+        throw new Error(`Schema not registered: version=${schemaVersion.toString()}`);
+    }
+    const metadataInstruction = await buildCreateEntityMetadataIx({
+        program: metadataProgram,
+        entityPda: entityPda,
+        schemaPda: schemaPda,
+        version: new anchor.BN(1),
+        metadataUri,
+        payer,
+        controllers,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new anchor.web3.Transaction();
+    transaction.add(instruction);
+    transaction.add(metadataInstruction);
+    return { transaction };
+}

package/dist/transactions/entity/updateControllers.d.ts

@@ -0,0 +1,19 @@
+import type { Program } from "@coral-xyz/anchor";
+import * as anchor from "@coral-xyz/anchor";
+import type { Entity } from "../../types/entity";
+export type UpdateControllersTransactionParams = {
+    program: Program<Entity>;
+    owner: anchor.web3.PublicKey;
+    entityIndex: anchor.BN;
+    newControllers: anchor.web3.PublicKey[];
+    newThreshold: number;
+    controllers: anchor.web3.PublicKey[];
+};
+/**
+ * Returns a Transaction containing an UpdateControllers instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function updateControllersTransaction({ program, owner, entityIndex, newControllers, newThreshold, controllers, }: UpdateControllersTransactionParams): Promise<{
+    transaction: anchor.web3.Transaction;
+    entityPda: anchor.web3.PublicKey;
+}>;

package/dist/transactions/entity/updateControllers.js

@@ -0,0 +1,20 @@
+import * as anchor from "@coral-xyz/anchor";
+import { buildUpdateControllersInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing an UpdateControllers instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function updateControllersTransaction({ program, owner, entityIndex, newControllers, newThreshold, controllers, }) {
+    // Build the instruction
+    const { instruction, entityPda } = buildUpdateControllersInstruction({
+        program,
+        owner,
+        entityIndex,
+        newControllers,
+        newThreshold,
+        controllers,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new anchor.web3.Transaction().add(await instruction);
+    return { transaction, entityPda };
+}

package/dist/transactions/index.d.ts

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

package/dist/transactions/index.js

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

package/dist/transactions/ipcore/addDerivativeLink.d.ts

@@ -0,0 +1,14 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, Transaction } from "@solana/web3.js";
+import type { Ipcore } from "../../types/ipcore";
+export type AddDerivativeLinkTransactionParams = {
+    program: Program<Ipcore>;
+    derivativeLink: PublicKey;
+};
+/**
+ * Returns a Transaction containing the addDerivativeLink instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function addDerivativeLinkTransaction({ program, derivativeLink, }: AddDerivativeLinkTransactionParams): Promise<{
+    transaction: Transaction;
+}>;

package/dist/transactions/ipcore/addDerivativeLink.js

@@ -0,0 +1,15 @@
+import { Transaction } from "@solana/web3.js";
+import { buildAddDerivativeLinkInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing the addDerivativeLink instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function addDerivativeLinkTransaction({ program, derivativeLink, }) {
+    // Build the instruction
+    const { instruction } = await buildAddDerivativeLinkInstruction(program, {
+        derivativeLink,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new Transaction().add(instruction);
+    return { transaction };
+}

package/dist/transactions/ipcore/addIpAsset.d.ts

@@ -0,0 +1,15 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { Program } from "@coral-xyz/anchor";
+import { Transaction } from "@solana/web3.js";
+import type { Ipcore } from "../../types/ipcore";
+export type AddIpAssetTransactionParams = {
+    program: Program<Ipcore>;
+    ipAsset: anchor.web3.PublicKey;
+};
+/**
+ * Returns a Transaction containing the addIpAsset instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function addIpAssetTransaction({ program, ipAsset, }: AddIpAssetTransactionParams): Promise<{
+    transaction: Transaction;
+}>;

package/dist/transactions/ipcore/addIpAsset.js

@@ -0,0 +1,13 @@
+import { Transaction } from "@solana/web3.js";
+import { buildAddIpAssetInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing the addIpAsset instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function addIpAssetTransaction({ program, ipAsset, }) {
+    // Build the instruction
+    const instruction = await buildAddIpAssetInstruction({ program, ipAsset });
+    // Create a transaction and add the instruction
+    const transaction = new Transaction().add(instruction);
+    return { transaction };
+}

package/dist/transactions/ipcore/createDerivativeLink.d.ts

@@ -0,0 +1,19 @@
+import type * as anchor from "@coral-xyz/anchor";
+import type { BN, Program } from "@coral-xyz/anchor";
+import { Transaction } from "@solana/web3.js";
+import type { Ipcore } from "../../types/ipcore";
+export type CreateDerivativeLinkTransactionParams = {
+    program: Program<Ipcore>;
+    parentIpId: BN;
+    childIpId: BN;
+    authority: anchor.web3.PublicKey;
+    entityPda: anchor.web3.PublicKey;
+};
+/**
+ * Returns a Transaction containing the createDerivativeLink instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function createDerivativeLinkTransaction({ program, parentIpId, childIpId, authority, entityPda, }: CreateDerivativeLinkTransactionParams): Promise<{
+    transaction: Transaction;
+    derivativeLinkPda: anchor.web3.PublicKey;
+}>;

package/dist/transactions/ipcore/createDerivativeLink.js

@@ -0,0 +1,18 @@
+import { Transaction } from "@solana/web3.js";
+import { buildCreateDerivativeLinkInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing the createDerivativeLink instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function createDerivativeLinkTransaction({ program, parentIpId, childIpId, authority, entityPda, }) {
+    // Build the instruction
+    const { instruction, derivativeLinkPda } = await buildCreateDerivativeLinkInstruction(program, {
+        parentIpId,
+        childIpId,
+        authority,
+        entityPda,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new Transaction().add(instruction);
+    return { transaction, derivativeLinkPda };
+}

package/dist/transactions/ipcore/createProvenanceClaim.d.ts

@@ -0,0 +1,20 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, Transaction } from "@solana/web3.js";
+import type { Ipcore } from "../../types/ipcore";
+export type CreateProvenanceClaimTransactionParams = {
+    program: Program<Ipcore>;
+    ipAssetPda: PublicKey;
+    entity: PublicKey;
+    payer: PublicKey;
+    evidenceHash: Buffer;
+    uri: string;
+    controllers: PublicKey[];
+};
+/**
+ * Returns a Transaction containing the createProvenanceClaim instruction.
+ * Does NOT sign or send the transaction.
+ */
+export declare function createProvenanceClaimTransaction({ program, ipAssetPda, entity, payer, evidenceHash, uri, controllers, }: CreateProvenanceClaimTransactionParams): Promise<{
+    transaction: Transaction;
+    provenancePda: PublicKey;
+}>;

package/dist/transactions/ipcore/createProvenanceClaim.js

@@ -0,0 +1,20 @@
+import { Transaction } from "@solana/web3.js";
+import { buildCreateProvenanceClaimInstruction } from "../../instructions";
+/**
+ * Returns a Transaction containing the createProvenanceClaim instruction.
+ * Does NOT sign or send the transaction.
+ */
+export async function createProvenanceClaimTransaction({ program, ipAssetPda, entity, payer, evidenceHash, uri, controllers, }) {
+    // Build the instruction
+    const { instruction, provenancePda } = await buildCreateProvenanceClaimInstruction(program, {
+        ipAssetPda,
+        entity,
+        payer,
+        evidenceHash,
+        uri,
+        controllers,
+    });
+    // Create a transaction and add the instruction
+    const transaction = new Transaction().add(instruction);
+    return { transaction, provenancePda };
+}

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

@@ -0,0 +1,12 @@
+export * from "./addDerivativeLink";
+export * from "./addIpAsset";
+export * from "./createDerivativeLink";
+export * from "./createProvenanceClaim";
+export * from "./initIpRegistry";
+export * from "./initializeRegistryConfig";
+export * from "./initializeRegistryConfigTreasury";
+export * from "./initModuleConfig";
+export * from "./registerIpAsset";
+export * from "./resolveParent";
+export * from "./updateRegistryConfig";
+export * from "./initIpCounter";

package/dist/transactions/ipcore/index.js

@@ -0,0 +1,12 @@
+export * from "./addDerivativeLink";
+export * from "./addIpAsset";
+export * from "./createDerivativeLink";
+export * from "./createProvenanceClaim";
+export * from "./initIpRegistry";
+export * from "./initializeRegistryConfig";
+export * from "./initializeRegistryConfigTreasury";
+export * from "./initModuleConfig";
+export * from "./registerIpAsset";
+export * from "./resolveParent";
+export * from "./updateRegistryConfig";
+export * from "./initIpCounter";