@trustvc/trustvc 1.7.4 → 1.8.1

package/dist/cjs/core/endorsement-chain/useEndorsementChain.js

@@ -92,14 +92,12 @@ const getDocumentOwner = /* @__PURE__ */ __name(async (tokenRegistryAddress, tok
   const tokenRegistry = new Contract(tokenRegistryAddress, tokenRegistryAbi, provider);
   return await tokenRegistry.ownerOf(tokenId);
 }, "getDocumentOwner");
-const checkSupportsInterface = /* @__PURE__ */ __name(async (titleEscrowAddress, interfaceId, provider) => {
+const checkSupportsInterface = /* @__PURE__ */ __name(async (contractAddress, interfaceId, provider) => {
   try {
     const Contract = ethers.getEthersContractFromProvider(provider);
-    const titleEscrowAbi = [
-      "function supportsInterface(bytes4 interfaceId) external view returns (bool)"
-    ];
-    const titleEscrowContract = new Contract(titleEscrowAddress, titleEscrowAbi, provider);
-    return await titleEscrowContract.supportsInterface(interfaceId);
+    const abi = ["function supportsInterface(bytes4 interfaceId) external view returns (bool)"];
+    const contract = new Contract(contractAddress, abi, provider);
+    return await contract.supportsInterface(interfaceId);
   } catch {
     return false;
   }
@@ -165,6 +163,7 @@ const fetchEndorsementChain = /* @__PURE__ */ __name(async (tokenRegistryAddress
 }, "fetchEndorsementChain");
 
 exports.TitleEscrowInterface = TitleEscrowInterface;
+exports.checkSupportsInterface = checkSupportsInterface;
 exports.fetchEndorsementChain = fetchEndorsementChain;
 exports.getDocumentOwner = getDocumentOwner;
 exports.getTitleEscrowAddress = getTitleEscrowAddress;

package/dist/cjs/index.js

@@ -2,6 +2,7 @@
 
 var tokenRegistryV4 = require('./token-registry-v4');
 var tokenRegistryV5 = require('./token-registry-v5');
+var tokenRegistryFunctions = require('./token-registry-functions');
 var core = require('./core');
 var openAttestation = require('./open-attestation');
 var verify = require('./verify');
@@ -79,6 +80,12 @@ Object.defineProperty(exports, "v5Utils", {
   enumerable: true,
   get: function () { return tokenRegistryV5.v5Utils; }
 });
+Object.keys(tokenRegistryFunctions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return tokenRegistryFunctions[k]; }
+  });
+});
 Object.keys(core).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/dist/cjs/token-registry-functions/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var transfer = require('./transfer');
+var rejectTransfers = require('./rejectTransfers');
+var returnToken = require('./returnToken');
+var mint = require('./mint');
+var ownerOf = require('./ownerOf');
+
+
+
+Object.keys(transfer).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return transfer[k]; }
+	});
+});
+Object.keys(rejectTransfers).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return rejectTransfers[k]; }
+	});
+});
+Object.keys(returnToken).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return returnToken[k]; }
+	});
+});
+Object.keys(mint).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return mint[k]; }
+	});
+});
+Object.keys(ownerOf).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return ownerOf[k]; }
+	});
+});

package/dist/cjs/token-registry-functions/mint.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var core = require('../core');
+var tokenRegistryV5 = require('../token-registry-v5');
+var tokenRegistryV4 = require('../token-registry-v4');
+var utils = require('./utils');
+var ethers = require('../utils/ethers');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const mint = /* @__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 { beneficiaryAddress, holderAddress, tokenId, remarks } = params;
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV4.v4SupportInterfaceIds.TradeTrustTokenMintable,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV5.v5SupportInterfaceIds.TradeTrustTokenMintable,
+        signer.provider
+      )
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV5.v5Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV4.v4Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${core.encrypt(remarks, options.id ?? "")}` : "0x";
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [beneficiaryAddress, holderAddress, tokenId, encryptedRemarks] : [beneficiaryAddress, holderAddress, tokenId];
+    if (isV6) {
+      await tradeTrustTokenContract.mint.staticCall(...args);
+    } else {
+      await tradeTrustTokenContract.callStatic.mint(...args);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for mint failed");
+  }
+  const txOptions = await utils.getTxOptions(
+    signer,
+    chainId,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  );
+  if (isV5TT) {
+    return await tradeTrustTokenContract.mint(
+      beneficiaryAddress,
+      holderAddress,
+      tokenId,
+      encryptedRemarks,
+      txOptions
+    );
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.mint(
+      beneficiaryAddress,
+      holderAddress,
+      tokenId,
+      txOptions
+    );
+  }
+}, "mint");
+
+exports.mint = mint;

package/dist/cjs/token-registry-functions/ownerOf.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var core = require('../core');
+var tokenRegistryV5 = require('../token-registry-v5');
+var tokenRegistryV4 = require('../token-registry-v4');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ownerOf = /* @__PURE__ */ __name(async (contractOptions, signer, params, options) => {
+  const { tokenRegistryAddress } = contractOptions;
+  const { titleEscrowVersion } = options;
+  const { tokenId } = params;
+  if (!tokenRegistryAddress) throw new Error("Token registry address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.checkSupportsInterface(tokenRegistryAddress, tokenRegistryV4.v4SupportInterfaceIds.SBT, signer.provider),
+      core.checkSupportsInterface(tokenRegistryAddress, tokenRegistryV5.v5SupportInterfaceIds.SBT, signer.provider)
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = tokenRegistryV5.v5Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = tokenRegistryV4.v4Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  }
+  if (isV5TT) {
+    return await tradeTrustTokenContract.ownerOf(tokenId);
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.ownerOf(tokenId);
+  }
+}, "ownerOf");
+
+exports.ownerOf = ownerOf;

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

