@trustvc/trustvc 1.5.5 → 1.6.0-alpha.2

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

@@ -0,0 +1,200 @@
+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';
+
+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;
+  let titleEscrowContract = v5Contracts.TitleEscrow__factory.connect(titleEscrowAddress, signer);
+  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");
+  }
+  if (isV4TT) {
+    titleEscrowContract = v4Contracts.TitleEscrow__factory.connect(
+      titleEscrowAddress,
+      signer
+    );
+  }
+  try {
+    if (isV5TT) {
+      await titleEscrowContract.callStatic.returnToIssuer(
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await titleEscrowContract.callStatic.surrender();
+    }
+  } 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");
+  }
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = v5Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = v4Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${encrypt(remarks, options.id)}` : "0x";
+  try {
+    if (isV5TT) {
+      await tradeTrustTokenContract.callStatic.restore(
+        tokenId,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await tradeTrustTokenContract.callStatic.restore(tokenId);
+    }
+  } 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");
+  }
+  let tradeTrustTokenContract;
+  if (isV5TT) {
+    tradeTrustTokenContract = v5Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  } else if (isV4TT) {
+    tradeTrustTokenContract = v4Contracts.TradeTrustToken__factory.connect(
+      tokenRegistryAddress,
+      signer
+    );
+  }
+  const encryptedRemarks = remarks && isV5TT ? `0x${encrypt(remarks, options.id)}` : "0x";
+  try {
+    if (isV5TT) {
+      await tradeTrustTokenContract.callStatic.burn(
+        tokenId,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await tradeTrustTokenContract.callStatic.burn(tokenId);
+    }
+  } 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,300 @@
+import { getTitleEscrowAddress, encrypt, isTitleEscrowVersion, TitleEscrowInterface } from '../core';
+import { v4Contracts } from '../token-registry-v4';
+import { v5Contracts } from '../token-registry-v5';
+import { getTxOptions } from './utils';
+
+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) {
+    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;
+  let titleEscrowContract = v5Contracts.TitleEscrow__factory.connect(titleEscrowAddress, signer);
+  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");
+  }
+  if (isV4TT) {
+    titleEscrowContract = v4Contracts.TitleEscrow__factory.connect(
+      titleEscrowAddress,
+      signer
+    );
+  }
+  try {
+    if (isV5TT) {
+      await titleEscrowContract.callStatic.transferHolder(
+        holderAddress,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await titleEscrowContract.callStatic.transferHolder(
+        holderAddress
+      );
+    }
+  } 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;
+  let titleEscrowContract = v5Contracts.TitleEscrow__factory.connect(titleEscrowAddress, signer);
+  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");
+  }
+  if (!isV5TT) {
+    titleEscrowContract = v4Contracts.TitleEscrow__factory.connect(
+      titleEscrowAddress,
+      signer
+    );
+  }
+  try {
+    if (isV5TT) {
+      await titleEscrowContract.callStatic.transferBeneficiary(
+        newBeneficiaryAddress,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await titleEscrowContract.callStatic.transferBeneficiary(
+        newBeneficiaryAddress
+      );
+    }
+  } 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) {
+    const tx = await titleEscrowContract.transferBeneficiary(
+      newBeneficiaryAddress,
+      encryptedRemarks,
+      txOptions
+    );
+    return tx;
+  } else if (isV4TT) {
+    const tx = await titleEscrowContract.transferBeneficiary(
+      newBeneficiaryAddress,
+      txOptions
+    );
+    return tx;
+  }
+}, "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;
+  let titleEscrowContract = v5Contracts.TitleEscrow__factory.connect(titleEscrowAddress, signer);
+  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");
+  }
+  if (!isV5TT) {
+    titleEscrowContract = v4Contracts.TitleEscrow__factory.connect(
+      titleEscrowAddress,
+      signer
+    );
+  }
+  try {
+    if (isV5TT) {
+      await titleEscrowContract.callStatic.transferOwners(
+        newBeneficiaryAddress,
+        newHolderAddress,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await titleEscrowContract.callStatic.transferOwners(
+        newBeneficiaryAddress,
+        newHolderAddress
+      );
+    }
+  } 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;
+  let titleEscrowContract = v5Contracts.TitleEscrow__factory.connect(titleEscrowAddress, signer);
+  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 (!isV5TT) {
+    titleEscrowContract = v4Contracts.TitleEscrow__factory.connect(
+      titleEscrowAddress,
+      signer
+    );
+  }
+  try {
+    if (isV5TT) {
+      await titleEscrowContract.callStatic.nominate(
+        newBeneficiaryAddress,
+        encryptedRemarks
+      );
+    } else if (isV4TT) {
+      await titleEscrowContract.callStatic.nominate(
+        newBeneficiaryAddress
+      );
+    }
+  } 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 @@
+

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

@@ -0,0 +1,33 @@
+import { isV6EthersProvider } from '../utils/ethers';
+import { SUPPORTED_CHAINS } from '@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 = SUPPORTED_CHAINS[chainId]?.gasStation;
+    if (gasStation) {
+      const gasFees = await gasStation();
+      maxFeePerGas = gasFees?.maxFeePerGas ?? 0;
+      maxPriorityFeePerGas = gasFees?.maxPriorityFeePerGas ?? 0;
+    }
+  }
+  return maxFeePerGas && maxPriorityFeePerGas ? { maxFeePerGas, maxPriorityFeePerGas } : void 0;
+}, "getTxOptions");
+const getChainIdSafe = /* @__PURE__ */ __name(async (signer) => {
+  if (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 (isV6EthersProvider(signer.provider)) {
+    return await signer.getAddress();
+  }
+  return await signer.getAddress();
+}, "getSignerAddressSafe");
+
+export { getChainIdSafe, getSignerAddressSafe, getTxOptions };

package/dist/types/core/endorsement-chain/index.d.ts

@@ -3,7 +3,7 @@ export { fetchTokenTransfers } from './fetchTokenTransfer.js';
 export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain } from './helpers.js';
 export { getEndorsementChain } from './retrieveEndorsementChain.js';
 export { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent } from './types.js';
-export { TitleEscrowInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './useEndorsementChain.js';
+export { TitleEscrowInterface, checkSupportsInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './useEndorsementChain.js';
 import 'ethersV6';
 import '@ethersproject/abstract-provider';
 import 'ethers';

package/dist/types/core/endorsement-chain/useEndorsementChain.d.ts

@@ -12,6 +12,7 @@ declare const getTitleEscrowAddress: (tokenRegistryAddress: string, tokenId: str
     titleEscrowVersion?: "v4" | "v5";
 }) => Promise<string>;
 declare const getDocumentOwner: (tokenRegistryAddress: string, tokenId: string, provider: Provider | ethers.Provider) => Promise<string>;
+declare const checkSupportsInterface: (contractAddress: string, interfaceId: string, provider: Provider | ethers.Provider) => Promise<boolean>;
 interface TitleEscrowVersionParams {
     tokenRegistryAddress?: string;
     tokenId?: string;
@@ -27,4 +28,4 @@ interface TitleEscrowVersionParams {
 declare const isTitleEscrowVersion: ({ tokenRegistryAddress, tokenId, titleEscrowAddress, versionInterface, provider, }: TitleEscrowVersionParams) => Promise<boolean>;
 declare const fetchEndorsementChain: (tokenRegistryAddress: string, tokenId: string, provider: Provider | ethers.Provider, keyId?: string) => Promise<EndorsementChain>;
 
-export { TitleEscrowInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion };
+export { TitleEscrowInterface, checkSupportsInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion };

package/dist/types/core/index.d.ts

@@ -6,7 +6,7 @@ export { fetchTokenTransfers } from './endorsement-chain/fetchTokenTransfer.js';
 export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain } from './endorsement-chain/helpers.js';
 export { getEndorsementChain } from './endorsement-chain/retrieveEndorsementChain.js';
 export { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent } from './endorsement-chain/types.js';
-export { TitleEscrowInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './endorsement-chain/useEndorsementChain.js';
+export { TitleEscrowInterface, checkSupportsInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './endorsement-chain/useEndorsementChain.js';
 export { DocumentBuilder, RenderMethod, W3CTransferableRecordsConfig, W3CVerifiableDocumentConfig, qrCode } from './documentBuilder.js';
 import '@trustvc/w3c-vc';
 import 'ethers';

package/dist/types/index.d.ts

@@ -10,6 +10,11 @@ export { supportInterfaceIds as v5SupportInterfaceIds } from './token-registry-v
 export { c as v5Contracts } from './contracts-BaIGKzNt.js';
 export { computeInterfaceId as v5ComputeInterfaceId, encodeInitParams as v5EncodeInitParams, getEventFromReceipt as v5GetEventFromReceipt } from './token-registry-v5/utils.js';
 export { TypedContractMethod } from '@tradetrust-tt/token-registry-v5/contracts/common';
+export { nominate, transferBeneficiary, transferHolder, transferOwners } from './token-registry-functions/transfer.js';
+export { rejectTransferBeneficiary, rejectTransferHolder, rejectTransferOwners } from './token-registry-functions/rejectTransfers.js';
+export { acceptReturned, rejectReturned, returnToIssuer } from './token-registry-functions/returnToken.js';
+export { mint } from './token-registry-functions/mint.js';
+export { ownerOf } from './token-registry-functions/ownerOf.js';
 export { decrypt } from './core/decrypt.js';
 export { encrypt } from './core/encrypt.js';
 export { verifyDocument } from './core/verify.js';
@@ -18,7 +23,7 @@ export { fetchTokenTransfers } from './core/endorsement-chain/fetchTokenTransfer
 export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain } from './core/endorsement-chain/helpers.js';
 export { getEndorsementChain } from './core/endorsement-chain/retrieveEndorsementChain.js';
 export { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent } from './core/endorsement-chain/types.js';
-export { TitleEscrowInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './core/endorsement-chain/useEndorsementChain.js';
+export { TitleEscrowInterface, checkSupportsInterface, fetchEndorsementChain, getDocumentOwner, getTitleEscrowAddress, isTitleEscrowVersion } from './core/endorsement-chain/useEndorsementChain.js';
 export { DocumentBuilder, RenderMethod, W3CTransferableRecordsConfig, W3CVerifiableDocumentConfig, qrCode } from './core/documentBuilder.js';
 export { signOA } from './open-attestation/sign.js';
 export { KeyPair } from './open-attestation/types.js';
@@ -53,6 +58,7 @@ import '@typechain/ethers-v5/static/common';
 import '@tradetrust-tt/token-registry-v5/contracts';
 import '@tradetrust-tt/token-registry-v5';
 import 'ethersV6';
+import './token-registry-functions/types.js';
 import '@ethersproject/abstract-provider';
 import 'ethers/lib/utils';
 import '@ethersproject/abstract-signer';

package/dist/types/token-registry-functions/index.d.ts

@@ -0,0 +1,9 @@
+export { nominate, transferBeneficiary, transferHolder, transferOwners } from './transfer.js';
+export { rejectTransferBeneficiary, rejectTransferHolder, rejectTransferOwners } from './rejectTransfers.js';
+export { acceptReturned, rejectReturned, returnToIssuer } from './returnToken.js';
+export { mint } from './mint.js';
+export { ownerOf } from './ownerOf.js';
+import 'ethersV6';
+import 'ethers';
+import './types.js';
+import '@tradetrust-tt/tradetrust-utils';

package/dist/types/token-registry-functions/mint.d.ts

@@ -0,0 +1,20 @@
+import { Signer as Signer$1 } from 'ethersV6';
+import { Signer, ContractTransaction } from 'ethers';
+import { MintTokenOptions, MintTokenParams, TransactionOptions } from './types.js';
+import '@tradetrust-tt/tradetrust-utils';
+
+/**
+ * Mints a new token into the TradeTrustToken registry with the specified beneficiary and holder.
+ * Supports both Token Registry V4 and V5 contracts.
+ * @param {MintTokenOptions} contractOptions - Contains the `tokenRegistryAddress` for the minting contract.
+ * @param {Signer | SignerV6} signer - Signer instance (Ethers v5 or v6) that authorizes the mint transaction.
+ * @param {MintTokenParams} params - Parameters for minting, including `beneficiaryAddress`, `holderAddress`, `tokenId`, and optional `remarks`.
+ * @param {TransactionOptions} options - Transaction metadata including gas values, version detection, chain ID, and optional encryption ID.
+ * @returns {Promise<ContractTransaction>} A promise resolving to the transaction result from the mint call.
+ * @throws {Error} If the token registry address or signer provider is not provided.
+ * @throws {Error} If neither V4 nor V5 interfaces are supported.
+ * @throws {Error} If the `callStatic.mint` fails as a pre-check.
+ */
+declare const mint: (contractOptions: MintTokenOptions, signer: Signer | Signer$1, params: MintTokenParams, options: TransactionOptions) => Promise<ContractTransaction>;
+
+export { mint };

package/dist/types/token-registry-functions/ownerOf.d.ts

@@ -0,0 +1,19 @@
+import { Signer as Signer$1 } from 'ethersV6';
+import { Signer } from 'ethers';
+import { OwnerOfTokenOptions, OwnerOfTokenParams, TransactionOptions } from './types.js';
+import '@tradetrust-tt/tradetrust-utils';
+
+/**
+ * Retrieves the owner of a given token from the TradeTrustToken contract.
+ * Supports both Token Registry V4 and V5 implementations.
+ * @param {OwnerOfTokenOptions} contractOptions - Options containing the token registry address.
+ * @param {Signer | SignerV6} signer - Signer instance (v5 or v6) used to query the blockchain.
+ * @param {OwnerOfTokenParams} params - Contains the `tokenId` of the token to query ownership for.
+ * @param {TransactionOptions} options - Includes the `titleEscrowVersion` and other optional metadata for interface detection.
+ * @returns {Promise<string>} A promise that resolves to the owner address of the specified token.
+ * @throws {Error} If token registry address or signer provider is not provided.
+ * @throws {Error} If the token registry does not support V4 or V5 interfaces.
+ */
+declare const ownerOf: (contractOptions: OwnerOfTokenOptions, signer: Signer | Signer$1, params: OwnerOfTokenParams, options: TransactionOptions) => Promise<string>;
+
+export { ownerOf };