@story-protocol/core-sdk 1.0.0-rc.15 → 1.0.0-rc.16

package/dist/story-protocol-core-sdk.esm.js

@@ -1,4 +1,4 @@
-import { isAddress, checksumAddress, decodeEventLog, zeroAddress, getAddress as getAddress$2, encodeFunctionData, toFunctionSelector, zeroHash, stringToHex, maxUint32, createPublicClient, createWalletClient } from 'viem';
+import { isAddress, checksumAddress, encodeFunctionData, decodeEventLog, zeroAddress, getAddress as getAddress$2, toFunctionSelector, zeroHash, stringToHex, maxUint32, createPublicClient, createWalletClient } from 'viem';
 import * as dotenv from 'dotenv';
 import { sepolia } from 'viem/chains';
 
@@ -9950,13 +9950,32 @@ var AccessControllerClient = /*#__PURE__*/function (_AccessControllerEven) {
       }
       return setAllPermissions;
     }()
+    /**
+     * method setAllPermissions for contract AccessController with only encode
+     *
+     * @param request AccessControllerSetAllPermissionsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setAllPermissionsEncode",
+    value: function setAllPermissionsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: accessControllerAbi,
+          functionName: "setAllPermissions",
+          args: [request.ipAccount, request.signer, request.permission]
+        })
+      };
+    }
+
     /**
      * method setBatchPermissions for contract AccessController
      *
      * @param request AccessControllerSetBatchPermissionsRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setBatchPermissions",
     value: (function () {
@@ -9991,13 +10010,32 @@ var AccessControllerClient = /*#__PURE__*/function (_AccessControllerEven) {
       }
       return setBatchPermissions;
     }()
+    /**
+     * method setBatchPermissions for contract AccessController with only encode
+     *
+     * @param request AccessControllerSetBatchPermissionsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setBatchPermissionsEncode",
+    value: function setBatchPermissionsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: accessControllerAbi,
+          functionName: "setBatchPermissions",
+          args: [request.permissions]
+        })
+      };
+    }
+
     /**
      * method setPermission for contract AccessController
      *
      * @param request AccessControllerSetPermissionRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setPermission",
     value: (function () {
@@ -10031,7 +10069,26 @@ var AccessControllerClient = /*#__PURE__*/function (_AccessControllerEven) {
         return _setPermission.apply(this, arguments);
       }
       return setPermission;
-    }())
+    }()
+    /**
+     * method setPermission for contract AccessController with only encode
+     *
+     * @param request AccessControllerSetPermissionRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setPermissionEncode",
+    value: function setPermissionEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: accessControllerAbi,
+          functionName: "setPermission",
+          args: [request.ipAccount, request.signer, request.to, request.func, request.permission]
+        })
+      };
+    }
   }]);
 }(AccessControllerEventClient);
 
@@ -10502,13 +10559,32 @@ var CoreMetadataModuleClient = /*#__PURE__*/function (_CoreMetadataModuleRe) {
       }
       return freezeMetadata;
     }()
+    /**
+     * method freezeMetadata for contract CoreMetadataModule with only encode
+     *
+     * @param request CoreMetadataModuleFreezeMetadataRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "freezeMetadataEncode",
+    value: function freezeMetadataEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: coreMetadataModuleAbi,
+          functionName: "freezeMetadata",
+          args: [request.ipId]
+        })
+      };
+    }
+
     /**
      * method setAll for contract CoreMetadataModule
      *
      * @param request CoreMetadataModuleSetAllRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setAll",
     value: (function () {
@@ -10543,13 +10619,32 @@ var CoreMetadataModuleClient = /*#__PURE__*/function (_CoreMetadataModuleRe) {
       }
       return setAll;
     }()
+    /**
+     * method setAll for contract CoreMetadataModule with only encode
+     *
+     * @param request CoreMetadataModuleSetAllRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setAllEncode",
+    value: function setAllEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: coreMetadataModuleAbi,
+          functionName: "setAll",
+          args: [request.ipId, request.metadataURI, request.metadataHash, request.nftMetadataHash]
+        })
+      };
+    }
+
     /**
      * method setMetadataURI for contract CoreMetadataModule
      *
      * @param request CoreMetadataModuleSetMetadataUriRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setMetadataUri",
     value: (function () {
@@ -10584,13 +10679,32 @@ var CoreMetadataModuleClient = /*#__PURE__*/function (_CoreMetadataModuleRe) {
       }
       return setMetadataUri;
     }()
+    /**
+     * method setMetadataURI for contract CoreMetadataModule with only encode
+     *
+     * @param request CoreMetadataModuleSetMetadataUriRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setMetadataUriEncode",
+    value: function setMetadataUriEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: coreMetadataModuleAbi,
+          functionName: "setMetadataURI",
+          args: [request.ipId, request.metadataURI, request.metadataHash]
+        })
+      };
+    }
+
     /**
      * method updateNftTokenURI for contract CoreMetadataModule
      *
      * @param request CoreMetadataModuleUpdateNftTokenUriRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "updateNftTokenUri",
     value: (function () {
@@ -10624,7 +10738,26 @@ var CoreMetadataModuleClient = /*#__PURE__*/function (_CoreMetadataModuleRe) {
         return _updateNftTokenUri.apply(this, arguments);
       }
       return updateNftTokenUri;
-    }())
+    }()
+    /**
+     * method updateNftTokenURI for contract CoreMetadataModule with only encode
+     *
+     * @param request CoreMetadataModuleUpdateNftTokenUriRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "updateNftTokenUriEncode",
+    value: function updateNftTokenUriEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: coreMetadataModuleAbi,
+          functionName: "updateNftTokenURI",
+          args: [request.ipId, request.nftMetadataHash]
+        })
+      };
+    }
   }]);
 }(CoreMetadataModuleReadOnlyClient);
 
@@ -10900,13 +11033,32 @@ var DisputeModuleClient = /*#__PURE__*/function (_DisputeModuleEventCl) {
       }
       return cancelDispute;
     }()
+    /**
+     * method cancelDispute for contract DisputeModule with only encode
+     *
+     * @param request DisputeModuleCancelDisputeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "cancelDisputeEncode",
+    value: function cancelDisputeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: disputeModuleAbi,
+          functionName: "cancelDispute",
+          args: [request.disputeId, request.data]
+        })
+      };
+    }
+
     /**
      * method raiseDispute for contract DisputeModule
      *
      * @param request DisputeModuleRaiseDisputeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "raiseDispute",
     value: (function () {
@@ -10941,13 +11093,32 @@ var DisputeModuleClient = /*#__PURE__*/function (_DisputeModuleEventCl) {
       }
       return raiseDispute;
     }()
+    /**
+     * method raiseDispute for contract DisputeModule with only encode
+     *
+     * @param request DisputeModuleRaiseDisputeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "raiseDisputeEncode",
+    value: function raiseDisputeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: disputeModuleAbi,
+          functionName: "raiseDispute",
+          args: [request.targetIpId, request.linkToDisputeEvidence, request.targetTag, request.data]
+        })
+      };
+    }
+
     /**
      * method resolveDispute for contract DisputeModule
      *
      * @param request DisputeModuleResolveDisputeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "resolveDispute",
     value: (function () {
@@ -10981,7 +11152,26 @@ var DisputeModuleClient = /*#__PURE__*/function (_DisputeModuleEventCl) {
         return _resolveDispute.apply(this, arguments);
       }
       return resolveDispute;
-    }())
+    }()
+    /**
+     * method resolveDispute for contract DisputeModule with only encode
+     *
+     * @param request DisputeModuleResolveDisputeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "resolveDisputeEncode",
+    value: function resolveDisputeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: disputeModuleAbi,
+          functionName: "resolveDispute",
+          args: [request.disputeId, request.data]
+        })
+      };
+    }
   }]);
 }(DisputeModuleEventClient);
 
@@ -11105,13 +11295,32 @@ var IpAccountImplClient = /*#__PURE__*/function (_IpAccountImplReadOnl) {
       }
       return execute;
     }()
+    /**
+     * method execute for contract IPAccountImpl with only encode
+     *
+     * @param request IpAccountImplExecuteRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "executeEncode",
+    value: function executeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipAccountImplAbi,
+          functionName: "execute",
+          args: [request.to, request.value, request.data]
+        })
+      };
+    }
+
     /**
      * method executeWithSig for contract IPAccountImpl
      *
      * @param request IpAccountImplExecuteWithSigRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "executeWithSig",
     value: (function () {
@@ -11145,7 +11354,26 @@ var IpAccountImplClient = /*#__PURE__*/function (_IpAccountImplReadOnl) {
         return _executeWithSig.apply(this, arguments);
       }
       return executeWithSig;
-    }())
+    }()
+    /**
+     * method executeWithSig for contract IPAccountImpl with only encode
+     *
+     * @param request IpAccountImplExecuteWithSigRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "executeWithSigEncode",
+    value: function executeWithSigEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipAccountImplAbi,
+          functionName: "executeWithSig",
+          args: [request.to, request.value, request.data, request.signer, request.deadline, request.signature]
+        })
+      };
+    }
   }]);
 }(IpAccountImplReadOnlyClient);
 
@@ -11444,7 +11672,26 @@ var IpAssetRegistryClient = /*#__PURE__*/function (_IpAssetRegistryReadO) {
         return _register.apply(this, arguments);
       }
       return register;
-    }())
+    }()
+    /**
+     * method register for contract IPAssetRegistry with only encode
+     *
+     * @param request IpAssetRegistryRegisterRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerEncode",
+    value: function registerEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipAssetRegistryAbi,
+          functionName: "register",
+          args: [request.chainid, request.tokenContract, request.tokenId]
+        })
+      };
+    }
   }]);
 }(IpAssetRegistryReadOnlyClient);
 
@@ -11802,13 +12049,32 @@ var IpRoyaltyVaultImplClient = /*#__PURE__*/function (_IpRoyaltyVaultImplRe) {
       }
       return claimRevenueBySnapshotBatch;
     }()
