@meshsdk/contract 1.7.10 → 1.7.11

package/dist/index.cjs

@@ -987,7 +987,24 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       scriptAddress
     };
   };
-  // Setup
+  /**
+   * [Setup phase]
+   * This is the first transaction you need to setup the contract.
+   *
+   * This transaction mints the one-time minting policy (a NFT) for the contract.
+   * It will be attached with the datum which serves as the single source of truth for the contract oracle.
+   *
+   * Note: You must save the `paramUtxo` for future transactions.
+   *
+   * @returns {Promise<{ txHexMintOneTimeMintingPolicy: string, txHexSetupOracleUtxo: string, paramUtxo: UTxO["input"] }>}
+   *
+   * @example
+   * ```typescript
+   * const { tx, paramUtxo } = await contract.mintOneTimeMintingPolicy();
+   * const signedTx = await wallet.signTx(tx);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   mintOneTimeMintingPolicy = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     if (utxos?.length <= 0) {
@@ -1018,14 +1035,27 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       this.stakeCredential,
       this.networkId
     );
+    this.paramUtxo = paramUtxo.input;
     return { tx: txHex, paramUtxo: paramUtxo.input };
   };
-  sendRefScriptOnchain = async (scriptIndex) => {
-    const { utxos, walletAddress } = await this.getWalletInfoForTx();
-    const { scriptAddress } = this.getOwnerNativeScript();
-    const txHex = await this.mesh.txOut(scriptAddress, []).txOutReferenceScript(getScriptCbor(this.paramUtxo, scriptIndex)).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
-    return txHex;
-  };
+  /**
+   * [Setup phase]
+   * This is the second transaction you need to setup the contract.
+   *
+   * This transaction send the NFT to a oracle contract locking the datum,
+   * which serves as the single source of truth for the contract oracle with data integrity.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.setupOracleUtxo();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   setupOracleUtxo = async () => {
     const { utxos, walletAddress } = await this.getWalletInfoForTx();
     const datumValue = this.getOracleDatum(0, 0);
@@ -1034,22 +1064,60 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ]).txOutInlineDatumValue(datumValue).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
     return txHex;
   };
-  // WIP. need to chain tx, and also need to manage the UTXOs not consumed
-  handleSetup = async () => {
-    const { tx: txHexMintOneTimeMintingPolicy, paramUtxo } = await this.mintOneTimeMintingPolicy();
-    this.paramUtxo = paramUtxo;
-    this.scriptInfo = getScriptInfo(
-      paramUtxo,
-      this.stakeCredential,
-      this.networkId
-    );
-    const txHexSetupOracleUtxo = await this.setupOracleUtxo();
-    return {
-      txHexMintOneTimeMintingPolicy,
-      txHexSetupOracleUtxo,
-      paramUtxo
-    };
+  /**
+   * [Setup phase]
+   * This are the next transactions you need to setup the contract.
+   * You need to run once for each script, and you would likely have to run one after the previous one is confirmed.
+   *
+   * This transaction sends the reference scripts to the blockchain for later transactions,
+   * boosting efficiency and avoid exceeding 16kb of transaction size limits enforced by protocol parameter.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must save txHash (after signed and submitted) for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken` transactions for future transactions.
+   *
+   * @param scriptIndex - "OracleNFT" | "OracleValidator" | "ContentRegistry" | "ContentRefToken" | "OwnershipRegistry" | "OwnershipRefToken"
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHexOracleNFT = await contract.sendRefScriptOnchain("OracleNFT");
+   * const signedTxOracleNFT = await wallet.signTx(txHexOracleNFT);
+   * const txHashOracleNFT = await wallet.submitTx(signedTxOracleNFT);
+   *
+   * const txHexOracleValidator = await contract.sendRefScriptOnchain("OracleValidator");
+   * ... // repeat for each script
+   *
+   * const txHexOwnershipRefToken = await contract.sendRefScriptOnchain("OwnershipRefToken");
+   * const signedTxOwnershipRefToken = await wallet.signTx(txHexOwnershipRefToken);
+   * const txHashOwnershipRefToken = await wallet.submitTx(signedTxOwnershipRefToken);
+   * ```
+   */
+  sendRefScriptOnchain = async (scriptIndex) => {
+    const { utxos, walletAddress } = await this.getWalletInfoForTx();
+    const { scriptAddress } = this.getOwnerNativeScript();
+    const txHex = await this.mesh.txOut(scriptAddress, []).txOutReferenceScript(getScriptCbor(this.paramUtxo, scriptIndex)).changeAddress(walletAddress).selectUtxosFrom(utxos, "experimental", "20000000").complete();
+    return txHex;
   };
+  /**
+   * [Setup phase]
+   * This is the next transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+   *
+   * This transaction creates one content registry. Each registry should comes in pair with one ownership registry and
+   * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+   * according to the number of parallelization needed and volumes of content expected to be managed.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.createContentRegistry();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   createContentRegistry = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
@@ -1090,6 +1158,26 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ).changeAddress(walletAddress).selectUtxosFrom(utxos, "largestFirstMultiAsset").complete();
     return txHex;
   };
+  /**
+   * [Setup phase]
+   * This is the last transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+   *
+   * This transaction creates one content registry. Each registry should comes in pair with one content registry and
+   * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+   * according to the number of parallelization needed and volumes of content expected to be managed.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.createOwnershipRegistry();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   createOwnershipRegistry = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
@@ -1126,10 +1214,79 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       collateral.input.outputIndex,
       collateral.output.amount,
       collateral.output.address
-    ).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
+    ).changeAddress(walletAddress).selectUtxosFrom(utxos, "largestFirstMultiAsset").complete();
+    return txHex;
+  };
+  /**
+   * Get the current oracle data.
+   *
+   * @returns {Promise<{
+   *  contentNumber: number,
+   *  ownershipNumber: number,
+   * }>}
+   *
+   * @example
+   * ```typescript
+   * const oracleData = await contract.getOracleData();
+   * ```
+   */
+  getOracleData = async () => {
+    const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
+      this.scriptInfo.oracleValidator.address,
+      this.scriptInfo.oracleNFT.hash
+    );
+    const currentOracleDatum = await this.getCurrentOracleDatum(scriptUtxo);
+    const contentNumber = currentOracleDatum.fields[4].int;
+    const ownershipNumber = currentOracleDatum.fields[7].int;
+    return {
+      contentNumber,
+      ownershipNumber
+    };
+  };
+  /**
+   * [User]
+   *
+   * This transaction mints a user token which can be used to represent the ownership of the content. This token is used in `createContent()` transaction.
+   *
+   * @param tokenName - The name of the token that you can specify.
+   * @param tokenMetadata - The metadata of the token that you can specify.
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const tx = await contract.mintUserToken("MeshContentOwnership", {
+   *   name: "Mesh Content Ownership",
+   *   description: "Demo at https://meshjs.dev/smart-contracts/content-ownership",
+   * });
+   * const signedTx = await wallet.signTx(tx, true);
+   * const txHash = await wallet.submitTx(signedTx);
+   */
+  mintUserToken = async (tokenName2, tokenMetadata = {}) => {
+    const { utxos, walletAddress } = await this.getWalletInfoForTx();
+    const { pubKeyHash: keyHash } = (0, import_core3.deserializeAddress)(walletAddress);
+    const nativeScript = {
+      type: "all",
+      scripts: [
+        {
+          type: "sig",
+          keyHash
+        }
+      ]
+    };
+    const forgingScript = import_core3.ForgeScript.fromNativeScript(nativeScript);
+    const policyId = (0, import_core3.resolveScriptHash)(forgingScript);
+    const tokenNameHex = (0, import_core3.stringToHex)(tokenName2);
+    const metadata = { [policyId]: { [tokenName2]: { ...tokenMetadata } } };
+    const txHex = await this.mesh.mint("1", policyId, tokenNameHex).mintingScript(forgingScript).metadataValue("721", metadata).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
     return txHex;
   };