@@ -0,0 +1,166 @@
+'use strict';
+
+var core = require('./../core');
+var tokenRegistryV5 = require('./../token-registry-v5');
+var utils = require('./utils');
+var ethers = require('../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 core.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 = ethers.getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await core.isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: core.TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = ethers.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 utils.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 core.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 = ethers.getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await core.isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: core.TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = ethers.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 utils.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 core.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 = ethers.getEthersContractFromProvider(signer.provider);
+  const titleEscrowContract = new Contract(
+    titleEscrowAddress,
+    tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const encryptedRemarks = remarks ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  if (titleEscrowVersion === void 0) {
+    isV5TT = await core.isTitleEscrowVersion({
+      titleEscrowAddress,
+      versionInterface: core.TitleEscrowInterface.V5,
+      provider: signer.provider
+    });
+  }
+  if (!isV5TT) {
+    throw new Error("Only Token Registry V5 is supported");
+  }
+  try {
+    const isV6 = ethers.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 utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await titleEscrowContract.rejectTransferOwners(encryptedRemarks, txOptions);
+}, "rejectTransferOwners");
+
+exports.rejectTransferBeneficiary = rejectTransferBeneficiary;
+exports.rejectTransferHolder = rejectTransferHolder;
+exports.rejectTransferOwners = rejectTransferOwners;

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

@@ -0,0 +1,210 @@
+'use strict';
+
+var core = require('../core');
+var tokenRegistryV5 = require('../token-registry-v5');
+var tokenRegistryV4 = require('../token-registry-v4');
+var utils = require('./utils');
+var ethers = require('../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 core.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${core.encrypt(remarks, options.id)}` : "0x";
+  let isV5TT = titleEscrowVersion === "v5";
+  let isV4TT = titleEscrowVersion === "v4";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      await core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      await core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV5TT && !isV4TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let titleEscrowContract;
+  if (isV5TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      tokenRegistryV5.v5Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    titleEscrowContract = new Contract(
+      titleEscrowAddress,
+      tokenRegistryV4.v4Contracts.TitleEscrow__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  try {
+    const isV6 = ethers.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 utils.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([
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV4.v4SupportInterfaceIds.TradeTrustTokenRestorable,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV5.v5SupportInterfaceIds.TradeTrustTokenRestorable,
+        signer.provider
+      )
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV5.v5Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV4.v4Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  try {
+    const isV6 = ethers.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 utils.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([
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV4.v4SupportInterfaceIds.TradeTrustTokenBurnable,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        tokenRegistryAddress,
+        tokenRegistryV5.v5SupportInterfaceIds.TradeTrustTokenBurnable,
+        signer.provider
+      )
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV5.v5Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = new Contract(
+      tokenRegistryAddress,
+      tokenRegistryV4.v4Contracts.TradeTrustToken__factory.abi,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${core.encrypt(remarks, options.id)}` : "0x";
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    const args = isV5TT ? [tokenId, encryptedRemarks] : [tokenId];
+    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 utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await tradeTrustTokenContract.burn(tokenId, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.burn(tokenId, txOptions);
+  }
+}, "acceptReturned");
+
+exports.acceptReturned = acceptReturned;
+exports.rejectReturned = rejectReturned;
+exports.returnToIssuer = returnToIssuer;