+    /**
+     * method claimRevenueBySnapshotBatch for contract IpRoyaltyVaultImpl with only encode
+     *
+     * @param request IpRoyaltyVaultImplClaimRevenueBySnapshotBatchRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "claimRevenueBySnapshotBatchEncode",
+    value: function claimRevenueBySnapshotBatchEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipRoyaltyVaultImplAbi,
+          functionName: "claimRevenueBySnapshotBatch",
+          args: [request.snapshotIds, request.token]
+        })
+      };
+    }
+
     /**
      * method claimRevenueByTokenBatch for contract IpRoyaltyVaultImpl
      *
      * @param request IpRoyaltyVaultImplClaimRevenueByTokenBatchRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "claimRevenueByTokenBatch",
     value: (function () {
@@ -11843,13 +12109,32 @@ var IpRoyaltyVaultImplClient = /*#__PURE__*/function (_IpRoyaltyVaultImplRe) {
       }
       return claimRevenueByTokenBatch;
     }()
+    /**
+     * method claimRevenueByTokenBatch for contract IpRoyaltyVaultImpl with only encode
+     *
+     * @param request IpRoyaltyVaultImplClaimRevenueByTokenBatchRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "claimRevenueByTokenBatchEncode",
+    value: function claimRevenueByTokenBatchEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipRoyaltyVaultImplAbi,
+          functionName: "claimRevenueByTokenBatch",
+          args: [request.snapshotId, request.tokenList]
+        })
+      };
+    }
+
     /**
      * method collectRoyaltyTokens for contract IpRoyaltyVaultImpl
      *
      * @param request IpRoyaltyVaultImplCollectRoyaltyTokensRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "collectRoyaltyTokens",
     value: (function () {
@@ -11884,13 +12169,32 @@ var IpRoyaltyVaultImplClient = /*#__PURE__*/function (_IpRoyaltyVaultImplRe) {
       }
       return collectRoyaltyTokens;
     }()
+    /**
+     * method collectRoyaltyTokens for contract IpRoyaltyVaultImpl with only encode
+     *
+     * @param request IpRoyaltyVaultImplCollectRoyaltyTokensRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "collectRoyaltyTokensEncode",
+    value: function collectRoyaltyTokensEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipRoyaltyVaultImplAbi,
+          functionName: "collectRoyaltyTokens",
+          args: [request.ancestorIpId]
+        })
+      };
+    }
+
     /**
      * method snapshot for contract IpRoyaltyVaultImpl
      *
      * @param request IpRoyaltyVaultImplSnapshotRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "snapshot",
     value: (function () {
@@ -11923,7 +12227,25 @@ var IpRoyaltyVaultImplClient = /*#__PURE__*/function (_IpRoyaltyVaultImplRe) {
         return _snapshot.apply(this, arguments);
       }
       return snapshot;
-    }())
+    }()
+    /**
+     * method snapshot for contract IpRoyaltyVaultImpl with only encode
+     *
+     * @param request IpRoyaltyVaultImplSnapshotRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "snapshotEncode",
+    value: function snapshotEncode() {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: ipRoyaltyVaultImplAbi,
+          functionName: "snapshot"
+        })
+      };
+    }
   }]);
 }(IpRoyaltyVaultImplReadOnlyClient);
 
@@ -13681,13 +14003,32 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
       }
       return attachLicenseTerms;
     }()
+    /**
+     * method attachLicenseTerms for contract LicensingModule with only encode
+     *
+     * @param request LicensingModuleAttachLicenseTermsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "attachLicenseTermsEncode",
+    value: function attachLicenseTermsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: licensingModuleAbi,
+          functionName: "attachLicenseTerms",
+          args: [request.ipId, request.licenseTemplate, request.licenseTermsId]
+        })
+      };
+    }
+
     /**
      * method mintLicenseTokens for contract LicensingModule
      *
      * @param request LicensingModuleMintLicenseTokensRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "mintLicenseTokens",
     value: (function () {
@@ -13722,13 +14063,32 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
       }
       return mintLicenseTokens;
     }()
+    /**
+     * method mintLicenseTokens for contract LicensingModule with only encode
+     *
+     * @param request LicensingModuleMintLicenseTokensRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "mintLicenseTokensEncode",
+    value: function mintLicenseTokensEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: licensingModuleAbi,
+          functionName: "mintLicenseTokens",
+          args: [request.licensorIpId, request.licenseTemplate, request.licenseTermsId, request.amount, request.receiver, request.royaltyContext]
+        })
+      };
+    }
+
     /**
      * method registerDerivative for contract LicensingModule
      *
      * @param request LicensingModuleRegisterDerivativeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerDerivative",
     value: (function () {
@@ -13763,13 +14123,32 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
       }
       return registerDerivative;
     }()
+    /**
+     * method registerDerivative for contract LicensingModule with only encode
+     *
+     * @param request LicensingModuleRegisterDerivativeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerDerivativeEncode",
+    value: function registerDerivativeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: licensingModuleAbi,
+          functionName: "registerDerivative",
+          args: [request.childIpId, request.parentIpIds, request.licenseTermsIds, request.licenseTemplate, request.royaltyContext]
+        })
+      };
+    }
+
     /**
      * method registerDerivativeWithLicenseTokens for contract LicensingModule
      *
      * @param request LicensingModuleRegisterDerivativeWithLicenseTokensRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerDerivativeWithLicenseTokens",
     value: (function () {
@@ -13803,7 +14182,26 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
         return _registerDerivativeWithLicenseTokens.apply(this, arguments);
       }
       return registerDerivativeWithLicenseTokens;
-    }())
+    }()
+    /**
+     * method registerDerivativeWithLicenseTokens for contract LicensingModule with only encode
+     *
+     * @param request LicensingModuleRegisterDerivativeWithLicenseTokensRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerDerivativeWithLicenseTokensEncode",
+    value: function registerDerivativeWithLicenseTokensEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: licensingModuleAbi,
+          functionName: "registerDerivativeWithLicenseTokens",
+          args: [request.childIpId, request.licenseTokenIds, request.royaltyContext]
+        })
+      };
+    }
   }]);
 }(LicensingModuleEventClient);
 
@@ -15128,13 +15526,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return initialize;
     }()
+    /**
+     * method initialize for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateInitializeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "initializeEncode",
+    value: function initializeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "initialize",
+          args: [request.accessManager, request.name, request.metadataURI]
+        })
+      };
+    }
+
     /**
      * method registerLicenseTerms for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateRegisterLicenseTermsRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerLicenseTerms",
     value: (function () {
@@ -15169,13 +15586,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return registerLicenseTerms;
     }()
+    /**
+     * method registerLicenseTerms for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateRegisterLicenseTermsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerLicenseTermsEncode",
+    value: function registerLicenseTermsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "registerLicenseTerms",
+          args: [request.terms]
+        })
+      };
+    }
+
     /**
      * method setApproval for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateSetApprovalRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setApproval",
     value: (function () {
@@ -15210,13 +15646,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return setApproval;
     }()
+    /**
+     * method setApproval for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateSetApprovalRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setApprovalEncode",
+    value: function setApprovalEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "setApproval",
+          args: [request.parentIpId, request.licenseTermsId, request.childIpId, request.approved]
+        })
+      };
+    }
+
     /**
      * method setAuthority for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateSetAuthorityRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "setAuthority",
     value: (function () {
@@ -15251,13 +15706,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return setAuthority;
     }()
+    /**
+     * method setAuthority for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateSetAuthorityRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "setAuthorityEncode",
+    value: function setAuthorityEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "setAuthority",
+          args: [request.newAuthority]
+        })
+      };
+    }
+
     /**
      * method upgradeToAndCall for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateUpgradeToAndCallRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "upgradeToAndCall",
     value: (function () {
@@ -15292,13 +15766,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return upgradeToAndCall;
     }()
+    /**
+     * method upgradeToAndCall for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateUpgradeToAndCallRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "upgradeToAndCallEncode",
+    value: function upgradeToAndCallEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "upgradeToAndCall",
+          args: [request.newImplementation, request.data]
+        })
+      };
+    }
+
     /**
      * method verifyMintLicenseToken for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateVerifyMintLicenseTokenRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "verifyMintLicenseToken",
     value: (function () {
@@ -15333,13 +15826,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return verifyMintLicenseToken;
     }()
+    /**
+     * method verifyMintLicenseToken for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateVerifyMintLicenseTokenRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "verifyMintLicenseTokenEncode",
+    value: function verifyMintLicenseTokenEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "verifyMintLicenseToken",
+          args: [request[0], request[1], request[2], request[3]]
+        })
+      };
+    }
+
     /**
      * method verifyRegisterDerivative for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateVerifyRegisterDerivativeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "verifyRegisterDerivative",
     value: (function () {
@@ -15374,13 +15886,32 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
       }
       return verifyRegisterDerivative;
     }()
+    /**
+     * method verifyRegisterDerivative for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateVerifyRegisterDerivativeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "verifyRegisterDerivativeEncode",
+    value: function verifyRegisterDerivativeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "verifyRegisterDerivative",
+          args: [request.childIpId, request.parentIpId, request.licenseTermsId, request.licensee]
+        })
+      };
+    }
+
     /**
      * method verifyRegisterDerivativeForAllParents for contract PILicenseTemplate
      *
      * @param request PiLicenseTemplateVerifyRegisterDerivativeForAllParentsRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "verifyRegisterDerivativeForAllParents",
     value: (function () {
@@ -15414,7 +15945,26 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
         return _verifyRegisterDerivativeForAllParents.apply(this, arguments);
       }
       return verifyRegisterDerivativeForAllParents;
-    }())
+    }()
+    /**
+     * method verifyRegisterDerivativeForAllParents for contract PILicenseTemplate with only encode
+     *
+     * @param request PiLicenseTemplateVerifyRegisterDerivativeForAllParentsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "verifyRegisterDerivativeForAllParentsEncode",
+    value: function verifyRegisterDerivativeForAllParentsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: piLicenseTemplateAbi,
+          functionName: "verifyRegisterDerivativeForAllParents",
+          args: [request.childIpId, request.parentIpIds, request.licenseTermsIds, request.childIpOwner]
+        })
+      };
+    }
   }]);
 }(PiLicenseTemplateReadOnlyClient);
 
@@ -15480,7 +16030,26 @@ var RoyaltyModuleClient = /*#__PURE__*/function () {
         return _payRoyaltyOnBehalf.apply(this, arguments);
       }
       return payRoyaltyOnBehalf;