-  // User
+  /**
+   *
+   * @param ownerAssetHex
+   * @param contentHashHex
+   * @param registryNumber
+   * @returns
+   */
   createContent = async (ownerAssetHex, contentHashHex, registryNumber = 0) => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const registryName = (0, import_core3.stringToHex)(`Registry (${registryNumber})`);
@@ -1199,6 +1356,24 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ).selectUtxosFrom(utxos).complete();
     return txHex;
   };
+  /**
+   * Get the content at the registry given the registry number and content number.
+   * @param registryNumber
+   * @param contentNumber
+   * @returns
+   */
+  getContent = async (registryNumber, contentNumber) => {
+    const [content] = await this.getScriptUtxos(registryNumber, ["content"]);
+    if (content === void 0) throw new Error("Content registry not found");
+    const contentDatam = (0, import_core_csl2.parseDatumCbor)(
+      content.output.plutusData
+    );
+    const contentAtRegistry = contentDatam.fields[1].list;
+    if (contentAtRegistry.length <= contentNumber)
+      throw new Error("Content not found");
+    const decoded = (0, import_core3.toUTF8)(contentAtRegistry[contentNumber]?.bytes);
+    return decoded;
+  };
   updateContent = async ({
     ownerTokenUtxo,
     registryNumber,

package/dist/index.d.cts

@@ -63,6 +63,44 @@ type TransferContent = {
     contentNumber: number;
 };
 
+/**
+ * Mesh Content Ownership Contract
+ *
+ * This contract is used to manage the ownership of content.
+ * It facilitates on-chain record of content (i.e. file on IPFS) ownership and transfer.
+ * While one cannot prefer others from obtaining a copy of the content, the app owner of the
+ * contract can serve the single source of truth of who owns the content. With the blockchain
+ * trace and record in place, it provides a trustless way to verify the ownership of the content
+ * and facilitates further application logics such as royalties, licensing, etc.
+ *
+ * @example
+ * ```typescript
+ *  const meshTxBuilder = new MeshTxBuilder({
+ *   fetcher: blockchainProvider, // one of the Providers
+ *   submitter: blockchainProvider,
+ *   verbose: true,
+ * });
+ *
+ * const contract = new MeshContentOwnershipContract(
+ *   {
+ *     mesh: meshTxBuilder,
+ *     fetcher: blockchainProvider,
+ *     wallet: wallet,
+ *     networkId: 0,
+ *   },
+ *   {
+ *     operationAddress: operationAddress, // the address of the app owner, where most of the actions should be signed by the spending key of this address
+ *     paramUtxo: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" }, // you can get this from the output of `mintOneTimeMintingPolicy()` transaction
+ *     refScriptUtxos?: { // you can get these from the output of `sendRefScriptOnchain()` transactions
+ *       contentRegistry: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       contentRefToken: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       ownershipRegistry: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       ownershipRefToken: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *     },
+ *   },
+ * );
+ * ```
+ */
 declare class MeshContentOwnershipContract extends MeshTxInitiator {
     paramUtxo: {
         txHash: string;
@@ -134,6 +172,24 @@ declare class MeshContentOwnershipContract extends MeshTxInitiator {
         };
         scriptAddress: string;
     };
+    /**
+     * [Setup phase]
+     * This is the first transaction you need to setup the contract.
+     *
+     * This transaction mints the one-time minting policy (a NFT) for the contract.
+     * It will be attached with the datum which serves as the single source of truth for the contract oracle.
+     *
+     * Note: You must save the `paramUtxo` for future transactions.
+     *
+     * @returns {Promise<{ txHexMintOneTimeMintingPolicy: string, txHexSetupOracleUtxo: string, paramUtxo: UTxO["input"] }>}
+     *
+     * @example
+     * ```typescript
+     * const { tx, paramUtxo } = await contract.mintOneTimeMintingPolicy();
+     * const signedTx = await wallet.signTx(tx);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     mintOneTimeMintingPolicy: () => Promise<{
         tx: string;
         paramUtxo: {
@@ -141,19 +197,147 @@ declare class MeshContentOwnershipContract extends MeshTxInitiator {
             txHash: string;
         };
     }>;
-    sendRefScriptOnchain: (scriptIndex: ScriptIndex) => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the second transaction you need to setup the contract.
+     *
+     * This transaction send the NFT to a oracle contract locking the datum,
+     * which serves as the single source of truth for the contract oracle with data integrity.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.setupOracleUtxo();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     setupOracleUtxo: () => Promise<string>;
-    handleSetup: () => Promise<{
-        txHexMintOneTimeMintingPolicy: string;
-        txHexSetupOracleUtxo: string;
-        paramUtxo: {
-            outputIndex: number;
-            txHash: string;
-        };
-    }>;
+    /**
+     * [Setup phase]
+     * This are the next transactions you need to setup the contract.
+     * You need to run once for each script, and you would likely have to run one after the previous one is confirmed.
+     *
+     * This transaction sends the reference scripts to the blockchain for later transactions,
+     * boosting efficiency and avoid exceeding 16kb of transaction size limits enforced by protocol parameter.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must save txHash (after signed and submitted) for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken` transactions for future transactions.
+     *
+     * @param scriptIndex - "OracleNFT" | "OracleValidator" | "ContentRegistry" | "ContentRefToken" | "OwnershipRegistry" | "OwnershipRefToken"
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHexOracleNFT = await contract.sendRefScriptOnchain("OracleNFT");
+     * const signedTxOracleNFT = await wallet.signTx(txHexOracleNFT);
+     * const txHashOracleNFT = await wallet.submitTx(signedTxOracleNFT);
+     *
+     * const txHexOracleValidator = await contract.sendRefScriptOnchain("OracleValidator");
+     * ... // repeat for each script
+     *
+     * const txHexOwnershipRefToken = await contract.sendRefScriptOnchain("OwnershipRefToken");
+     * const signedTxOwnershipRefToken = await wallet.signTx(txHexOwnershipRefToken);
+     * const txHashOwnershipRefToken = await wallet.submitTx(signedTxOwnershipRefToken);
+     * ```
+     */
+    sendRefScriptOnchain: (scriptIndex: ScriptIndex) => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the next transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+     *
+     * This transaction creates one content registry. Each registry should comes in pair with one ownership registry and
+     * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+     * according to the number of parallelization needed and volumes of content expected to be managed.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.createContentRegistry();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     createContentRegistry: () => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the last transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+     *
+     * This transaction creates one content registry. Each registry should comes in pair with one content registry and
+     * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+     * according to the number of parallelization needed and volumes of content expected to be managed.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.createOwnershipRegistry();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     createOwnershipRegistry: () => Promise<string>;
+    /**
+     * Get the current oracle data.
+     *
+     * @returns {Promise<{
+     *  contentNumber: number,
+     *  ownershipNumber: number,
+     * }>}
+     *
+     * @example
+     * ```typescript
+     * const oracleData = await contract.getOracleData();
+     * ```
+     */
+    getOracleData: () => Promise<{
+        contentNumber: number;
+        ownershipNumber: number;
+    }>;
+    /**
+     * [User]
+     *
+     * This transaction mints a user token which can be used to represent the ownership of the content. This token is used in `createContent()` transaction.
+     *
+     * @param tokenName - The name of the token that you can specify.
+     * @param tokenMetadata - The metadata of the token that you can specify.
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const tx = await contract.mintUserToken("MeshContentOwnership", {
+     *   name: "Mesh Content Ownership",
+     *   description: "Demo at https://meshjs.dev/smart-contracts/content-ownership",
+     * });
+     * const signedTx = await wallet.signTx(tx, true);
+     * const txHash = await wallet.submitTx(signedTx);
+     */
+    mintUserToken: (tokenName: string, tokenMetadata?: {}) => Promise<string>;
+    /**
+     *
+     * @param ownerAssetHex
+     * @param contentHashHex
+     * @param registryNumber
+     * @returns
+     */
     createContent: (ownerAssetHex: string, contentHashHex: string, registryNumber?: number) => Promise<string>;
+    /**
+     * Get the content at the registry given the registry number and content number.
+     * @param registryNumber
+     * @param contentNumber
+     * @returns
+     */
+    getContent: (registryNumber: number, contentNumber: number) => Promise<string>;
     updateContent: ({ ownerTokenUtxo, registryNumber, newContentHashHex, contentNumber, }: UpdateContent) => Promise<string>;
     transferContent: ({ ownerTokenUtxo, registryNumber, newOwnerAssetHex, contentNumber, }: TransferContent) => Promise<string>;
     stopContentRegistry: (registryNumber: number) => Promise<string>;

package/dist/index.d.ts

@@ -63,6 +63,44 @@ type TransferContent = {
     contentNumber: number;
 };
 
+/**
+ * Mesh Content Ownership Contract
+ *
+ * This contract is used to manage the ownership of content.
+ * It facilitates on-chain record of content (i.e. file on IPFS) ownership and transfer.
+ * While one cannot prefer others from obtaining a copy of the content, the app owner of the
+ * contract can serve the single source of truth of who owns the content. With the blockchain
+ * trace and record in place, it provides a trustless way to verify the ownership of the content
+ * and facilitates further application logics such as royalties, licensing, etc.
+ *
+ * @example
+ * ```typescript
+ *  const meshTxBuilder = new MeshTxBuilder({
+ *   fetcher: blockchainProvider, // one of the Providers
+ *   submitter: blockchainProvider,
+ *   verbose: true,
+ * });
+ *
+ * const contract = new MeshContentOwnershipContract(
+ *   {
+ *     mesh: meshTxBuilder,
+ *     fetcher: blockchainProvider,
+ *     wallet: wallet,
+ *     networkId: 0,
+ *   },
+ *   {
+ *     operationAddress: operationAddress, // the address of the app owner, where most of the actions should be signed by the spending key of this address
+ *     paramUtxo: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" }, // you can get this from the output of `mintOneTimeMintingPolicy()` transaction
+ *     refScriptUtxos?: { // you can get these from the output of `sendRefScriptOnchain()` transactions
+ *       contentRegistry: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       contentRefToken: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       ownershipRegistry: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *       ownershipRefToken: { outputIndex: 0, txHash: "0000000000000000000000000000000000000000000000000000000000000000" },
+ *     },
+ *   },
+ * );
+ * ```
+ */
 declare class MeshContentOwnershipContract extends MeshTxInitiator {
     paramUtxo: {
         txHash: string;
@@ -134,6 +172,24 @@ declare class MeshContentOwnershipContract extends MeshTxInitiator {
         };
         scriptAddress: string;
     };
+    /**
+     * [Setup phase]
+     * This is the first transaction you need to setup the contract.
+     *
+     * This transaction mints the one-time minting policy (a NFT) for the contract.
+     * It will be attached with the datum which serves as the single source of truth for the contract oracle.
+     *
+     * Note: You must save the `paramUtxo` for future transactions.
+     *
+     * @returns {Promise<{ txHexMintOneTimeMintingPolicy: string, txHexSetupOracleUtxo: string, paramUtxo: UTxO["input"] }>}
+     *
+     * @example
+     * ```typescript
+     * const { tx, paramUtxo } = await contract.mintOneTimeMintingPolicy();
+     * const signedTx = await wallet.signTx(tx);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     mintOneTimeMintingPolicy: () => Promise<{
         tx: string;
         paramUtxo: {
@@ -141,19 +197,147 @@ declare class MeshContentOwnershipContract extends MeshTxInitiator {
             txHash: string;
         };
     }>;
-    sendRefScriptOnchain: (scriptIndex: ScriptIndex) => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the second transaction you need to setup the contract.
+     *
+     * This transaction send the NFT to a oracle contract locking the datum,
+     * which serves as the single source of truth for the contract oracle with data integrity.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.setupOracleUtxo();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     setupOracleUtxo: () => Promise<string>;
-    handleSetup: () => Promise<{
-        txHexMintOneTimeMintingPolicy: string;
-        txHexSetupOracleUtxo: string;
-        paramUtxo: {
-            outputIndex: number;
-            txHash: string;
-        };
-    }>;
+    /**
+     * [Setup phase]
+     * This are the next transactions you need to setup the contract.
+     * You need to run once for each script, and you would likely have to run one after the previous one is confirmed.
+     *
+     * This transaction sends the reference scripts to the blockchain for later transactions,
+     * boosting efficiency and avoid exceeding 16kb of transaction size limits enforced by protocol parameter.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must save txHash (after signed and submitted) for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken` transactions for future transactions.
+     *
+     * @param scriptIndex - "OracleNFT" | "OracleValidator" | "ContentRegistry" | "ContentRefToken" | "OwnershipRegistry" | "OwnershipRefToken"
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHexOracleNFT = await contract.sendRefScriptOnchain("OracleNFT");
+     * const signedTxOracleNFT = await wallet.signTx(txHexOracleNFT);
+     * const txHashOracleNFT = await wallet.submitTx(signedTxOracleNFT);
+     *
+     * const txHexOracleValidator = await contract.sendRefScriptOnchain("OracleValidator");
+     * ... // repeat for each script
+     *
+     * const txHexOwnershipRefToken = await contract.sendRefScriptOnchain("OwnershipRefToken");
+     * const signedTxOwnershipRefToken = await wallet.signTx(txHexOwnershipRefToken);
+     * const txHashOwnershipRefToken = await wallet.submitTx(signedTxOwnershipRefToken);
+     * ```
+     */
+    sendRefScriptOnchain: (scriptIndex: ScriptIndex) => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the next transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+     *
+     * This transaction creates one content registry. Each registry should comes in pair with one ownership registry and
+     * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+     * according to the number of parallelization needed and volumes of content expected to be managed.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.createContentRegistry();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     createContentRegistry: () => Promise<string>;
+    /**
+     * [Setup phase]
+     * This is the last transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+     *
+     * This transaction creates one content registry. Each registry should comes in pair with one content registry and
+     * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+     * according to the number of parallelization needed and volumes of content expected to be managed.
+     *
+     * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+     * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+     *
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const txHex = await contract.createOwnershipRegistry();
+     * const signedTx = await wallet.signTx(txHex);
+     * const txHash = await wallet.submitTx(signedTx);
+     * ```
+     */
     createOwnershipRegistry: () => Promise<string>;
+    /**
+     * Get the current oracle data.
+     *
+     * @returns {Promise<{
+     *  contentNumber: number,
+     *  ownershipNumber: number,
+     * }>}
+     *
+     * @example
+     * ```typescript
+     * const oracleData = await contract.getOracleData();
+     * ```
+     */
+    getOracleData: () => Promise<{
+        contentNumber: number;
+        ownershipNumber: number;
+    }>;
+    /**
+     * [User]
+     *
+     * This transaction mints a user token which can be used to represent the ownership of the content. This token is used in `createContent()` transaction.
+     *
+     * @param tokenName - The name of the token that you can specify.
+     * @param tokenMetadata - The metadata of the token that you can specify.
+     * @returns {Promise<string>}
+     *
+     * @example
+     * ```typescript
+     * const tx = await contract.mintUserToken("MeshContentOwnership", {
+     *   name: "Mesh Content Ownership",
+     *   description: "Demo at https://meshjs.dev/smart-contracts/content-ownership",
+     * });
+     * const signedTx = await wallet.signTx(tx, true);
+     * const txHash = await wallet.submitTx(signedTx);
+     */
+    mintUserToken: (tokenName: string, tokenMetadata?: {}) => Promise<string>;
+    /**
+     *
+     * @param ownerAssetHex
+     * @param contentHashHex
+     * @param registryNumber
+     * @returns
+     */
     createContent: (ownerAssetHex: string, contentHashHex: string, registryNumber?: number) => Promise<string>;
+    /**
+     * Get the content at the registry given the registry number and content number.
+     * @param registryNumber
+     * @param contentNumber
+     * @returns
+     */
+    getContent: (registryNumber: number, contentNumber: number) => Promise<string>;
     updateContent: ({ ownerTokenUtxo, registryNumber, newContentHashHex, contentNumber, }: UpdateContent) => Promise<string>;
     transferContent: ({ ownerTokenUtxo, registryNumber, newOwnerAssetHex, contentNumber, }: TransferContent) => Promise<string>;
     stopContentRegistry: (registryNumber: number) => Promise<string>;

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/content-ownership/offchain/offchain.ts
 import {
-  deserializeAddress as deserializeAddress2,
+  deserializeAddress,
+  ForgeScript,
   mConStr,
   mConStr0,
   mConStr1,
@@ -8,9 +9,14 @@ import {
   mScriptAddress,
   resolveScriptHash as resolveScriptHash2,
   serializeNativeScript,
-  stringToHex
+  stringToHex,
+  toUTF8
 } from "@meshsdk/core";
-import { applyParamsToScript as applyParamsToScript2, parseInlineDatum } from "@meshsdk/core-csl";
+import {
+  applyParamsToScript as applyParamsToScript2,
+  parseDatumCbor,
+  parseInlineDatum
+} from "@meshsdk/core-csl";
 
 // src/common.ts
 import {
@@ -942,11 +948,11 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       this.networkId
     );
     this.operationAddress = contract.operationAddress;
-    const serializedOpsPlutusAddr = deserializeAddress2(this.operationAddress);
+    const serializedOpsPlutusAddr = deserializeAddress(this.operationAddress);
     this.opsKey = serializedOpsPlutusAddr.pubKeyHash;
   }
   getOwnerNativeScript = () => {
-    const { pubKeyHash: keyHash } = deserializeAddress2(this.operationAddress);
+    const { pubKeyHash: keyHash } = deserializeAddress(this.operationAddress);
     const nativeScript = {
       type: "all",
       scripts: [
@@ -966,7 +972,24 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       scriptAddress
     };
   };
-  // Setup
+  /**
+   * [Setup phase]
+   * This is the first transaction you need to setup the contract.
+   *
+   * This transaction mints the one-time minting policy (a NFT) for the contract.
+   * It will be attached with the datum which serves as the single source of truth for the contract oracle.
+   *
+   * Note: You must save the `paramUtxo` for future transactions.
+   *
+   * @returns {Promise<{ txHexMintOneTimeMintingPolicy: string, txHexSetupOracleUtxo: string, paramUtxo: UTxO["input"] }>}
+   *
+   * @example
+   * ```typescript
+   * const { tx, paramUtxo } = await contract.mintOneTimeMintingPolicy();
+   * const signedTx = await wallet.signTx(tx);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   mintOneTimeMintingPolicy = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     if (utxos?.length <= 0) {
@@ -997,14 +1020,27 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       this.stakeCredential,
       this.networkId
     );
+    this.paramUtxo = paramUtxo.input;
     return { tx: txHex, paramUtxo: paramUtxo.input };
   };
-  sendRefScriptOnchain = async (scriptIndex) => {
-    const { utxos, walletAddress } = await this.getWalletInfoForTx();
-    const { scriptAddress } = this.getOwnerNativeScript();
-    const txHex = await this.mesh.txOut(scriptAddress, []).txOutReferenceScript(getScriptCbor(this.paramUtxo, scriptIndex)).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
-    return txHex;
-  };
+  /**
+   * [Setup phase]
+   * This is the second transaction you need to setup the contract.
+   *
+   * This transaction send the NFT to a oracle contract locking the datum,
+   * which serves as the single source of truth for the contract oracle with data integrity.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.setupOracleUtxo();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   setupOracleUtxo = async () => {
     const { utxos, walletAddress } = await this.getWalletInfoForTx();
     const datumValue = this.getOracleDatum(0, 0);
@@ -1013,22 +1049,60 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ]).txOutInlineDatumValue(datumValue).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
     return txHex;
   };
-  // WIP. need to chain tx, and also need to manage the UTXOs not consumed
-  handleSetup = async () => {
-    const { tx: txHexMintOneTimeMintingPolicy, paramUtxo } = await this.mintOneTimeMintingPolicy();
-    this.paramUtxo = paramUtxo;
-    this.scriptInfo = getScriptInfo(
-      paramUtxo,
-      this.stakeCredential,
-      this.networkId
-    );
-    const txHexSetupOracleUtxo = await this.setupOracleUtxo();
-    return {
-      txHexMintOneTimeMintingPolicy,
-      txHexSetupOracleUtxo,
-      paramUtxo
-    };
+  /**
+   * [Setup phase]
+   * This are the next transactions you need to setup the contract.
+   * You need to run once for each script, and you would likely have to run one after the previous one is confirmed.
+   *
+   * This transaction sends the reference scripts to the blockchain for later transactions,
+   * boosting efficiency and avoid exceeding 16kb of transaction size limits enforced by protocol parameter.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must save txHash (after signed and submitted) for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken` transactions for future transactions.
+   *
+   * @param scriptIndex - "OracleNFT" | "OracleValidator" | "ContentRegistry" | "ContentRefToken" | "OwnershipRegistry" | "OwnershipRefToken"
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHexOracleNFT = await contract.sendRefScriptOnchain("OracleNFT");
+   * const signedTxOracleNFT = await wallet.signTx(txHexOracleNFT);
+   * const txHashOracleNFT = await wallet.submitTx(signedTxOracleNFT);
+   *
+   * const txHexOracleValidator = await contract.sendRefScriptOnchain("OracleValidator");
+   * ... // repeat for each script
+   *
+   * const txHexOwnershipRefToken = await contract.sendRefScriptOnchain("OwnershipRefToken");
+   * const signedTxOwnershipRefToken = await wallet.signTx(txHexOwnershipRefToken);
+   * const txHashOwnershipRefToken = await wallet.submitTx(signedTxOwnershipRefToken);
+   * ```
+   */
+  sendRefScriptOnchain = async (scriptIndex) => {
+    const { utxos, walletAddress } = await this.getWalletInfoForTx();
+    const { scriptAddress } = this.getOwnerNativeScript();
+    const txHex = await this.mesh.txOut(scriptAddress, []).txOutReferenceScript(getScriptCbor(this.paramUtxo, scriptIndex)).changeAddress(walletAddress).selectUtxosFrom(utxos, "experimental", "20000000").complete();
+    return txHex;
   };
+  /**
+   * [Setup phase]
+   * This is the next transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+   *
+   * This transaction creates one content registry. Each registry should comes in pair with one ownership registry and
+   * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+   * according to the number of parallelization needed and volumes of content expected to be managed.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.createContentRegistry();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   createContentRegistry = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
@@ -1069,6 +1143,26 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ).changeAddress(walletAddress).selectUtxosFrom(utxos, "largestFirstMultiAsset").complete();
     return txHex;
   };
+  /**
+   * [Setup phase]
+   * This is the last transaction you need to setup the contract after completing all the `sendRefScriptOnchain` transactions.
+   *
+   * This transaction creates one content registry. Each registry should comes in pair with one content registry and
+   * each pair of registry serves around 50 records of content ownership. The application can be scaled indefinitely
+   * according to the number of parallelization needed and volumes of content expected to be managed.
+   *
+   * Note: You must provide the `paramUtxo` from the `mintOneTimeMintingPolicy` transaction.
+   * Note: You must provide the txHash for `ContentRegistry`, `ContentRefToken`, `OwnershipRegistry`, `OwnershipRefToken`
+   *
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const txHex = await contract.createOwnershipRegistry();
+   * const signedTx = await wallet.signTx(txHex);
+   * const txHash = await wallet.submitTx(signedTx);
+   * ```
+   */
   createOwnershipRegistry = async () => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
@@ -1105,10 +1199,79 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
       collateral.input.outputIndex,
       collateral.output.amount,
       collateral.output.address
-    ).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
+    ).changeAddress(walletAddress).selectUtxosFrom(utxos, "largestFirstMultiAsset").complete();
     return txHex;
   };
-  // User
+  /**
+   * Get the current oracle data.
+   *
+   * @returns {Promise<{
+   *  contentNumber: number,
+   *  ownershipNumber: number,
+   * }>}
+   *
+   * @example
+   * ```typescript
+   * const oracleData = await contract.getOracleData();
+   * ```
+   */
+  getOracleData = async () => {
+    const scriptUtxo = await this.fetcher.fetchAddressUTxOs(
+      this.scriptInfo.oracleValidator.address,
+      this.scriptInfo.oracleNFT.hash
+    );
+    const currentOracleDatum = await this.getCurrentOracleDatum(scriptUtxo);
+    const contentNumber = currentOracleDatum.fields[4].int;
+    const ownershipNumber = currentOracleDatum.fields[7].int;
+    return {
+      contentNumber,
+      ownershipNumber
+    };
+  };
+  /**
+   * [User]
+   *
+   * This transaction mints a user token which can be used to represent the ownership of the content. This token is used in `createContent()` transaction.
+   *
+   * @param tokenName - The name of the token that you can specify.
+   * @param tokenMetadata - The metadata of the token that you can specify.
+   * @returns {Promise<string>}
+   *
+   * @example
+   * ```typescript
+   * const tx = await contract.mintUserToken("MeshContentOwnership", {
+   *   name: "Mesh Content Ownership",
+   *   description: "Demo at https://meshjs.dev/smart-contracts/content-ownership",
+   * });
+   * const signedTx = await wallet.signTx(tx, true);
+   * const txHash = await wallet.submitTx(signedTx);
+   */
+  mintUserToken = async (tokenName2, tokenMetadata = {}) => {
+    const { utxos, walletAddress } = await this.getWalletInfoForTx();
+    const { pubKeyHash: keyHash } = deserializeAddress(walletAddress);
+    const nativeScript = {
+      type: "all",
+      scripts: [
+        {
+          type: "sig",
+          keyHash
+        }
+      ]
+    };
+    const forgingScript = ForgeScript.fromNativeScript(nativeScript);
+    const policyId = resolveScriptHash2(forgingScript);
+    const tokenNameHex = stringToHex(tokenName2);
+    const metadata = { [policyId]: { [tokenName2]: { ...tokenMetadata } } };
+    const txHex = await this.mesh.mint("1", policyId, tokenNameHex).mintingScript(forgingScript).metadataValue("721", metadata).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
+    return txHex;
+  };
+  /**
+   *
+   * @param ownerAssetHex
+   * @param contentHashHex
+   * @param registryNumber
+   * @returns
+   */
   createContent = async (ownerAssetHex, contentHashHex, registryNumber = 0) => {
     const { utxos, collateral, walletAddress } = await this.getWalletInfoForTx();
     const registryName = stringToHex(`Registry (${registryNumber})`);
@@ -1178,6 +1341,24 @@ var MeshContentOwnershipContract = class extends MeshTxInitiator {
     ).selectUtxosFrom(utxos).complete();
     return txHex;
   };
+  /**
+   * Get the content at the registry given the registry number and content number.
+   * @param registryNumber
+   * @param contentNumber
+   * @returns
+   */
+  getContent = async (registryNumber, contentNumber) => {
+    const [content] = await this.getScriptUtxos(registryNumber, ["content"]);
+    if (content === void 0) throw new Error("Content registry not found");
+    const contentDatam = parseDatumCbor(
+      content.output.plutusData
+    );
+    const contentAtRegistry = contentDatam.fields[1].list;
+    if (contentAtRegistry.length <= contentNumber)
+      throw new Error("Content not found");
+    const decoded = toUTF8(contentAtRegistry[contentNumber]?.bytes);
+    return decoded;
+  };
   updateContent = async ({
     ownerTokenUtxo,
     registryNumber,
@@ -1487,7 +1668,7 @@ import {
   value
 } from "@meshsdk/common";
 import {
-  deserializeAddress as deserializeAddress3,
+  deserializeAddress as deserializeAddress2,
   deserializeDatum,
   mergeAssets,
   serializeAddressObj
@@ -2022,14 +2203,14 @@ var plutus_default3 = {
 
 // src/escrow/offchain.ts
 var initiateEscrowDatum = (walletAddress, amount) => {
-  const { pubKeyHash, stakeCredentialHash } = deserializeAddress3(walletAddress);
+  const { pubKeyHash, stakeCredentialHash } = deserializeAddress2(walletAddress);
   return conStr0([
     pubKeyAddress(pubKeyHash, stakeCredentialHash),
     value(amount)
   ]);
 };
 var activeEscrowDatum = (initiationDatum, walletAddress, amount) => {
-  const { pubKeyHash, stakeCredentialHash } = deserializeAddress3(walletAddress);
+  const { pubKeyHash, stakeCredentialHash } = deserializeAddress2(walletAddress);
   const [initiator, initiatorAmount] = initiationDatum.fields;
   return conStr1([
     initiator,
@@ -2094,7 +2275,7 @@ var MeshEscrowContract = class extends MeshTxInitiator {
       escrowUtxo.input.outputIndex,
       escrowUtxo.output.amount,
       this.scriptAddress
-    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr12([])).txInScript(this.scriptCbor).requiredSignerHash(deserializeAddress3(walletAddress).pubKeyHash).changeAddress(walletAddress).txInCollateral(
+    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr12([])).txInScript(this.scriptCbor).requiredSignerHash(deserializeAddress2(walletAddress).pubKeyHash).changeAddress(walletAddress).txInCollateral(
       collateral.input.txHash,
       collateral.input.outputIndex,
       collateral.output.amount,
@@ -2157,7 +2338,7 @@ var MeshEscrowContract = class extends MeshTxInitiator {
       escrowUtxo.input.outputIndex,
       escrowUtxo.output.amount,
       this.scriptAddress
-    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr2([])).txInScript(this.scriptCbor).txOut(initiatorAddress, initiatorToReceive).txOut(recipientAddress, recipientToReceive).requiredSignerHash(deserializeAddress3(recipientAddress).pubKeyHash).requiredSignerHash(deserializeAddress3(initiatorAddress).pubKeyHash).changeAddress(walletAddress).txInCollateral(
+    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr2([])).txInScript(this.scriptCbor).txOut(initiatorAddress, initiatorToReceive).txOut(recipientAddress, recipientToReceive).requiredSignerHash(deserializeAddress2(recipientAddress).pubKeyHash).requiredSignerHash(deserializeAddress2(initiatorAddress).pubKeyHash).changeAddress(walletAddress).txInCollateral(
       collateral.input.txHash,
       collateral.input.outputIndex,
       collateral.output.amount,
@@ -2172,7 +2353,7 @@ var MeshEscrowContract = class extends MeshTxInitiator {
 
 // src/giftcard/offchain.ts
 import {
-  builtinByteString as builtinByteString2,
+  builtinByteString as builtinByteString3,
   mConStr0 as mConStr02,
   mConStr1 as mConStr13,
   outputReference as outputReference2,
@@ -2514,7 +2695,7 @@ var MeshGiftCardContract = class extends MeshTxInitiator {
     }
     return applyParamsToScript4(
       scriptCbor,
-      [builtinByteString2(tokenNameHex), utxo],
+      [builtinByteString3(tokenNameHex), utxo],
       "JSON"
     );
   };
@@ -2609,7 +2790,7 @@ var MeshGiftCardContract = class extends MeshTxInitiator {
 
 // src/hello-world/offchain.ts
 import {
-  deserializeAddress as deserializeAddress4,
+  deserializeAddress as deserializeAddress3,
   mConStr0 as mConStr03,
   stringToHex as stringToHex3
 } from "@meshsdk/core";
@@ -2785,13 +2966,13 @@ var MeshHelloWorldContract = class extends MeshTxInitiator {
   };
   lockAsset = async (assets) => {
     const { utxos, walletAddress } = await this.getWalletInfoForTx();
-    const signerHash = deserializeAddress4(walletAddress).pubKeyHash;
+    const signerHash = deserializeAddress3(walletAddress).pubKeyHash;
     await this.mesh.txOut(this.scriptAddress, assets).txOutDatumHashValue(mConStr03([signerHash])).changeAddress(walletAddress).selectUtxosFrom(utxos).complete();
     return this.mesh.txHex;
   };
   unlockAsset = async (scriptUtxo, message) => {
     const { utxos, walletAddress, collateral } = await this.getWalletInfoForTx();
-    const signerHash = deserializeAddress4(walletAddress).pubKeyHash;
+    const signerHash = deserializeAddress3(walletAddress).pubKeyHash;
     await this.mesh.spendingPlutusScript(this.languageVersion).txIn(
       scriptUtxo.input.txHash,
       scriptUtxo.input.outputIndex,
@@ -2822,7 +3003,7 @@ import {
   tokenName
 } from "@meshsdk/common";
 import {
-  deserializeAddress as deserializeAddress5,
+  deserializeAddress as deserializeAddress4,
   deserializeDatum as deserializeDatum3,
   serializeAddressObj as serializeAddressObj2
 } from "@meshsdk/core";
@@ -3295,7 +3476,7 @@ var plutus_default9 = {
 
 // src/marketplace/offchain.ts
 var marketplaceDatum = (sellerAddress, lovelaceFee, assetHex) => {
-  const { pubKeyHash, stakeCredentialHash } = deserializeAddress5(sellerAddress);
+  const { pubKeyHash, stakeCredentialHash } = deserializeAddress4(sellerAddress);
   const { policyId, assetName } = parseAssetUnit(assetHex);
   return conStr02([
     pubKeyAddress2(pubKeyHash, stakeCredentialHash),
@@ -3313,7 +3494,7 @@ var MeshMarketplaceContract = class extends MeshTxInitiator {
     super(inputs);
     this.ownerAddress = ownerAddress;
     this.feePercentageBasisPoint = feePercentageBasisPoint;
-    const { pubKeyHash, stakeCredentialHash } = deserializeAddress5(ownerAddress);
+    const { pubKeyHash, stakeCredentialHash } = deserializeAddress4(ownerAddress);
     this.scriptCbor = this.getScriptCbor(
       pubKeyHash,
       stakeCredentialHash,
@@ -3359,7 +3540,7 @@ var MeshMarketplaceContract = class extends MeshTxInitiator {
       marketplaceUtxo.input.outputIndex,
       marketplaceUtxo.output.amount,
       marketplaceUtxo.output.address
-    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr14([])).txInScript(this.scriptCbor).changeAddress(walletAddress).requiredSignerHash(deserializeAddress5(walletAddress).pubKeyHash).txInCollateral(
+    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr14([])).txInScript(this.scriptCbor).changeAddress(walletAddress).requiredSignerHash(deserializeAddress4(walletAddress).pubKeyHash).txInCollateral(
       collateral.input.txHash,
       collateral.input.outputIndex,
       collateral.output.amount,
@@ -3428,7 +3609,7 @@ var MeshMarketplaceContract = class extends MeshTxInitiator {
       marketplaceUtxo.input.outputIndex,
       marketplaceUtxo.output.amount,
       marketplaceUtxo.output.address
-    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr14([])).txInScript(this.scriptCbor).txOut(this.scriptAddress, tokenForSale).txOutInlineDatumValue(outputDatum, "JSON").changeAddress(walletAddress).requiredSignerHash(deserializeAddress5(walletAddress).pubKeyHash).txInCollateral(
+    ).spendingReferenceTxInInlineDatumPresent().spendingReferenceTxInRedeemerValue(mConStr14([])).txInScript(this.scriptCbor).txOut(this.scriptAddress, tokenForSale).txOutInlineDatumValue(outputDatum, "JSON").changeAddress(walletAddress).requiredSignerHash(deserializeAddress4(walletAddress).pubKeyHash).txInCollateral(
       collateral.input.txHash,
       collateral.input.outputIndex,
       collateral.output.amount,
@@ -3450,10 +3631,10 @@ var MeshMarketplaceContract = class extends MeshTxInitiator {
 };
 
 // src/payment-splitter/offchain.ts
-import { builtinByteString as builtinByteString3, list } from "@meshsdk/common";
+import { builtinByteString as builtinByteString4, list } from "@meshsdk/common";
 import {
   BrowserWallet as BrowserWallet2,
-  deserializeAddress as deserializeAddress6,
+  deserializeAddress as deserializeAddress5,
   MeshWallet as MeshWallet2,
   Transaction
 } from "@meshsdk/core";
@@ -3653,7 +3834,7 @@ var MeshPaymentSplitterContract = class extends MeshTxInitiator {
   payees = [];
   wrapPayees = (payees) => list(
     payees.map(
-      (payee) => builtinByteString3(deserializeAddress6(payee).pubKeyHash)
+      (payee) => builtinByteString4(deserializeAddress5(payee).pubKeyHash)
     )
   );
   constructor(inputs, payees) {
@@ -3697,7 +3878,7 @@ var MeshPaymentSplitterContract = class extends MeshTxInitiator {
       throw new Error("Wallet not provided");
     }
     const { walletAddress } = await this.getWalletInfoForTx();
-    const { pubKeyHash } = deserializeAddress6(walletAddress);
+    const { pubKeyHash } = deserializeAddress5(walletAddress);
     const datum = {
       alternative: 0,
       fields: [pubKeyHash]
@@ -3722,7 +3903,7 @@ var MeshPaymentSplitterContract = class extends MeshTxInitiator {
       version: this.languageVersion
     };
     const utxos = await this.fetcher?.fetchAddressUTxOs(this.scriptAddress) || [];
-    const { pubKeyHash } = deserializeAddress6(walletAddress);
+    const { pubKeyHash } = deserializeAddress5(walletAddress);
     const datum = {
       alternative: 0,
       fields: [pubKeyHash]
@@ -3766,7 +3947,7 @@ import {
   stringToHex as stringToHex4
 } from "@meshsdk/common";
 import {
-  deserializeAddress as deserializeAddress7,
+  deserializeAddress as deserializeAddress6,
   resolveScriptHash as resolveScriptHash4,
   serializeAddressObj as serializeAddressObj3,
   serializePlutusScript as serializePlutusScript3
@@ -3774,7 +3955,7 @@ import {
 import {
   applyCborEncoding,
   applyParamsToScript as applyParamsToScript8,
-  parseDatumCbor
+  parseDatumCbor as parseDatumCbor2
 } from "@meshsdk/core-csl";
 
 // src/plutus-nft/aiken-workspace/plutus.json
@@ -4207,7 +4388,7 @@ var MeshPlutusNFTContract = class extends MeshTxInitiator {
     const paramScript = applyParamsToScript8(script, [param]);
     const policyId = resolveScriptHash4(paramScript, "V3");
     const tokenName2 = "";
-    const { pubKeyHash, stakeCredentialHash } = deserializeAddress7(walletAddress);
+    const { pubKeyHash, stakeCredentialHash } = deserializeAddress6(walletAddress);
     const txHex = await this.mesh.txIn(
       paramUtxo.input.txHash,
       paramUtxo.input.outputIndex,
@@ -4297,7 +4478,7 @@ var MeshPlutusNFTContract = class extends MeshTxInitiator {
   getOracleData = async () => {
     const oracleNftPolicyId = resolveScriptHash4(this.getOracleNFTCbor(), "V3");
     const oracleUtxo = (await this.getAddressUtxosWithToken(this.oracleAddress, oracleNftPolicyId))[0];
-    const oracleDatum = parseDatumCbor(
+    const oracleDatum = parseDatumCbor2(
       oracleUtxo.output.plutusData
     );
     const nftIndex = oracleDatum.fields[0].int;
@@ -4333,7 +4514,7 @@ import {
   value as value2
 } from "@meshsdk/common";
 import {
-  deserializeAddress as deserializeAddress8,
+  deserializeAddress as deserializeAddress7,
   deserializeDatum as deserializeDatum4,
   serializeAddressObj as serializeAddressObj4
 } from "@meshsdk/core";
@@ -4816,7 +4997,7 @@ var MeshSwapContract = class extends MeshTxInitiator {
   };
   initiateSwap = async (toProvide, toReceive) => {
     const { utxos, walletAddress, collateral } = await this.getWalletInfoForTx();
-    const { pubKeyHash, stakeCredentialHash } = deserializeAddress8(walletAddress);
+    const { pubKeyHash, stakeCredentialHash } = deserializeAddress7(walletAddress);
     const swapDatum = conStr04([
       pubKeyAddress3(pubKeyHash, stakeCredentialHash),
       value2(toProvide),
@@ -4875,7 +5056,7 @@ var MeshSwapContract = class extends MeshTxInitiator {
       collateral.input.outputIndex,
       collateral.output.amount,
       collateral.output.address
-    ).requiredSignerHash(deserializeAddress8(initiatorAddress).pubKeyHash).selectUtxosFrom(utxos).complete();
+    ).requiredSignerHash(deserializeAddress7(initiatorAddress).pubKeyHash).selectUtxosFrom(utxos).complete();
     return this.mesh.txHex;
   };
   getUtxoByTxHash = async (txHash) => {
@@ -4890,7 +5071,7 @@ import {
   unixTimeToEnclosingSlot
 } from "@meshsdk/common";
 import {
-  deserializeAddress as deserializeAddress9,
+  deserializeAddress as deserializeAddress8,
   deserializeDatum as deserializeDatum5
 } from "@meshsdk/core";
 import { applyParamsToScript as applyParamsToScript10 } from "@meshsdk/core-csl";
@@ -5065,8 +5246,8 @@ var MeshVestingContract = class extends MeshTxInitiator {
   };
   depositFund = async (amount, lockUntilTimeStampMs, beneficiary) => {
     const { utxos, walletAddress } = await this.getWalletInfoForTx();
-    const { pubKeyHash: ownerPubKeyHash } = deserializeAddress9(walletAddress);
-    const { pubKeyHash: beneficiaryPubKeyHash } = deserializeAddress9(beneficiary);
+    const { pubKeyHash: ownerPubKeyHash } = deserializeAddress8(walletAddress);
+    const { pubKeyHash: beneficiaryPubKeyHash } = deserializeAddress8(beneficiary);
     await this.mesh.txOut(this.scriptAddress, amount).txOutInlineDatumValue(
       mConStr07([
         lockUntilTimeStampMs,
@@ -5079,7 +5260,7 @@ var MeshVestingContract = class extends MeshTxInitiator {
   withdrawFund = async (vestingUtxo) => {
     const { utxos, walletAddress, collateral } = await this.getWalletInfoForTx();
     const { input: collateralInput, output: collateralOutput } = collateral;
-    const { pubKeyHash } = deserializeAddress9(walletAddress);
+    const { pubKeyHash } = deserializeAddress8(walletAddress);
     const datum = deserializeDatum5(
       vestingUtxo.output.plutusData
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshsdk/contract",
-  "version": "1.7.10",
+  "version": "1.7.11",
   "description": "",
   "main": "./dist/index.cjs",
   "browser": "./dist/index.js",
@@ -34,9 +34,9 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "@meshsdk/common": "1.7.10",
-    "@meshsdk/core": "1.7.10",
-    "@meshsdk/core-csl": "1.7.10"
+    "@meshsdk/common": "1.7.11",
+    "@meshsdk/core": "1.7.11",
+    "@meshsdk/core-csl": "1.7.11"
   },
   "prettier": "@meshsdk/configs/prettier",
   "publishConfig": {