@trustvc/trustvc 1.7.3 → 1.8.0

package/dist/esm/token-registry-functions/rejectTransfers.js

@@ -0,0 +1,162 @@
+import { getTitleEscrowAddress, encrypt, isTitleEscrowVersion, TitleEscrowInterface } from './../core';
+import { v5Contracts } from './../token-registry-v5';
+import { getTxOptions } from './utils';
+import { getEthersContractFromProvider, isV6EthersProvider } from '../utils/ethers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const rejectTransferHolder = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress, tokenId } = contractOptions;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!titleEscrowAddress) {
+    if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+    if (!tokenId) throw new Error("Token ID is required");
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      {}
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Title escrow address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { remarks } = params;
+  const Contract = getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [encryptedRemarks] : [];
+    if (isV6) {
+      await titleEscrowContract.rejectTransferHolder.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.rejectTransferHolder(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for rejectTransferHolder failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await titleEscrowContract.rejectTransferHolder(encryptedRemarks, txOptions);
+}, "rejectTransferHolder");
+const rejectTransferBeneficiary = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress, tokenId } = contractOptions;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!titleEscrowAddress) {
+    if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+    if (!tokenId) throw new Error("Token ID is required");
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      {}
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { remarks } = params;
+  const Contract = getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [encryptedRemarks] : [];
+    if (isV6) {
+      await titleEscrowContract.rejectTransferBeneficiary.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.rejectTransferBeneficiary(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for rejectTransferBeneficiary failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await titleEscrowContract.rejectTransferBeneficiary(encryptedRemarks, txOptions);
+}, "rejectTransferBeneficiary");
+const rejectTransferOwners = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress, tokenId } = contractOptions;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!titleEscrowAddress) {
+    if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+    if (!tokenId) throw new Error("Token ID is required");
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      {}
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { remarks } = params;
+  const Contract = getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [encryptedRemarks] : [];
+    if (isV6) {
+      await titleEscrowContract.rejectTransferOwners.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.rejectTransferOwners(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for rejectTransferOwners failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await titleEscrowContract.rejectTransferOwners(encryptedRemarks, txOptions);
+}, "rejectTransferOwners");
+
+export { rejectTransferBeneficiary, rejectTransferHolder, rejectTransferOwners };

package/dist/esm/token-registry-functions/returnToken.js

@@ -0,0 +1,206 @@
+import { getTitleEscrowAddress, encrypt, isTitleEscrowVersion, TitleEscrowInterface, checkSupportsInterface } from '../core';
+import { v5Contracts, v5SupportInterfaceIds } from '../token-registry-v5';
+import { v4Contracts, v4SupportInterfaceIds } from '../token-registry-v4';
+import { getTxOptions } from './utils';
+import { getEthersContractFromProvider, isV6EthersProvider } from '../utils/ethers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const returnToIssuer = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress, tokenId } = contractOptions;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!titleEscrowAddress) {
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      {}
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Title Escrow address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { remarks } = params;
+  const encryptedRemarks = remarks && options.id ? `0x${encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      await isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      await isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV5TT && !isV4TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [encryptedRemarks] : [];
+    const staticCallFxn = isV5TT ? "returnToIssuer" : "surrender";
+    if (isV6) {
+      await titleEscrowContract[staticCallFxn].staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic[staticCallFxn](...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for returnToIssuer failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.returnToIssuer(encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await titleEscrowContract.surrender(txOptions);
+  }
+}, "returnToIssuer");
+const rejectReturned = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { tokenId, remarks } = params;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v4SupportInterfaceIds.TradeTrustTokenRestorable,
+        signer.provider
+      ),
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v5SupportInterfaceIds.TradeTrustTokenRestorable,
+        signer.provider
+      )
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      v5Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      v4Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${encrypt(remarks, options.id)}` : "0x";
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [tokenId, encryptedRemarks] : [tokenId];
+    if (isV6) {
+      await tradeTrustTokenContract.restore.staticCall(...args);
+    } else {
+      await tradeTrustTokenContract.callStatic.restore(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for rejectReturned failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await tradeTrustTokenContract.restore(tokenId, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.restore(tokenId, txOptions);
+  }
+}, "rejectReturned");
+const acceptReturned = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, titleEscrowVersion } = options;
+  if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { tokenId, remarks } = params;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v4SupportInterfaceIds.TradeTrustTokenBurnable,
+        signer.provider
+      ),
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v5SupportInterfaceIds.TradeTrustTokenBurnable,
+        signer.provider
+      )
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      v5Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      v4Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${encrypt(remarks, options.id)}` : "0x";
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [encryptedRemarks] : [];
+    if (isV6) {
+      await tradeTrustTokenContract.burn.staticCall(...args);
+    } else {
+      await tradeTrustTokenContract.callStatic.burn(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for acceptReturned failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await tradeTrustTokenContract.burn(tokenId, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.burn(tokenId, txOptions);
+  }
+}, "acceptReturned");
+
+export { acceptReturned, rejectReturned, returnToIssuer };

package/dist/esm/token-registry-functions/transfer.js

@@ -0,0 +1,310 @@
+import { getTitleEscrowAddress, encrypt, isTitleEscrowVersion, TitleEscrowInterface } from '../core';
+import { v4Contracts } from '../token-registry-v4';
+import { v5Contracts } from '../token-registry-v5';
+import { getTxOptions } from './utils';
+import { getEthersContractFromProvider, isV6EthersProvider } from '../utils/ethers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const transferHolder = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress, tokenId } = contractOptions;
+  const { titleEscrowVersion } = options;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas } = options;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (!titleEscrowAddress) {
+    if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+    if (!tokenId) throw new Error("Token ID is required");
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      { titleEscrowVersion }
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { holderAddress, remarks } = params;
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [holderAddress, encryptedRemarks] : [holderAddress];
+    if (isV6) {
+      await titleEscrowContract.transferHolder.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.transferHolder(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for transferHolder failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.transferHolder(holderAddress, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await titleEscrowContract.transferHolder(holderAddress, txOptions);
+  }
+}, "transferHolder");
+const transferBeneficiary = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenId, tokenRegistryAddress } = contractOptions;
+  const { titleEscrowVersion } = options;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas } = options;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (!titleEscrowAddress) {
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      { titleEscrowVersion }
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { newBeneficiaryAddress, remarks } = params;
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [newBeneficiaryAddress, encryptedRemarks] : [newBeneficiaryAddress];
+    if (isV6) {
+      await titleEscrowContract.transferBeneficiary.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.transferBeneficiary(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for transferBeneficiary failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.transferBeneficiary(
+      newBeneficiaryAddress,
+      encryptedRemarks,
+      txOptions
+    );
+  } else if (isV4TT) {
+    return await titleEscrowContract.transferBeneficiary(newBeneficiaryAddress, txOptions);
+  }
+}, "transferBeneficiary");
+const transferOwners = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenId, tokenRegistryAddress } = contractOptions;
+  const { titleEscrowVersion } = options;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas } = options;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (!titleEscrowAddress) {
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      { titleEscrowVersion }
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { newBeneficiaryAddress, newHolderAddress, remarks } = params;
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [newBeneficiaryAddress, newHolderAddress, encryptedRemarks] : [newBeneficiaryAddress, newHolderAddress];
+    if (isV6) {
+      await titleEscrowContract.transferOwners.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.transferOwners(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for transferOwners failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.transferOwners(
+      newBeneficiaryAddress,
+      newHolderAddress,
+      encryptedRemarks,
+      txOptions
+    );
+  } else if (isV4TT) {
+    return await titleEscrowContract.transferOwners(
+      newBeneficiaryAddress,
+      newHolderAddress,
+      txOptions
+    );
+  }
+}, "transferOwners");
+const nominate = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenId, tokenRegistryAddress } = contractOptions;
+  const { titleEscrowVersion } = options;
+  let { titleEscrowAddress } = contractOptions;
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas } = options;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (!titleEscrowAddress) {
+    titleEscrowAddress = await getTitleEscrowAddress(
+      tokenRegistryAddress,
+      tokenId,
+      signer.provider,
+      { titleEscrowVersion }
+    );
+  }
+  if (!titleEscrowAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { newBeneficiaryAddress, remarks } = params;
+  const encryptedRemarks = remarks ? `0x${encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  const Contract = getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [newBeneficiaryAddress, encryptedRemarks] : [newBeneficiaryAddress];
+    if (isV6) {
+      await titleEscrowContract.nominate.staticCall(...args);
+    } else {
+      await titleEscrowContract.callStatic.nominate(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for nominate failed");
+  }
+  const txOptions = await getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.nominate(newBeneficiaryAddress, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await titleEscrowContract.nominate(newBeneficiaryAddress, txOptions);
+  }
+}, "nominate");
+
+export { nominate, transferBeneficiary, transferHolder, transferOwners };

package/dist/esm/token-registry-functions/types.js

@@ -0,0 +1 @@
+