-    }())
+    }()
+    /**
+     * method payRoyaltyOnBehalf for contract RoyaltyModule with only encode
+     *
+     * @param request RoyaltyModulePayRoyaltyOnBehalfRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "payRoyaltyOnBehalfEncode",
+    value: function payRoyaltyOnBehalfEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: royaltyModuleAbi,
+          functionName: "payRoyaltyOnBehalf",
+          args: [request.receiverIpId, request.payerIpId, request.token, request.amount]
+        })
+      };
+    }
   }]);
 }();
 
@@ -15610,7 +16179,26 @@ var RoyaltyPolicyLapClient = /*#__PURE__*/function (_RoyaltyPolicyLapRead) {
         return _onRoyaltyPayment.apply(this, arguments);
       }
       return onRoyaltyPayment;
-    }())
+    }()
+    /**
+     * method onRoyaltyPayment for contract RoyaltyPolicyLAP with only encode
+     *
+     * @param request RoyaltyPolicyLapOnRoyaltyPaymentRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "onRoyaltyPaymentEncode",
+    value: function onRoyaltyPaymentEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: royaltyPolicyLapAbi,
+          functionName: "onRoyaltyPayment",
+          args: [request.caller, request.ipId, request.token, request.amount]
+        })
+      };
+    }
   }]);
 }(RoyaltyPolicyLapReadOnlyClient);
 
@@ -15837,13 +16425,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return createCollection;
     }()
+    /**
+     * method createCollection for contract SPG with only encode
+     *
+     * @param request SpgCreateCollectionRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "createCollectionEncode",
+    value: function createCollectionEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "createCollection",
+          args: [request.name, request.symbol, request.maxSupply, request.mintFee, request.mintFeeToken, request.owner]
+        })
+      };
+    }
+
     /**
      * method mintAndRegisterIp for contract SPG
      *
      * @param request SpgMintAndRegisterIpRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "mintAndRegisterIp",
     value: (function () {
@@ -15878,13 +16485,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return mintAndRegisterIp;
     }()
+    /**
+     * method mintAndRegisterIp for contract SPG with only encode
+     *
+     * @param request SpgMintAndRegisterIpRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "mintAndRegisterIpEncode",
+    value: function mintAndRegisterIpEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "mintAndRegisterIp",
+          args: [request.nftContract, request.recipient, request.metadata]
+        })
+      };
+    }
+
     /**
      * method mintAndRegisterIpAndAttachPILTerms for contract SPG
      *
      * @param request SpgMintAndRegisterIpAndAttachPilTermsRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "mintAndRegisterIpAndAttachPilTerms",
     value: (function () {
@@ -15919,13 +16545,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return mintAndRegisterIpAndAttachPilTerms;
     }()
+    /**
+     * method mintAndRegisterIpAndAttachPILTerms for contract SPG with only encode
+     *
+     * @param request SpgMintAndRegisterIpAndAttachPilTermsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "mintAndRegisterIpAndAttachPilTermsEncode",
+    value: function mintAndRegisterIpAndAttachPilTermsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "mintAndRegisterIpAndAttachPILTerms",
+          args: [request.nftContract, request.recipient, request.metadata, request.terms]
+        })
+      };
+    }
+
     /**
      * method mintAndRegisterIpAndMakeDerivative for contract SPG
      *
      * @param request SpgMintAndRegisterIpAndMakeDerivativeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "mintAndRegisterIpAndMakeDerivative",
     value: (function () {
@@ -15960,13 +16605,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return mintAndRegisterIpAndMakeDerivative;
     }()
+    /**
+     * method mintAndRegisterIpAndMakeDerivative for contract SPG with only encode
+     *
+     * @param request SpgMintAndRegisterIpAndMakeDerivativeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "mintAndRegisterIpAndMakeDerivativeEncode",
+    value: function mintAndRegisterIpAndMakeDerivativeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "mintAndRegisterIpAndMakeDerivative",
+          args: [request.nftContract, request.derivData, request.metadata, request.recipient]
+        })
+      };
+    }
+
     /**
      * method mintAndRegisterIpAndMakeDerivativeWithLicenseTokens for contract SPG
      *
      * @param request SpgMintAndRegisterIpAndMakeDerivativeWithLicenseTokensRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "mintAndRegisterIpAndMakeDerivativeWithLicenseTokens",
     value: (function () {
@@ -16001,13 +16665,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return mintAndRegisterIpAndMakeDerivativeWithLicenseTokens;
     }()
+    /**
+     * method mintAndRegisterIpAndMakeDerivativeWithLicenseTokens for contract SPG with only encode
+     *
+     * @param request SpgMintAndRegisterIpAndMakeDerivativeWithLicenseTokensRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "mintAndRegisterIpAndMakeDerivativeWithLicenseTokensEncode",
+    value: function mintAndRegisterIpAndMakeDerivativeWithLicenseTokensEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "mintAndRegisterIpAndMakeDerivativeWithLicenseTokens",
+          args: [request.nftContract, request.licenseTokenIds, request.royaltyContext, request.metadata, request.recipient]
+        })
+      };
+    }
+
     /**
      * method registerIp for contract SPG
      *
      * @param request SpgRegisterIpRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerIp",
     value: (function () {
@@ -16042,13 +16725,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return registerIp;
     }()
+    /**
+     * method registerIp for contract SPG with only encode
+     *
+     * @param request SpgRegisterIpRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerIpEncode",
+    value: function registerIpEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "registerIp",
+          args: [request.nftContract, request.tokenId, request.metadata, request.sigMetadata]
+        })
+      };
+    }
+
     /**
      * method registerIpAndAttachPILTerms for contract SPG
      *
      * @param request SpgRegisterIpAndAttachPilTermsRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerIpAndAttachPilTerms",
     value: (function () {
@@ -16083,13 +16785,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return registerIpAndAttachPilTerms;
     }()
+    /**
+     * method registerIpAndAttachPILTerms for contract SPG with only encode
+     *
+     * @param request SpgRegisterIpAndAttachPilTermsRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerIpAndAttachPilTermsEncode",
+    value: function registerIpAndAttachPilTermsEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "registerIpAndAttachPILTerms",
+          args: [request.nftContract, request.tokenId, request.metadata, request.terms, request.sigMetadata, request.sigAttach]
+        })
+      };
+    }
+
     /**
      * method registerIpAndMakeDerivative for contract SPG
      *
      * @param request SpgRegisterIpAndMakeDerivativeRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerIpAndMakeDerivative",
     value: (function () {
@@ -16124,13 +16845,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return registerIpAndMakeDerivative;
     }()
+    /**
+     * method registerIpAndMakeDerivative for contract SPG with only encode
+     *
+     * @param request SpgRegisterIpAndMakeDerivativeRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerIpAndMakeDerivativeEncode",
+    value: function registerIpAndMakeDerivativeEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "registerIpAndMakeDerivative",
+          args: [request.nftContract, request.tokenId, request.derivData, request.metadata, request.sigMetadata, request.sigRegister]
+        })
+      };
+    }
+
     /**
      * method registerIpAndMakeDerivativeWithLicenseTokens for contract SPG
      *
      * @param request SpgRegisterIpAndMakeDerivativeWithLicenseTokensRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerIpAndMakeDerivativeWithLicenseTokens",
     value: (function () {
@@ -16165,13 +16905,32 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
       }
       return registerIpAndMakeDerivativeWithLicenseTokens;
     }()
+    /**
+     * method registerIpAndMakeDerivativeWithLicenseTokens for contract SPG with only encode
+     *
+     * @param request SpgRegisterIpAndMakeDerivativeWithLicenseTokensRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerIpAndMakeDerivativeWithLicenseTokensEncode",
+    value: function registerIpAndMakeDerivativeWithLicenseTokensEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "registerIpAndMakeDerivativeWithLicenseTokens",
+          args: [request.nftContract, request.tokenId, request.licenseTokenIds, request.royaltyContext, request.metadata, request.sigMetadata, request.sigRegister]
+        })
+      };
+    }
+
     /**
      * method registerPILTermsAndAttach for contract SPG
      *
      * @param request SpgRegisterPilTermsAndAttachRequest
      * @return Promise<WriteContractReturnType>
      */
-    )
   }, {
     key: "registerPilTermsAndAttach",
     value: (function () {
@@ -16205,7 +16964,26 @@ var SpgClient = /*#__PURE__*/function (_SpgEventClient) {
         return _registerPilTermsAndAttach.apply(this, arguments);
       }
       return registerPilTermsAndAttach;
-    }())
+    }()
+    /**
+     * method registerPILTermsAndAttach for contract SPG with only encode
+     *
+     * @param request SpgRegisterPilTermsAndAttachRequest
+     * @return EncodedTxData
+     */
+    )
+  }, {
+    key: "registerPilTermsAndAttachEncode",
+    value: function registerPilTermsAndAttachEncode(request) {
+      return {
+        to: this.address,
+        data: encodeFunctionData({
+          abi: spgAbi,
+          functionName: "registerPILTermsAndAttach",
+          args: [request.ipId, request.terms]
+        })
+      };
+    }
   }]);
 }(SpgEventClient);
 
@@ -16418,7 +17196,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "register",
     value: (function () {
       var _register = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, tokenId, ipIdAddress, isRegistered, object, calculatedDeadline, signature, txHash, txReceipt, targetLogs;
+        var _request$txOptions, tokenId, ipIdAddress, isRegistered, object, calculatedDeadline, signature, _request$txOptions2, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -16484,57 +17262,80 @@ var IPAssetClient = /*#__PURE__*/function () {
                 deadline: calculatedDeadline,
                 signature: signature
               };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 25;
+                break;
+              }
+              if (!request.metadata) {
+                _context.next = 22;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: this.spgClient.registerIpEncode(object)
+              });
+            case 22:
+              return _context.abrupt("return", {
+                encodedTxData: this.ipAssetRegistryClient.registerEncode({
+                  tokenContract: object.nftContract,
+                  tokenId: object.tokenId,
+                  chainid: chain[this.chainId]
+                })
+              });
+            case 23:
+              _context.next = 43;
+              break;
+            case 25:
               if (!request.metadata) {
-                _context.next = 23;
+                _context.next = 31;
                 break;
               }
