@trustvc/trustvc 1.7.4 → 1.8.0

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

@@ -0,0 +1,315 @@
+'use strict';
+
+var core = require('../core');
+var tokenRegistryV4 = require('../token-registry-v4');
+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 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 core.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${core.encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    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 ? [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 utils.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 core.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${core.encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    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 ? [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 utils.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 core.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${core.encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    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 ? [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 utils.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 core.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${core.encrypt(remarks, options.id)}` : "0x";
+  if (titleEscrowVersion === void 0) {
+    [isV4TT, isV5TT] = await Promise.all([
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V4,
+        provider: signer.provider
+      }),
+      core.isTitleEscrowVersion({
+        titleEscrowAddress,
+        versionInterface: core.TitleEscrowInterface.V5,
+        provider: signer.provider
+      })
+    ]);
+  }
+  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 ? [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 utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  if (isV5TT) {
+    return await titleEscrowContract.nominate(newBeneficiaryAddress, encryptedRemarks, txOptions);
+  } else if (isV4TT) {
+    return await titleEscrowContract.nominate(newBeneficiaryAddress, txOptions);
+  }
+}, "nominate");
+
+exports.nominate = nominate;
+exports.transferBeneficiary = transferBeneficiary;
+exports.transferHolder = transferHolder;
+exports.transferOwners = transferOwners;

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

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,37 @@
+'use strict';
+
+var ethers = require('../utils/ethers');
+var tradetrustUtils = require('@tradetrust-tt/tradetrust-utils');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getTxOptions = /* @__PURE__ */ __name(async (signer, chainId, maxFeePerGas, maxPriorityFeePerGas) => {
+  if (!maxFeePerGas || !maxPriorityFeePerGas) {
+    chainId = chainId ?? await getChainIdSafe(signer);
+    const gasStation = tradetrustUtils.SUPPORTED_CHAINS[chainId]?.gasStation;
+    if (gasStation) {
+      const gasFees = await gasStation();
+      maxFeePerGas = gasFees?.maxFeePerGas ?? 0;
+      maxPriorityFeePerGas = gasFees?.maxPriorityFeePerGas ?? 0;
+    }
+  }
+  return maxFeePerGas && maxPriorityFeePerGas ? { maxFeePerGas, maxPriorityFeePerGas } : {};
+}, "getTxOptions");
+const getChainIdSafe = /* @__PURE__ */ __name(async (signer) => {
+  if (ethers.isV6EthersProvider(signer.provider)) {
+    const network = await signer.provider?.getNetwork();
+    if (!network?.chainId) throw new Error("Cannot determine chainId: provider is missing");
+    return network.chainId;
+  }
+  return await signer.getChainId();
+}, "getChainIdSafe");
+const getSignerAddressSafe = /* @__PURE__ */ __name(async (signer) => {
+  if (ethers.isV6EthersProvider(signer.provider)) {
+    return await signer.getAddress();
+  }
+  return await signer.getAddress();
+}, "getSignerAddressSafe");
+
+exports.getChainIdSafe = getChainIdSafe;
+exports.getSignerAddressSafe = getSignerAddressSafe;
+exports.getTxOptions = getTxOptions;

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

@@ -90,14 +90,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 = 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;
   }
@@ -162,4 +160,4 @@ const fetchEndorsementChain = /* @__PURE__ */ __name(async (tokenRegistryAddress
   }));
 }, "fetchEndorsementChain");
 
-export { TitleEscrowInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion };
+export { TitleEscrowInterface, checkSupportsInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion };

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 export { v4ComputeInterfaceId, v4ComputeTitleEscrowAddress, v4ContractAddress, v4Contracts, v4EncodeInitParams, v4GetEventFromReceipt, v4RoleHash, v4SupportInterfaceIds, v4Utils } from './token-registry-v4';
 export { v5ComputeInterfaceId, v5ContractAddress, v5Contracts, v5EncodeInitParams, v5GetEventFromReceipt, v5RoleHash, v5SupportInterfaceIds, v5Utils } from './token-registry-v5';
+export * from './token-registry-functions';
 export * from './core';
 export * from './open-attestation';
 export * from './verify';

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

@@ -0,0 +1,5 @@
+export * from './transfer';
+export * from './rejectTransfers';
+export * from './returnToken';
+export * from './mint';
+export * from './ownerOf';

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

@@ -0,0 +1,88 @@
+import { checkSupportsInterface, encrypt } from '../core';
+import { v5SupportInterfaceIds, v5Contracts } from '../token-registry-v5';
+import { v4SupportInterfaceIds, v4Contracts } 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 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([
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v4SupportInterfaceIds.TradeTrustTokenMintable,
+        signer.provider
+      ),
+      checkSupportsInterface(
+        tokenRegistryAddress,
+        v5SupportInterfaceIds.TradeTrustTokenMintable,
+        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 ? [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 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");
+
+export { mint };

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

@@ -0,0 +1,43 @@
+import { checkSupportsInterface } from '../core';
+import { v5SupportInterfaceIds, v5Contracts } from '../token-registry-v5';
+import { v4SupportInterfaceIds, v4Contracts } from '../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([
+      checkSupportsInterface(tokenRegistryAddress, v4SupportInterfaceIds.SBT, signer.provider),
+      checkSupportsInterface(tokenRegistryAddress, v5SupportInterfaceIds.SBT, signer.provider)
+    ]);
+  }
+  if (!isV4TT && !isV5TT) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = v5Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = v4Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  }
+  if (isV5TT) {
+    return await tradeTrustTokenContract.ownerOf(tokenId);
+  } else if (isV4TT) {
+    return await tradeTrustTokenContract.ownerOf(tokenId);
+  }
+}, "ownerOf");
+
+export { ownerOf };