-              _context.next = 20;
+              _context.next = 28;
               return this.spgClient.registerIp(object);
-            case 20:
+            case 28:
               txHash = _context.sent;
-              _context.next = 26;
+              _context.next = 34;
               break;
-            case 23:
-              _context.next = 25;
+            case 31:
+              _context.next = 33;
               return this.ipAssetRegistryClient.register({
                 tokenContract: object.nftContract,
                 tokenId: object.tokenId,
                 chainid: chain[this.chainId]
               });
-            case 25:
+            case 33:
               txHash = _context.sent;
-            case 26:
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 34;
+            case 34:
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 42;
                 break;
               }
-              _context.next = 29;
+              _context.next = 37;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 29:
+            case 37:
               txReceipt = _context.sent;
               targetLogs = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 ipId: targetLogs[0].ipId
               });
-            case 34:
+            case 42:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 35:
-              _context.next = 40;
+            case 43:
+              _context.next = 48;
               break;
-            case 37:
-              _context.prev = 37;
+            case 45:
+              _context.prev = 45;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to register IP");
-            case 40:
+            case 48:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 37]]);
+        }, _callee, this, [[0, 45]]);
       }));
       function register(_x) {
         return _register.apply(this, arguments);
@@ -16559,7 +17360,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivative",
     value: (function () {
       var _registerDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, isChildIpIdRegistered, _iterator, _step, parentId, isParentIpIdRegistered, i, isAttachedLicenseTerms, txHash;
+        var _request$txOptions3, isChildIpIdRegistered, _iterator, _step, parentId, isParentIpIdRegistered, i, isAttachedLicenseTerms, req, _request$txOptions4, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -16637,8 +17438,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               _context2.next = 29;
               break;
             case 38:
-              _context2.next = 40;
-              return this.licensingModuleClient.registerDerivative({
+              req = {
                 childIpId: request.childIpId,
                 parentIpIds: request.parentIpIds,
                 licenseTermsIds: request.licenseTermsIds.map(function (id) {
@@ -16646,37 +17446,47 @@ var IPAssetClient = /*#__PURE__*/function () {
                 }),
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 royaltyContext: zeroAddress
+              };
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 43;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: this.licensingModuleClient.registerDerivativeEncode(req)
               });
-            case 40:
+            case 43:
+              _context2.next = 45;
+              return this.licensingModuleClient.registerDerivative(req);
+            case 45:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 47;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context2.next = 52;
                 break;
               }
-              _context2.next = 44;
+              _context2.next = 49;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 44:
+            case 49:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 47:
+            case 52:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 48:
-              _context2.next = 53;
+            case 53:
+              _context2.next = 58;
               break;
-            case 50:
-              _context2.prev = 50;
+            case 55:
+              _context2.prev = 55;
               _context2.t1 = _context2["catch"](0);
               handleError(_context2.t1, "Failed to register derivative");
-            case 53:
+            case 58:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 50], [7, 20, 23, 26]]);
+        }, _callee2, this, [[0, 55], [7, 20, 23, 26]]);
       }));
       function registerDerivative(_x2) {
         return _registerDerivative.apply(this, arguments);
@@ -16699,7 +17509,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivativeWithLicenseTokens",
     value: (function () {
       var _registerDerivativeWithLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions3, isChildIpIdRegistered, _iterator2, _step2, licenseTokenId, tokenOwnerAddress, txHash;
+        var _request$txOptions5, isChildIpIdRegistered, _iterator2, _step2, licenseTokenId, tokenOwnerAddress, req, _request$txOptions6, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
@@ -16752,42 +17562,51 @@ var IPAssetClient = /*#__PURE__*/function () {
               _iterator2.f();
               return _context3.finish(24);
             case 27:
-              _context3.next = 29;
-              return this.licensingModuleClient.registerDerivativeWithLicenseTokens({
+              req = {
                 childIpId: getAddress$1(request.childIpId, "request.childIpId"),
                 licenseTokenIds: request.licenseTokenIds,
                 royaltyContext: zeroAddress
+              };
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.encodedTxDataOnly)) {
+                _context3.next = 32;
+                break;
+              }
+              return _context3.abrupt("return", {
+                encodedTxData: this.licensingModuleClient.registerDerivativeWithLicenseTokensEncode(req)
               });
-            case 29:
+            case 32:
+              _context3.next = 34;
+              return this.licensingModuleClient.registerDerivativeWithLicenseTokens(req);
+            case 34:
               txHash = _context3.sent;
-              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
-                _context3.next = 36;
+              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.waitForTransaction)) {
+                _context3.next = 41;
                 break;
               }
-              _context3.next = 33;
+              _context3.next = 38;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 33:
+            case 38:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 36:
+            case 41:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 37:
-              _context3.next = 42;
+            case 42:
+              _context3.next = 47;
               break;
-            case 39:
-              _context3.prev = 39;
+            case 44:
+              _context3.prev = 44;
               _context3.t1 = _context3["catch"](0);
               handleError(_context3.t1, "Failed to register derivative with license tokens");
-            case 42:
+            case 47:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[0, 39], [8, 21, 24, 27]]);
+        }, _callee3, this, [[0, 44], [8, 21, 24, 27]]);
       }));
       function registerDerivativeWithLicenseTokens(_x3) {
         return _registerDerivativeWithLicenseTokens.apply(this, arguments);
@@ -16817,7 +17636,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "mintAndRegisterIpAssetWithPilTerms",
     value: (function () {
       var _mintAndRegisterIpAssetWithPilTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
-        var _request$txOptions4, licenseTerm, object, txHash, txReceipt, iPRegisteredLog, licenseTermsId;
+        var _request$txOptions7, licenseTerm, object, _request$txOptions8, txHash, txReceipt, iPRegisteredLog, licenseTermsId;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -16851,19 +17670,27 @@ var IPAssetClient = /*#__PURE__*/function () {
                   nftMetadataHash: request.metadata.nftMetadataHash || object.metadata.nftMetadataHash
                 };
               }
-              _context4.next = 8;
+              if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.encodedTxDataOnly)) {
+                _context4.next = 10;
+                break;
+              }
+              return _context4.abrupt("return", {
+                encodedTxData: this.spgClient.mintAndRegisterIpAndAttachPilTermsEncode(object)
+              });
+            case 10:
+              _context4.next = 12;
               return this.spgClient.mintAndRegisterIpAndAttachPilTerms(object);
-            case 8:
+            case 12:
               txHash = _context4.sent;
-              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
-                _context4.next = 16;
+              if (!((_request$txOptions8 = request.txOptions) !== null && _request$txOptions8 !== void 0 && _request$txOptions8.waitForTransaction)) {
+                _context4.next = 20;
                 break;
               }
-              _context4.next = 12;
+              _context4.next = 16;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 12:
+            case 16:
               txReceipt = _context4.sent;
               iPRegisteredLog = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(txReceipt)[0];
               licenseTermsId = this.licensingModuleClient.parseTxLicenseTermsAttachedEvent(txReceipt)[0].licenseTermsId;
@@ -16873,19 +17700,22 @@ var IPAssetClient = /*#__PURE__*/function () {
                 licenseTermsId: licenseTermsId,
                 tokenId: iPRegisteredLog.tokenId
               });
-            case 16:
+            case 20:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 19:
-              _context4.prev = 19;
+            case 21:
+              _context4.next = 26;
+              break;
+            case 23:
+              _context4.prev = 23;
               _context4.t0 = _context4["catch"](0);
               handleError(_context4.t0, "Failed to mint and register IP and attach PIL terms");
-            case 22:
+            case 26:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 19]]);
+        }, _callee4, this, [[0, 23]]);
       }));
       function mintAndRegisterIpAssetWithPilTerms(_x4) {
         return _mintAndRegisterIpAssetWithPilTerms.apply(this, arguments);
@@ -16915,7 +17745,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerIpAndAttachPilTerms",
     value: (function () {
       var _registerIpAndAttachPilTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$txOptions5, ipIdAddress, isRegistered, licenseTerm, calculatedDeadline, sigAttachSignature, object, signature, txHash, txReceipt, log;
+        var _request$txOptions9, ipIdAddress, isRegistered, licenseTerm, calculatedDeadline, sigAttachSignature, object, signature, _request$txOptions10, txHash, txReceipt, log;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -17014,19 +17844,27 @@ var IPAssetClient = /*#__PURE__*/function () {
                 deadline: calculatedDeadline,
                 signature: signature
               };
-              _context5.next = 25;
+              if (!((_request$txOptions9 = request.txOptions) !== null && _request$txOptions9 !== void 0 && _request$txOptions9.encodedTxDataOnly)) {
+                _context5.next = 27;
+                break;
+              }
+              return _context5.abrupt("return", {
+                encodedTxData: this.spgClient.registerIpAndAttachPilTermsEncode(object)
+              });
+            case 27:
+              _context5.next = 29;
               return this.spgClient.registerIpAndAttachPilTerms(object);
-            case 25:
+            case 29:
               txHash = _context5.sent;
-              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.waitForTransaction)) {
-                _context5.next = 32;
+              if (!((_request$txOptions10 = request.txOptions) !== null && _request$txOptions10 !== void 0 && _request$txOptions10.waitForTransaction)) {
+                _context5.next = 36;
                 break;
               }
-              _context5.next = 29;
+              _context5.next = 33;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 29:
+            case 33:
               txReceipt = _context5.sent;
               log = this.licensingModuleClient.parseTxLicenseTermsAttachedEvent(txReceipt)[0];
               return _context5.abrupt("return", {
@@ -17034,19 +17872,22 @@ var IPAssetClient = /*#__PURE__*/function () {
                 licenseTermsId: log.licenseTermsId,
                 ipId: log.ipId
               });
-            case 32:
+            case 36:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 35:
-              _context5.prev = 35;
+            case 37:
+              _context5.next = 42;
+              break;
+            case 39:
+              _context5.prev = 39;
               _context5.t0 = _context5["catch"](0);
               handleError(_context5.t0, "Failed to register IP and attach PIL terms");
-            case 38:
+            case 42:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 35]]);
+        }, _callee5, this, [[0, 39]]);
       }));
       function registerIpAndAttachPilTerms(_x5) {
         return _registerIpAndAttachPilTerms.apply(this, arguments);
@@ -17076,7 +17917,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivativeIp",
     value: (function () {
       var _registerDerivativeIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(request) {
-        var _request$txOptions6, tokenId, ipIdAddress, isRegistered, i, isAttachedLicenseTerms, calculatedDeadline, sigRegisterSignature, object, signature, txHash, receipt, log;
+        var _request$txOptions11, tokenId, ipIdAddress, isRegistered, i, isAttachedLicenseTerms, calculatedDeadline, sigRegisterSignature, object, signature, _request$txOptions12, txHash, receipt, log;
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
@@ -17202,38 +18043,49 @@ var IPAssetClient = /*#__PURE__*/function () {
                 deadline: calculatedDeadline,
                 signature: signature
               };
-              _context6.next = 34;
+              if (!((_request$txOptions11 = request.txOptions) !== null && _request$txOptions11 !== void 0 && _request$txOptions11.encodedTxDataOnly)) {
+                _context6.next = 36;
+                break;
+              }
+              return _context6.abrupt("return", {
+                encodedTxData: this.spgClient.registerIpAndMakeDerivativeEncode(object)
+              });
+            case 36:
+              _context6.next = 38;
               return this.spgClient.registerIpAndMakeDerivative(object);
-            case 34:
+            case 38:
               txHash = _context6.sent;
-              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.waitForTransaction)) {
-                _context6.next = 41;
+              if (!((_request$txOptions12 = request.txOptions) !== null && _request$txOptions12 !== void 0 && _request$txOptions12.waitForTransaction)) {
+                _context6.next = 45;
                 break;
               }
-              _context6.next = 38;
+              _context6.next = 42;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 38:
+            case 42:
               receipt = _context6.sent;
               log = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(receipt)[0];
               return _context6.abrupt("return", {
                 txHash: txHash,
                 ipId: log.ipId
               });
-            case 41:
+            case 45:
               return _context6.abrupt("return", {
                 txHash: txHash
               });
-            case 44:
-              _context6.prev = 44;
+            case 46:
+              _context6.next = 51;
+              break;
+            case 48:
+              _context6.prev = 48;
               _context6.t0 = _context6["catch"](0);
               handleError(_context6.t0, "Failed to register derivative IP");
-            case 47:
+            case 51:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[0, 44]]);
+        }, _callee6, this, [[0, 48]]);
       }));
       function registerDerivativeIp(_x6) {
         return _registerDerivativeIp.apply(this, arguments);
@@ -17331,7 +18183,7 @@ var PermissionClient = /*#__PURE__*/function () {
     key: "setPermission",
     value: (function () {
       var _setPermission = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, txHash;
+        var _request$txOptions, req, _request$txOptions2, txHash;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -17339,45 +18191,54 @@ var PermissionClient = /*#__PURE__*/function () {
               _context.next = 3;
               return this.checkIsRegistered(request.ipId);
             case 3:
-              _context.next = 5;
-              return this.accessControllerClient.setPermission({
+              req = {
                 ipAccount: request.ipId,
                 signer: request.signer,
                 to: request.to,
                 func: request.func ? toFunctionSelector(request.func) : defaultFunctionSelector,
                 permission: request.permission
+              };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: this.accessControllerClient.setPermissionEncode(req)
               });
-            case 5:
+            case 8:
+              _context.next = 10;
+              return this.accessControllerClient.setPermission(req);
+            case 10:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 12;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 17;
                 break;
               }
-              _context.next = 9;
+              _context.next = 14;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 9:
+            case 14:
               return _context.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 12:
+            case 17:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 13:
-              _context.next = 18;
+            case 18:
+              _context.next = 23;
               break;
-            case 15:
-              _context.prev = 15;
+            case 20:
+              _context.prev = 20;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to set permissions");
-            case 18:
+            case 23:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 15]]);
+        }, _callee, this, [[0, 20]]);
       }));
       function setPermission(_x) {
         return _setPermission.apply(this, arguments);
@@ -17402,7 +18263,7 @@ var PermissionClient = /*#__PURE__*/function () {
     key: "createSetPermissionSignature",
     value: (function () {
       var _createSetPermissionSignature = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var ipId, signer, to, txOptions, func, permission, deadline, ipAccountClient, nonce, data, calculatedDeadline, signature, txHash;
+        var _request$txOptions3, ipId, signer, to, txOptions, func, permission, deadline, ipAccountClient, nonce, data, calculatedDeadline, signature, req, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -17440,46 +18301,55 @@ var PermissionClient = /*#__PURE__*/function () {
               });
             case 13:
               signature = _context2.sent;
-              _context2.next = 16;
-              return ipAccountClient.executeWithSig({
+              req = {
                 to: getAddress$1(this.accessControllerClient.address, "accessControllerClientAddress"),
                 value: BigInt(0),
                 data: data,
                 signer: signer,
                 deadline: calculatedDeadline,
                 signature: signature
+              };
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 19;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: ipAccountClient.executeWithSigEncode(req)
               });
-            case 16:
+            case 19:
+              _context2.next = 21;
+              return ipAccountClient.executeWithSig(req);
+            case 21:
               txHash = _context2.sent;
               if (!(txOptions !== null && txOptions !== void 0 && txOptions.waitForTransaction)) {
-                _context2.next = 23;
+                _context2.next = 28;
                 break;
               }
-              _context2.next = 20;
+              _context2.next = 25;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 20:
+            case 25:
               return _context2.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 23:
+            case 28:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 24:
-              _context2.next = 29;
+            case 29:
+              _context2.next = 34;
               break;
-            case 26:
-              _context2.prev = 26;
+            case 31:
+              _context2.prev = 31;
               _context2.t1 = _context2["catch"](0);
               handleError(_context2.t1, "Failed to create set permission signature");
-            case 29:
+            case 34:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 26]]);
+        }, _callee2, this, [[0, 31]]);
       }));
       function createSetPermissionSignature(_x2) {
         return _createSetPermissionSignature.apply(this, arguments);
@@ -17501,7 +18371,7 @@ var PermissionClient = /*#__PURE__*/function () {
     key: "setAllPermissions",
     value: (function () {
       var _setAllPermissions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions2, txHash;
+        var _request$txOptions4, req, _request$txOptions5, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
@@ -17509,43 +18379,52 @@ var PermissionClient = /*#__PURE__*/function () {
               _context3.next = 3;
               return this.checkIsRegistered(request.ipId);
             case 3:
-              _context3.next = 5;
-              return this.accessControllerClient.setAllPermissions({
+              req = {
                 ipAccount: request.ipId,
                 signer: request.signer,
                 permission: request.permission
+              };
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.encodedTxDataOnly)) {
+                _context3.next = 8;
+                break;
+              }
+              return _context3.abrupt("return", {
+                encodedTxData: this.accessControllerClient.setAllPermissionsEncode(req)
               });
-            case 5:
+            case 8:
+              _context3.next = 10;
+              return this.accessControllerClient.setAllPermissions(req);
+            case 10:
               txHash = _context3.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context3.next = 12;
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.waitForTransaction)) {
+                _context3.next = 17;
                 break;
               }
-              _context3.next = 9;
+              _context3.next = 14;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 9:
+            case 14:
               return _context3.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 12:
+            case 17:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 13:
-              _context3.next = 18;
+            case 18:
+              _context3.next = 23;
               break;
-            case 15:
-              _context3.prev = 15;
+            case 20:
+              _context3.prev = 20;
               _context3.t0 = _context3["catch"](0);
               handleError(_context3.t0, "Failed to set all permissions");
-            case 18:
+            case 23:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[0, 15]]);
+        }, _callee3, this, [[0, 20]]);
       }));
       function setAllPermissions(_x3) {
         return _setAllPermissions.apply(this, arguments);
@@ -17571,7 +18450,7 @@ var PermissionClient = /*#__PURE__*/function () {
     key: "setBatchPermissions",
     value: (function () {
       var _setBatchPermissions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
-        var permissions, txOptions, _iterator, _step, permission, txHash;
+        var _request$txOptions6, permissions, txOptions, _iterator, _step, permission, req, txHash;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -17603,8 +18482,7 @@ var PermissionClient = /*#__PURE__*/function () {
               _iterator.f();
               return _context4.finish(16);
             case 19:
-              _context4.next = 21;
-              return this.accessControllerClient.setBatchPermissions({
+              req = {
                 permissions: permissions.map(function (permission) {
                   return {
                     ipAccount: permission.ipId,
@@ -17614,38 +18492,48 @@ var PermissionClient = /*#__PURE__*/function () {
                     permission: permission.permission
                   };
                 })
+              };
+              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.encodedTxDataOnly)) {
+                _context4.next = 24;
+                break;
+              }
+              return _context4.abrupt("return", {
+                encodedTxData: this.accessControllerClient.setBatchPermissionsEncode(req)
               });
-            case 21:
+            case 24:
+              _context4.next = 26;
+              return this.accessControllerClient.setBatchPermissions(req);
+            case 26:
               txHash = _context4.sent;
               if (!(txOptions !== null && txOptions !== void 0 && txOptions.waitForTransaction)) {
-                _context4.next = 28;
+                _context4.next = 33;
                 break;
               }
-              _context4.next = 25;
+              _context4.next = 30;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 25:
+            case 30:
               return _context4.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 28:
+            case 33:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 29:
-              _context4.next = 34;
+            case 34:
+              _context4.next = 39;
               break;
-            case 31:
-              _context4.prev = 31;
+            case 36:
+              _context4.prev = 36;
               _context4.t1 = _context4["catch"](0);
               handleError(_context4.t1, "Failed to set batch permissions");
-            case 34:
+            case 39:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 31], [3, 13, 16, 19]]);
+        }, _callee4, this, [[0, 36], [3, 13, 16, 19]]);
       }));
       function setBatchPermissions(_x4) {
         return _setBatchPermissions.apply(this, arguments);
@@ -17671,7 +18559,7 @@ var PermissionClient = /*#__PURE__*/function () {
     key: "createBatchPermissionSignature",
     value: (function () {
       var _createBatchPermissionSignature = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var permissions, deadline, ipId, txOptions, _iterator2, _step2, permission, ipAccountClient, nonce, data, calculatedDeadline, signature, txHash;
+        var _request$txOptions7, permissions, deadline, ipId, txOptions, _iterator2, _step2, permission, ipAccountClient, nonce, data, calculatedDeadline, signature, req, txHash;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -17735,46 +18623,55 @@ var PermissionClient = /*#__PURE__*/function () {
               });
             case 28:
               signature = _context5.sent;
-              _context5.next = 31;
-              return ipAccountClient.executeWithSig({
+              req = {
                 to: getAddress$1(this.accessControllerClient.address, "accessControllerAddress"),
                 value: BigInt(0),
                 data: data,
                 signer: getAddress$1(this.wallet.account.address, "walletAccountAddress"),
                 deadline: calculatedDeadline,
                 signature: signature
+              };
+              if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.encodedTxDataOnly)) {
+                _context5.next = 34;
+                break;
+              }
+              return _context5.abrupt("return", {
+                encodedTxData: ipAccountClient.executeWithSigEncode(req)
               });
-            case 31:
+            case 34:
+              _context5.next = 36;
+              return ipAccountClient.executeWithSig(req);
+            case 36:
               txHash = _context5.sent;
               if (!(txOptions !== null && txOptions !== void 0 && txOptions.waitForTransaction)) {
-                _context5.next = 38;
+                _context5.next = 43;
                 break;
               }
-              _context5.next = 35;
+              _context5.next = 40;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 35:
+            case 40:
               return _context5.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 38:
+            case 43:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 39:
-              _context5.next = 44;
+            case 44:
+              _context5.next = 49;
               break;
-            case 41:
-              _context5.prev = 41;
+            case 46:
+              _context5.prev = 46;
               _context5.t2 = _context5["catch"](0);
               handleError(_context5.t2, "Failed to create batch permission signature");
-            case 44:
+            case 49:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 41], [3, 13, 16, 19]]);
+        }, _callee5, this, [[0, 46], [3, 13, 16, 19]]);
       }));
       function createBatchPermissionSignature(_x5) {
         return _createBatchPermissionSignature.apply(this, arguments);
@@ -17838,7 +18735,7 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "registerNonComSocialRemixingPIL",
     value: (function () {
       var _registerNonComSocialRemixingPIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, licenseTerms, licenseTermsId, txHash, txReceipt, targetLogs;
+        var _request$txOptions, licenseTerms, licenseTermsId, _request$txOptions2, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -17856,43 +18753,53 @@ var LicenseClient = /*#__PURE__*/function () {
                 licenseTermsId: licenseTermsId
               });
             case 7:
-              _context.next = 9;
+              if (!(request !== null && request !== void 0 && (_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 11;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: this.licenseTemplateClient.registerLicenseTermsEncode({
+                  terms: licenseTerms
+                })
+              });
+            case 11:
+              _context.next = 13;
               return this.licenseTemplateClient.registerLicenseTerms({
                 terms: licenseTerms
               });
-            case 9:
+            case 13:
               txHash = _context.sent;
-              if (!(request !== null && request !== void 0 && (_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 18;
+              if (!(request !== null && request !== void 0 && (_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 22;
                 break;
               }
-              _context.next = 13;
+              _context.next = 17;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 13:
+            case 17:
               txReceipt = _context.sent;
               targetLogs = this.licenseTemplateClient.parseTxLicenseTermsRegisteredEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 licenseTermsId: targetLogs[0].licenseTermsId
               });
-            case 18:
+            case 22:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 19:
-              _context.next = 24;
+            case 23:
+              _context.next = 28;
               break;
-            case 21:
-              _context.prev = 21;
+            case 25:
+              _context.prev = 25;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to register non commercial social remixing PIL");
-            case 24:
+            case 28:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 21]]);
+        }, _callee, this, [[0, 25]]);
       }));
       function registerNonComSocialRemixingPIL(_x) {
         return _registerNonComSocialRemixingPIL.apply(this, arguments);
@@ -17913,7 +18820,7 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "registerCommercialUsePIL",
     value: (function () {
       var _registerCommercialUsePIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, licenseTerms, licenseTermsId, txHash, txReceipt, targetLogs;
+        var _request$txOptions3, licenseTerms, licenseTermsId, _request$txOptions4, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -17935,43 +18842,53 @@ var LicenseClient = /*#__PURE__*/function () {
                 licenseTermsId: licenseTermsId
               });
             case 7:
-              _context2.next = 9;
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 11;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: this.licenseTemplateClient.registerLicenseTermsEncode({
+                  terms: licenseTerms
+                })
+              });
+            case 11:
+              _context2.next = 13;
               return this.licenseTemplateClient.registerLicenseTerms({
                 terms: licenseTerms
               });
-            case 9:
+            case 13:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 18;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context2.next = 22;
                 break;
               }
-              _context2.next = 13;
+              _context2.next = 17;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 13:
+            case 17:
               txReceipt = _context2.sent;
               targetLogs = this.licenseTemplateClient.parseTxLicenseTermsRegisteredEvent(txReceipt);
               return _context2.abrupt("return", {
                 txHash: txHash,
                 licenseTermsId: targetLogs[0].licenseTermsId
               });
-            case 18:
+            case 22:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 19:
-              _context2.next = 24;
+            case 23:
+              _context2.next = 28;
               break;
-            case 21:
-              _context2.prev = 21;
+            case 25:
+              _context2.prev = 25;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to register commercial use PIL");
-            case 24:
+            case 28:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 21]]);
+        }, _callee2, this, [[0, 25]]);
       }));
       function registerCommercialUsePIL(_x2) {
         return _registerCommercialUsePIL.apply(this, arguments);
@@ -17993,7 +18910,7 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "registerCommercialRemixPIL",
     value: (function () {
       var _registerCommercialRemixPIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions3, licenseTerms, licenseTermsId, txHash, txReceipt, targetLogs;
+        var _request$txOptions5, licenseTerms, licenseTermsId, _request$txOptions6, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
@@ -18016,43 +18933,53 @@ var LicenseClient = /*#__PURE__*/function () {
                 licenseTermsId: licenseTermsId
               });
             case 7:
-              _context3.next = 9;
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.encodedTxDataOnly)) {
+                _context3.next = 11;
+                break;
+              }
+              return _context3.abrupt("return", {
+                encodedTxData: this.licenseTemplateClient.registerLicenseTermsEncode({
+                  terms: licenseTerms
+                })
+              });
+            case 11:
+              _context3.next = 13;
               return this.licenseTemplateClient.registerLicenseTerms({
                 terms: licenseTerms
               });
-            case 9:
+            case 13:
               txHash = _context3.sent;
-              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
-                _context3.next = 18;
+              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.waitForTransaction)) {
+                _context3.next = 22;
                 break;
               }
-              _context3.next = 13;
+              _context3.next = 17;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 13:
+            case 17:
               txReceipt = _context3.sent;
               targetLogs = this.licenseTemplateClient.parseTxLicenseTermsRegisteredEvent(txReceipt);
               return _context3.abrupt("return", {
                 txHash: txHash,
                 licenseTermsId: targetLogs[0].licenseTermsId
               });
-            case 18:
+            case 22:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 19:
-              _context3.next = 24;
+            case 23:
+              _context3.next = 28;
               break;
-            case 21:
-              _context3.prev = 21;
+            case 25:
+              _context3.prev = 25;
               _context3.t0 = _context3["catch"](0);
               handleError(_context3.t0, "Failed to register commercial remix PIL");
-            case 24:
+            case 28:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[0, 21]]);
+        }, _callee3, this, [[0, 25]]);
       }));
       function registerCommercialRemixPIL(_x3) {
         return _registerCommercialRemixPIL.apply(this, arguments);
@@ -18073,7 +19000,7 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "attachLicenseTerms",
     value: (function () {
       var _attachLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
-        var _request$txOptions4, isRegistered, isExisted, isAttachedLicenseTerms, txHash;
+        var _request$txOptions7, isRegistered, isExisted, isAttachedLicenseTerms, req, _request$txOptions8, txHash;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -18120,43 +19047,52 @@ var LicenseClient = /*#__PURE__*/function () {
                 success: false
               });
             case 17:
-              _context4.next = 19;
-              return this.licensingModuleClient.attachLicenseTerms({
+              req = {
                 ipId: request.ipId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: request.licenseTermsId
+              };
+              if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.encodedTxDataOnly)) {
+                _context4.next = 22;
+                break;
+              }
+              return _context4.abrupt("return", {
+                encodedTxData: this.licensingModuleClient.attachLicenseTermsEncode(req)
               });
-            case 19:
+            case 22:
+              _context4.next = 24;
+              return this.licensingModuleClient.attachLicenseTerms(req);
+            case 24:
               txHash = _context4.sent;
-              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
-                _context4.next = 26;
+              if (!((_request$txOptions8 = request.txOptions) !== null && _request$txOptions8 !== void 0 && _request$txOptions8.waitForTransaction)) {
+                _context4.next = 31;
                 break;
               }
-              _context4.next = 23;
+              _context4.next = 28;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 23:
+            case 28:
               return _context4.abrupt("return", {
                 txHash: txHash,
                 success: true
               });
-            case 26:
+            case 31:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 27:
-              _context4.next = 32;
+            case 32:
+              _context4.next = 37;
               break;
-            case 29:
-              _context4.prev = 29;
+            case 34:
+              _context4.prev = 34;
               _context4.t0 = _context4["catch"](0);
               handleError(_context4.t0, "Failed to attach license terms");
-            case 32:
+            case 37:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 29]]);
+        }, _callee4, this, [[0, 34]]);
       }));
       function attachLicenseTerms(_x4) {
         return _attachLicenseTerms.apply(this, arguments);
@@ -18190,7 +19126,7 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "mintLicenseTokens",
     value: (function () {
       var _mintLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$txOptions5, isLicenseIpIdRegistered, isExisted, isAttachedLicenseTerms, amount, txHash, txReceipt, targetLogs, startLicenseTokenId, licenseTokenIds, i;
+        var _request$txOptions9, isLicenseIpIdRegistered, isExisted, isAttachedLicenseTerms, amount, req, _request$txOptions10, txHash, txReceipt, targetLogs, startLicenseTokenId, licenseTokenIds, i;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -18235,26 +19171,35 @@ var LicenseClient = /*#__PURE__*/function () {
               throw new Error("License terms id ".concat(request.licenseTermsId, " is not attached to the IP with id ").concat(request.licensorIpId, "."));
             case 17:
               amount = BigInt(request.amount || 1);
-              _context5.next = 20;
-              return this.licensingModuleClient.mintLicenseTokens({
+              req = {
                 licensorIpId: request.licensorIpId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: request.licenseTermsId,
                 amount: amount,
                 receiver: request.receiver && getAddress$1(request.receiver, "request.receiver") || this.wallet.account.address,
                 royaltyContext: zeroAddress
+              };
+              if (!((_request$txOptions9 = request.txOptions) !== null && _request$txOptions9 !== void 0 && _request$txOptions9.encodedTxDataOnly)) {
+                _context5.next = 23;
+                break;
+              }
+              return _context5.abrupt("return", {
+                encodedTxData: this.licensingModuleClient.mintLicenseTokensEncode(req)
               });
-            case 20:
+            case 23:
+              _context5.next = 25;
+              return this.licensingModuleClient.mintLicenseTokens(req);
+            case 25:
               txHash = _context5.sent;
-              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.waitForTransaction)) {
-                _context5.next = 32;
+              if (!((_request$txOptions10 = request.txOptions) !== null && _request$txOptions10 !== void 0 && _request$txOptions10.waitForTransaction)) {
+                _context5.next = 37;
                 break;
               }
-              _context5.next = 24;
+              _context5.next = 29;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 24:
+            case 29:
               txReceipt = _context5.sent;
               targetLogs = this.licensingModuleClient.parseTxLicenseTokensMintedEvent(txReceipt);
               startLicenseTokenId = targetLogs[0].startLicenseTokenId;
@@ -18266,22 +19211,22 @@ var LicenseClient = /*#__PURE__*/function () {
                 txHash: txHash,
                 licenseTokenIds: licenseTokenIds
               });
-            case 32:
+            case 37:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 33:
-              _context5.next = 38;
+            case 38:
+              _context5.next = 43;
               break;
-            case 35:
-              _context5.prev = 35;
+            case 40:
+              _context5.prev = 40;
               _context5.t0 = _context5["catch"](0);
               handleError(_context5.t0, "Failed to mint license tokens");
-            case 38:
+            case 43:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 35]]);
+        }, _callee5, this, [[0, 40]]);
       }));
       function mintLicenseTokens(_x5) {
         return _mintLicenseTokens.apply(this, arguments);
@@ -18379,50 +19324,62 @@ var DisputeClient = /*#__PURE__*/function () {
     key: "raiseDispute",
     value: (function () {
       var _raiseDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, txHash, txReceipt, targetLogs;
+        var _request$txOptions, req, _request$txOptions2, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
-              _context.next = 3;
-              return this.disputeModuleClient.raiseDispute({
+              req = {
                 targetIpId: getAddress$1(request.targetIpId, "request.targetIpId"),
                 linkToDisputeEvidence: request.linkToDisputeEvidence,
                 targetTag: stringToHex(request.targetTag, {
                   size: 32
                 }),
                 data: request.calldata || "0x"
+              };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 6;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: this.disputeModuleClient.raiseDisputeEncode(req)
               });
-            case 3:
+            case 6:
+              _context.next = 8;
+              return this.disputeModuleClient.raiseDispute(req);
+            case 8:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 10;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 15;
                 break;
               }
-              _context.next = 7;
+              _context.next = 12;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 7:
+            case 12:
               txReceipt = _context.sent;
               targetLogs = this.disputeModuleClient.parseTxDisputeRaisedEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 disputeId: targetLogs[0].disputeId
               });
-            case 10:
+            case 15:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 13:
-              _context.prev = 13;
+            case 16:
+              _context.next = 21;
+              break;
+            case 18:
+              _context.prev = 18;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to raise dispute");
-            case 16:
+            case 21:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 13]]);
+        }, _callee, this, [[0, 18]]);
       }));
       function raiseDispute(_x) {
         return _raiseDispute.apply(this, arguments);
@@ -18446,39 +19403,51 @@ var DisputeClient = /*#__PURE__*/function () {
     key: "cancelDispute",
     value: (function () {
       var _cancelDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, txHash;
+        var _request$txOptions3, req, _request$txOptions4, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
-              _context2.next = 3;
-              return this.disputeModuleClient.cancelDispute({
+              req = {
                 disputeId: BigInt(request.disputeId),
                 data: request.calldata ? request.calldata : "0x"
+              };
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: this.disputeModuleClient.cancelDisputeEncode(req)
               });
-            case 3:
+            case 6:
+              _context2.next = 8;
+              return this.disputeModuleClient.cancelDispute(req);
+            case 8:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 7;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context2.next = 12;
                 break;
               }
-              _context2.next = 7;
+              _context2.next = 12;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 7:
+            case 12:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 10:
-              _context2.prev = 10;
+            case 13:
+              _context2.next = 18;
+              break;
+            case 15:
+              _context2.prev = 15;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to cancel dispute");
-            case 13:
+            case 18:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 10]]);
+        }, _callee2, this, [[0, 15]]);
       }));
       function cancelDispute(_x2) {
         return _cancelDispute.apply(this, arguments);
@@ -18500,39 +19469,51 @@ var DisputeClient = /*#__PURE__*/function () {
     key: "resolveDispute",
     value: (function () {
       var _resolveDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions3, txHash;
+        var _request$txOptions5, req, _request$txOptions6, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               _context3.prev = 0;
-              _context3.next = 3;
-              return this.disputeModuleClient.resolveDispute({
+              req = {
                 disputeId: BigInt(request.disputeId),
                 data: request.data
+              };
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.encodedTxDataOnly)) {
+                _context3.next = 6;
+                break;
+              }
+              return _context3.abrupt("return", {
+                encodedTxData: this.disputeModuleClient.resolveDisputeEncode(req)
               });
-            case 3:
+            case 6:
+              _context3.next = 8;
+              return this.disputeModuleClient.resolveDispute(req);
+            case 8:
               txHash = _context3.sent;
-              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
-                _context3.next = 7;
+              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.waitForTransaction)) {
+                _context3.next = 12;
                 break;
               }
-              _context3.next = 7;
+              _context3.next = 12;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 7:
+            case 12:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 10:
-              _context3.prev = 10;
+            case 13:
+              _context3.next = 18;
+              break;
+            case 15:
+              _context3.prev = 15;
               _context3.t0 = _context3["catch"](0);
               handleError(_context3.t0, "Failed to resolve dispute");
-            case 13:
+            case 18:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[0, 10]]);
+        }, _callee3, this, [[0, 15]]);
       }));
       function resolveDispute(_x3) {
         return _resolveDispute.apply(this, arguments);
@@ -18562,41 +19543,53 @@ var IPAccountClient = /*#__PURE__*/function () {
     key: "execute",
     value: (function () {
       var _execute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, ipAccountClient, txHash;
+        var _request$txOptions, ipAccountClient, req, _request$txOptions2, txHash;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(request.ipId, "request.ipId"));
-              _context.next = 4;
-              return ipAccountClient.execute({
+              req = {
                 to: request.to,
                 value: BigInt(0),
                 data: request.data
+              };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 7;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: ipAccountClient.executeEncode(req)
               });
-            case 4:
+            case 7:
+              _context.next = 9;
+              return ipAccountClient.execute(req);
+            case 9:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 8;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 13;
                 break;
               }
-              _context.next = 8;
+              _context.next = 13;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 8:
+            case 13:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 11:
-              _context.prev = 11;
+            case 14:
+              _context.next = 19;
+              break;
+            case 16:
+              _context.prev = 16;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to execute the IP Account transaction");
-            case 14:
+            case 19:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 11]]);
+        }, _callee, this, [[0, 16]]);
       }));
       function execute(_x) {
         return _execute.apply(this, arguments);
@@ -18619,44 +19612,56 @@ var IPAccountClient = /*#__PURE__*/function () {
     key: "executeWithSig",
     value: (function () {
       var _executeWithSig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, ipAccountClient, txHash;
+        var _request$txOptions3, ipAccountClient, req, _request$txOptions4, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
               ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(request.ipId, "request.ipId"));
-              _context2.next = 4;
-              return ipAccountClient.executeWithSig({
+              req = {
                 to: getAddress$1(request.to, "request.to"),
                 value: BigInt(0),
                 data: request.data,
                 signer: getAddress$1(request.signer, "request.signer"),
                 deadline: BigInt(request.deadline),
                 signature: request.signature
+              };
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 7;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: ipAccountClient.executeWithSigEncode(req)
               });
-            case 4:
+            case 7:
+              _context2.next = 9;
+              return ipAccountClient.executeWithSig(req);
+            case 9:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 8;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context2.next = 13;
                 break;
               }
-              _context2.next = 8;
+              _context2.next = 13;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 8:
+            case 13:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 11:
-              _context2.prev = 11;
+            case 14:
+              _context2.next = 19;
+              break;
+            case 16:
+              _context2.prev = 16;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to execute with signature for the IP Account transaction");
-            case 14:
+            case 19:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 11]]);
+        }, _callee2, this, [[0, 16]]);
       }));
       function executeWithSig(_x2) {
         return _executeWithSig.apply(this, arguments);
@@ -18719,7 +19724,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "collectRoyaltyTokens",
     value: (function () {
       var _collectRoyaltyTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, isParentIpIdRegistered, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
+        var _request$txOptions, isParentIpIdRegistered, proxyAddress, ipRoyaltyVault, req, _request$txOptions2, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -18741,43 +19746,52 @@ var RoyaltyClient = /*#__PURE__*/function () {
             case 8:
               proxyAddress = _context.sent;
               ipRoyaltyVault = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet, proxyAddress);
-              _context.next = 12;
-              return ipRoyaltyVault.collectRoyaltyTokens({
+              req = {
                 ancestorIpId: request.parentIpId
+              };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 15;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: ipRoyaltyVault.collectRoyaltyTokensEncode(req)
               });
-            case 12:
+            case 15:
+              _context.next = 17;
+              return ipRoyaltyVault.collectRoyaltyTokens(req);
+            case 17:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 21;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 26;
                 break;
               }
-              _context.next = 16;
+              _context.next = 21;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 16:
+            case 21:
               txReceipt = _context.sent;
               targetLogs = ipRoyaltyVault.parseTxRoyaltyTokensCollectedEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 royaltyTokensCollected: targetLogs[0].royaltyTokensCollected
               });
-            case 21:
+            case 26:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 22:
-              _context.next = 27;
+            case 27:
+              _context.next = 32;
               break;
-            case 24:
-              _context.prev = 24;
+            case 29:
+              _context.prev = 29;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to collect royalty tokens");
-            case 27:
+            case 32:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 24]]);
+        }, _callee, this, [[0, 29]]);
       }));
       function collectRoyaltyTokens(_x) {
         return _collectRoyaltyTokens.apply(this, arguments);
@@ -18799,7 +19813,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "payRoyaltyOnBehalf",
     value: (function () {
       var _payRoyaltyOnBehalf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, isReceiverRegistered, isPayerRegistered, txHash;
+        var _request$txOptions3, isReceiverRegistered, isPayerRegistered, req, _request$txOptions4, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -18828,43 +19842,52 @@ var RoyaltyClient = /*#__PURE__*/function () {
               }
               throw new Error("The payer IP with id ".concat(request.payerIpId, " is not registered."));
             case 11:
-              _context2.next = 13;
-              return this.royaltyModuleClient.payRoyaltyOnBehalf({
+              req = {
                 receiverIpId: request.receiverIpId,
                 payerIpId: request.payerIpId,
                 token: getAddress$1(request.token, "request.token"),
                 amount: BigInt(request.amount)
+              };
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
+                _context2.next = 16;
+                break;
+              }
+              return _context2.abrupt("return", {
+                encodedTxData: this.royaltyModuleClient.payRoyaltyOnBehalfEncode(req)
               });
-            case 13:
+            case 16:
+              _context2.next = 18;
+              return this.royaltyModuleClient.payRoyaltyOnBehalf(req);
+            case 18:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 20;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context2.next = 25;
                 break;
               }
-              _context2.next = 17;
+              _context2.next = 22;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 17:
+            case 22:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 20:
+            case 25:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 21:
-              _context2.next = 26;
+            case 26:
+              _context2.next = 31;
               break;
-            case 23:
-              _context2.prev = 23;
+            case 28:
+              _context2.prev = 28;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to pay royalty on behalf");
-            case 26:
+            case 31:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 23]]);
+        }, _callee2, this, [[0, 28]]);
       }));
       function payRoyaltyOnBehalf(_x2) {
         return _payRoyaltyOnBehalf.apply(this, arguments);
@@ -18935,7 +19958,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "claimRevenue",
     value: (function () {
       var _claimRevenue = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
-        var _request$txOptions3, proxyAddress, ipRoyaltyVault, txHash, iPAccountExecuteResponse, txReceipt, targetLogs;
+        var _request$txOptions7, proxyAddress, ipRoyaltyVault, txHash, _request$txOptions5, iPAccountExecuteResponse, _request$txOptions6, req, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -18949,7 +19972,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
                 return BigInt(item);
               });
               if (!request.account) {
-                _context4.next = 13;
+                _context4.next = 15;
                 break;
               }
               _context4.next = 9;
@@ -18957,9 +19980,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
                 to: proxyAddress,
                 value: 0,
                 ipId: getAddress$1(request.account, "request.account"),
-                txOptions: {
-                  waitForTransaction: true
-                },
+                txOptions: request.txOptions,
                 data: encodeFunctionData({
                   abi: ipRoyaltyVaultImplAbi,
                   functionName: "claimRevenueBySnapshotBatch",
@@ -18968,49 +19989,66 @@ var RoyaltyClient = /*#__PURE__*/function () {
               });
             case 9:
               iPAccountExecuteResponse = _context4.sent;
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.encodedTxDataOnly)) {
+                _context4.next = 12;
+                break;
+              }
+              return _context4.abrupt("return", {
+                encodedTxData: iPAccountExecuteResponse.encodedTxData
+              });
+            case 12:
               txHash = iPAccountExecuteResponse.txHash;
-              _context4.next = 16;
+              _context4.next = 23;
               break;
-            case 13:
-              _context4.next = 15;
-              return ipRoyaltyVault.claimRevenueBySnapshotBatch({
+            case 15:
+              req = {
                 snapshotIds: request.snapshotIds,
                 token: getAddress$1(request.token, "request.token")
+              };
+              if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.encodedTxDataOnly)) {
+                _context4.next = 20;
+                break;
+              }
+              return _context4.abrupt("return", {
+                encodedTxData: ipRoyaltyVault.claimRevenueBySnapshotBatchEncode(req)
               });
-            case 15:
+            case 20:
+              _context4.next = 22;
+              return ipRoyaltyVault.claimRevenueBySnapshotBatch(req);
+            case 22:
               txHash = _context4.sent;
-            case 16:
-              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
-                _context4.next = 24;
+            case 23:
+              if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.waitForTransaction)) {
+                _context4.next = 31;
                 break;
               }
-              _context4.next = 19;
+              _context4.next = 26;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 19:
+            case 26:
               txReceipt = _context4.sent;
               targetLogs = ipRoyaltyVault.parseTxRevenueTokenClaimedEvent(txReceipt);
               return _context4.abrupt("return", {
                 txHash: txHash,
                 claimableToken: targetLogs[0].amount
               });
-            case 24:
+            case 31:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 25:
-              _context4.next = 30;
+            case 32:
+              _context4.next = 37;
               break;
-            case 27:
-              _context4.prev = 27;
+            case 34:
+              _context4.prev = 34;
               _context4.t0 = _context4["catch"](0);
               handleError(_context4.t0, "Failed to claim revenue");
-            case 30:
+            case 37:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 27]]);
+        }, _callee4, this, [[0, 34]]);
       }));
       function claimRevenue(_x4) {
         return _claimRevenue.apply(this, arguments);
@@ -19030,7 +20068,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "snapshot",
     value: (function () {
       var _snapshot = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$txOptions4, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
+        var _request$txOptions8, proxyAddress, ipRoyaltyVault, _request$txOptions9, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -19040,41 +20078,49 @@ var RoyaltyClient = /*#__PURE__*/function () {
             case 3:
               proxyAddress = _context5.sent;
               ipRoyaltyVault = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet, proxyAddress);
-              _context5.next = 7;
+              if (!((_request$txOptions8 = request.txOptions) !== null && _request$txOptions8 !== void 0 && _request$txOptions8.encodedTxDataOnly)) {
+                _context5.next = 9;
+                break;
+              }
+              return _context5.abrupt("return", {
+                encodedTxData: ipRoyaltyVault.snapshotEncode()
+              });
+            case 9:
+              _context5.next = 11;
               return ipRoyaltyVault.snapshot();
-            case 7:
+            case 11:
               txHash = _context5.sent;
-              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
-                _context5.next = 16;
+              if (!((_request$txOptions9 = request.txOptions) !== null && _request$txOptions9 !== void 0 && _request$txOptions9.waitForTransaction)) {
+                _context5.next = 20;
                 break;
               }
-              _context5.next = 11;
+              _context5.next = 15;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 11:
+            case 15:
               txReceipt = _context5.sent;
               targetLogs = ipRoyaltyVault.parseTxSnapshotCompletedEvent(txReceipt);
               return _context5.abrupt("return", {
                 txHash: txHash,
                 snapshotId: targetLogs[0].snapshotId
               });
-            case 16:
+            case 20:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 17:
-              _context5.next = 22;
+            case 21:
+              _context5.next = 26;
               break;
-            case 19:
-              _context5.prev = 19;
+            case 23:
+              _context5.prev = 23;
               _context5.t0 = _context5["catch"](0);
               handleError(_context5.t0, "Failed to snapshot");
-            case 22:
+            case 26:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 19]]);
+        }, _callee5, this, [[0, 23]]);
       }));
       function snapshot(_x5) {
         return _snapshot.apply(this, arguments);
@@ -19159,7 +20205,7 @@ var NftClient = /*#__PURE__*/function () {
     key: "createNFTCollection",
     value: (function () {
       var _createNFTCollection = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$maxSupply, _request$mintFee, _request$mintFeeToken, _request$txOptions, txHash, txReceipt, targetLogs;
+        var _request$maxSupply, _request$mintFee, _request$mintFeeToken, _request$txOptions, req, _request$txOptions2, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -19170,45 +20216,57 @@ var NftClient = /*#__PURE__*/function () {
               }
               throw new Error("Invalid mint fee token address, mint fee is greater than 0.");
             case 3:
-              _context.next = 5;
-              return this.spgClient.createCollection({
+              req = {
                 name: request.name,
                 symbol: request.symbol,
                 maxSupply: (_request$maxSupply = request.maxSupply) !== null && _request$maxSupply !== void 0 ? _request$maxSupply : Number(maxUint32),
                 mintFee: (_request$mintFee = request.mintFee) !== null && _request$mintFee !== void 0 ? _request$mintFee : 0n,
                 mintFeeToken: (_request$mintFeeToken = request.mintFeeToken) !== null && _request$mintFeeToken !== void 0 ? _request$mintFeeToken : zeroAddress,
                 owner: request.owner && getAddress$1(request.owner, "request.owner") || this.wallet.account.address
+              };
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", {
+                encodedTxData: this.spgClient.createCollectionEncode(req)
               });
-            case 5:
+            case 8:
+              _context.next = 10;
+              return this.spgClient.createCollection(req);
+            case 10:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 12;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context.next = 17;
                 break;
               }
-              _context.next = 9;
+              _context.next = 14;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 9:
+            case 14:
               txReceipt = _context.sent;
               targetLogs = this.spgClient.parseTxCollectionCreatedEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 nftContract: targetLogs[0].nftContract
               });
-            case 12:
+            case 17:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 15:
-              _context.prev = 15;
+            case 18:
+              _context.next = 23;
+              break;
+            case 20:
+              _context.prev = 20;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to create a SPG NFT collection");
-            case 18:
+            case 23:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 15]]);
+        }, _callee, this, [[0, 20]]);
       }));
       function createNFTCollection(_x) {
         return _createNFTCollection.apply(this, arguments);