@trustvc/trustvc 1.0.4 → 1.1.0

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

@@ -0,0 +1,103 @@
+'use strict';
+
+var ethers = require('ethers');
+var decrypt = require('../decrypt');
+var fetchEscrowTransfer = require('../endorsement-chain/fetchEscrowTransfer');
+var fetchTokenTransfer = require('../endorsement-chain/fetchTokenTransfer');
+var helpers = require('../endorsement-chain/helpers');
+var retrieveEndorsementChain = require('../endorsement-chain/retrieveEndorsementChain');
+var contracts = require('../../token-registry-v4/contracts');
+var supportInterfaceIds = require('../../token-registry-v4/supportInterfaceIds');
+var supportInterfaceIds$1 = require('../../token-registry-v5/supportInterfaceIds');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const TitleEscrowInterface = {
+  V4: supportInterfaceIds.supportInterfaceIds.TitleEscrow,
+  V5: supportInterfaceIds$1.supportInterfaceIds.TitleEscrow
+};
+const fetchTitleEscrowFactoryAddress = /* @__PURE__ */ __name(async (tokenRegistry) => {
+  return tokenRegistry.titleEscrowFactory();
+}, "fetchTitleEscrowFactoryAddress");
+const resolveTitleEscrowAddress = /* @__PURE__ */ __name(async (titleEscrowFactoryContract, tokenRegistryAddress, tokenId) => {
+  try {
+    return await titleEscrowFactoryContract.getEscrowAddress(tokenRegistryAddress, tokenId);
+  } catch {
+    return titleEscrowFactoryContract.getAddress(tokenRegistryAddress, tokenId);
+  }
+}, "resolveTitleEscrowAddress");
+const getTitleEscrowAddress = /* @__PURE__ */ __name(async (tokenRegistryAddress, tokenId, provider) => {
+  const tokenRegistryAbi = [
+    "function titleEscrowFactory() external view returns (address)",
+    "function ownerOf(uint256 tokenId) view returns (address)"
+  ];
+  const tokenRegistry = new ethers.ethers.Contract(tokenRegistryAddress, tokenRegistryAbi, provider);
+  const titleEscrowOwner = await tokenRegistry.ownerOf(tokenId);
+  const BURN_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+  const isInactiveEscrow = [BURN_ADDRESS, tokenRegistryAddress].map((address) => address.toLowerCase()).includes(titleEscrowOwner.toLowerCase());
+  if (!isInactiveEscrow) return titleEscrowOwner;
+  const titleEscrowFactoryAddress = await fetchTitleEscrowFactoryAddress(tokenRegistry);
+  const titleEscrowFactoryContract = new ethers.ethers.Contract(
+    titleEscrowFactoryAddress,
+    [
+      "function getAddress(address, uint256) view returns (address)",
+      "function getEscrowAddress(address, uint256) view returns (address)"
+    ],
+    provider
+  );
+  return resolveTitleEscrowAddress(titleEscrowFactoryContract, tokenRegistryAddress, tokenId);
+}, "getTitleEscrowAddress");
+const checkSupportsInterface = /* @__PURE__ */ __name(async (titleEscrowAddress, interfaceId, provider) => {
+  try {
+    const titleEscrowAbi = [
+      "function supportsInterface(bytes4 interfaceId) external view returns (bool)"
+    ];
+    const titleEscrowContract = new ethers.ethers.Contract(titleEscrowAddress, titleEscrowAbi, provider);
+    return await titleEscrowContract.supportsInterface(interfaceId);
+  } catch {
+    return false;
+  }
+}, "checkSupportsInterface");
+const isTitleEscrowVersion = /* @__PURE__ */ __name(async (versionInterface, tokenRegistryAddress, tokenId, provider) => {
+  try {
+    const titleEscrowAddress = await getTitleEscrowAddress(tokenRegistryAddress, tokenId, provider);
+    return await checkSupportsInterface(titleEscrowAddress, versionInterface, provider);
+  } catch {
+    return false;
+  }
+}, "isTitleEscrowVersion");
+const fetchEndorsementChain = /* @__PURE__ */ __name(async (tokenRegistry, tokenId, provider, keyId) => {
+  if (!tokenRegistry || !tokenId || !provider) {
+    throw new Error("Missing required dependencies");
+  }
+  const [isV4, isV5] = await Promise.all([
+    isTitleEscrowVersion(TitleEscrowInterface.V4, tokenRegistry, tokenId, provider),
+    isTitleEscrowVersion(TitleEscrowInterface.V5, tokenRegistry, tokenId, provider)
+  ]);
+  if (!isV4 && !isV5) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const titleEscrowAddress = await getTitleEscrowAddress(tokenRegistry, tokenId, provider);
+  let transferEvents = [];
+  if (isV4) {
+    const tokenRegistryContract = contracts.TradeTrustToken__factory.connect(tokenRegistry, provider);
+    const [tokenLogs, titleEscrowLogs] = await Promise.all([
+      fetchTokenTransfer.fetchTokenTransfers(tokenRegistryContract, tokenId),
+      fetchEscrowTransfer.fetchEscrowTransfersV4(provider, titleEscrowAddress)
+    ]);
+    transferEvents = helpers.mergeTransfersV4([...titleEscrowLogs, ...tokenLogs]);
+  } else if (isV5) {
+    const titleEscrowLogs = await fetchEscrowTransfer.fetchEscrowTransfersV5(provider, titleEscrowAddress);
+    transferEvents = helpers.mergeTransfersV5(titleEscrowLogs);
+  }
+  const endorsementChain = await retrieveEndorsementChain.getEndorsementChain(provider, transferEvents);
+  return isV4 ? endorsementChain : endorsementChain.map((event) => ({
+    ...event,
+    remark: event?.remark?.slice(2) ? decrypt.decrypt(event.remark.slice(2), keyId ?? "") : ""
+  }));
+}, "fetchEndorsementChain");
+
+exports.TitleEscrowInterface = TitleEscrowInterface;
+exports.fetchEndorsementChain = fetchEndorsementChain;
+exports.getTitleEscrowAddress = getTitleEscrowAddress;
+exports.isTitleEscrowVersion = isTitleEscrowVersion;

package/dist/core/index.d.mts

@@ -1,5 +1,16 @@
 export { decrypt } from './decrypt.mjs';
 export { encrypt } from './encrypt.mjs';
 export { verifyDocument } from './verify.mjs';
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 } from './endorsement-chain/fetchEscrowTransfer.mjs';
+export { fetchTokenTransfers } from './endorsement-chain/fetchTokenTransfer.mjs';
+export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain } from './endorsement-chain/helpers.mjs';
+export { getEndorsementChain } from './endorsement-chain/retrieveEndorsementChain.mjs';
+export { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent } from './endorsement-chain/types.mjs';
+export { TitleEscrowInterface, fetchEndorsementChain, getTitleEscrowAddress, isTitleEscrowVersion } from './endorsement-chain/useEndorsementChain.mjs';
 import '@trustvc/w3c-vc';
 import '@tradetrust-tt/tt-verify/dist/types/src/types/core';
+import 'ethers';
+import '@tradetrust-tt/token-registry-v4/contracts';
+import '@ethersproject/abstract-provider';
+import 'ethers/lib/utils';
+import '@ethersproject/providers';

package/dist/core/index.d.ts

@@ -1,5 +1,16 @@
 export { decrypt } from './decrypt.js';
 export { encrypt } from './encrypt.js';
 export { verifyDocument } from './verify.js';
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 } from './endorsement-chain/fetchEscrowTransfer.js';
+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, getTitleEscrowAddress, isTitleEscrowVersion } from './endorsement-chain/useEndorsementChain.js';
 import '@trustvc/w3c-vc';
 import '@tradetrust-tt/tt-verify/dist/types/src/types/core';
+import 'ethers';
+import '@tradetrust-tt/token-registry-v4/contracts';
+import '@ethersproject/abstract-provider';
+import 'ethers/lib/utils';
+import '@ethersproject/providers';

package/dist/core/index.js

@@ -3,6 +3,7 @@
 var decrypt = require('./decrypt');
 var encrypt = require('./encrypt');
 var verify = require('./verify');
+var endorsementChain = require('./endorsement-chain');
 
 
 
@@ -24,3 +25,9 @@ Object.keys(verify).forEach(function (k) {
 		get: function () { return verify[k]; }
 	});
 });
+Object.keys(endorsementChain).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return endorsementChain[k]; }
+	});
+});

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

@@ -0,0 +1,164 @@
+import { TitleEscrow__factory } from '../../token-registry-v4/contracts';
+import { TitleEscrow__factory as TitleEscrow__factory$1 } from '../../token-registry-v5/contracts';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fetchEscrowTransfersV4 = /* @__PURE__ */ __name(async (provider, address) => {
+  const titleEscrowContract = TitleEscrow__factory.connect(address, provider);
+  const holderChangeLogsDeferred = await fetchHolderTransfers(titleEscrowContract, provider);
+  const ownerChangeLogsDeferred = await fetchOwnerTransfers(titleEscrowContract, provider);
+  const [holderChangeLogs, ownerChangeLogs] = await Promise.all([
+    holderChangeLogsDeferred,
+    ownerChangeLogsDeferred
+  ]);
+  return [...holderChangeLogs, ...ownerChangeLogs];
+}, "fetchEscrowTransfersV4");
+const fetchEscrowTransfersV5 = /* @__PURE__ */ __name(async (provider, address) => {
+  const titleEscrowContract = TitleEscrow__factory$1.connect(address, provider);
+  const holderChangeLogsDeferred = await fetchAllTransfers(titleEscrowContract);
+  return holderChangeLogsDeferred;
+}, "fetchEscrowTransfersV5");
+const getParsedLogs = /* @__PURE__ */ __name((logs, titleEscrow) => {
+  return logs.map((log) => {
+    if (!log.blockNumber) throw new Error("Block number not present");
+    return {
+      ...log,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...titleEscrow.interface.parseLog(log)
+    };
+  });
+}, "getParsedLogs");
+const fetchOwnerTransfers = /* @__PURE__ */ __name(async (titleEscrowContract, provider) => {
+  const ownerChangeFilter = titleEscrowContract.filters.BeneficiaryTransfer(null, null);
+  const ownerChangeLogs = await provider.getLogs({ ...ownerChangeFilter, fromBlock: 0 });
+  const ownerChangeLogsParsed = getParsedLogs(ownerChangeLogs, titleEscrowContract);
+  return ownerChangeLogsParsed.map((event) => ({
+    type: "TRANSFER_BENEFICIARY",
+    owner: event.args.toBeneficiary,
+    blockNumber: event.blockNumber,
+    transactionHash: event.transactionHash,
+    transactionIndex: event.transactionIndex
+  }));
+}, "fetchOwnerTransfers");
+const fetchHolderTransfers = /* @__PURE__ */ __name(async (titleEscrowContract, provider) => {
+  const holderChangeFilter = titleEscrowContract.filters.HolderTransfer(null, null);
+  const holderChangeLogs = await provider.getLogs({ ...holderChangeFilter, fromBlock: 0 });
+  const holderChangeLogsParsed = getParsedLogs(holderChangeLogs, titleEscrowContract);
+  return holderChangeLogsParsed.map((event) => ({
+    type: "TRANSFER_HOLDER",
+    blockNumber: event.blockNumber,
+    holder: event.args.toHolder,
+    transactionHash: event.transactionHash,
+    transactionIndex: event.transactionIndex
+  }));
+}, "fetchHolderTransfers");
+const fetchAllTransfers = /* @__PURE__ */ __name(async (titleEscrowContract) => {
+  const allFilters = [
+    titleEscrowContract.filters.HolderTransfer,
+    titleEscrowContract.filters.BeneficiaryTransfer,
+    titleEscrowContract.filters.TokenReceived,
+    titleEscrowContract.filters.ReturnToIssuer,
+    // titleEscrowContract.filters.Nomination,
+    titleEscrowContract.filters.RejectTransferOwners,
+    titleEscrowContract.filters.RejectTransferBeneficiary,
+    titleEscrowContract.filters.RejectTransferHolder,
+    titleEscrowContract.filters.Shred
+  ];
+  const allLogs = await Promise.all(
+    allFilters.map(async (filter) => {
+      const logs = await titleEscrowContract.queryFilter(filter, 0, "latest");
+      return logs;
+    })
+  );
+  const holderChangeLogsParsed = getParsedLogs(allLogs.flat(), titleEscrowContract);
+  const tokenRegistryAddress = await titleEscrowContract.registry();
+  return holderChangeLogsParsed.map((event) => {
+    if (event?.name === "HolderTransfer") {
+      return {
+        type: "TRANSFER_HOLDER",
+        blockNumber: event.blockNumber,
+        holder: event.args.toHolder,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "BeneficiaryTransfer") {
+      return {
+        type: "TRANSFER_BENEFICIARY",
+        owner: event.args.toBeneficiary,
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "TokenReceived") {
+      const type = identifyTokenReceivedType(event);
+      return {
+        type,
+        from: type === "INITIAL" ? "0x0000000000000000000000000000000000000000" : tokenRegistryAddress,
+        to: titleEscrowContract.address,
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "ReturnToIssuer") {
+      return {
+        type: "RETURNED_TO_ISSUER",
+        blockNumber: event.blockNumber,
+        from: titleEscrowContract.address,
+        to: tokenRegistryAddress,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "Nomination") {
+      return void 0;
+    } else if (event?.name === "RejectTransferOwners") {
+      return {
+        type: "REJECT_TRANSFER_OWNERS",
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "RejectTransferBeneficiary") {
+      return {
+        type: "REJECT_TRANSFER_BENEFICIARY",
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "RejectTransferHolder") {
+      return {
+        type: "REJECT_TRANSFER_HOLDER",
+        blockNumber: event.blockNumber,
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    } else if (event?.name === "Shred") {
+      return {
+        type: "RETURN_TO_ISSUER_ACCEPTED",
+        blockNumber: event.blockNumber,
+        from: tokenRegistryAddress,
+        to: "0x00000000000000000000000000000000000dead",
+        transactionHash: event.transactionHash,
+        transactionIndex: event.transactionIndex,
+        remark: event.args?.remark
+      };
+    }
+    return void 0;
+  }).filter((event) => event !== void 0);
+}, "fetchAllTransfers");
+function identifyTokenReceivedType(event) {
+  if (event.args.isMinting) {
+    return "INITIAL";
+  } else {
+    return "RETURN_TO_ISSUER_REJECTED";
+  }
+}
+__name(identifyTokenReceivedType, "identifyTokenReceivedType");
+
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 };

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

@@ -0,0 +1,56 @@
+import { sortLogChain } from '../endorsement-chain/helpers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fetchTokenTransfers = /* @__PURE__ */ __name(async (tokenRegistry, tokenId) => {
+  const logs = await fetchLogs(tokenRegistry, tokenId);
+  const parsedLogs = parseLogs(logs, tokenRegistry);
+  const tokenRegistryAddress = tokenRegistry.address;
+  const reformattedLogs = parsedLogs.map(
+    (event) => formatTokenTransferEvent(event, tokenRegistryAddress)
+  );
+  sortLogChain(reformattedLogs);
+  return reformattedLogs;
+}, "fetchTokenTransfers");
+const fetchLogs = /* @__PURE__ */ __name(async (tokenRegistry, tokenId) => {
+  const transferLogFilter = tokenRegistry.filters.Transfer(null, null, tokenId);
+  const logs = await tokenRegistry.queryFilter(transferLogFilter, 0);
+  if (logs.length === 0) {
+    throw new Error("Unminted Title Escrow");
+  }
+  return logs;
+}, "fetchLogs");
+const parseLogs = /* @__PURE__ */ __name((logs, tokenRegistry) => {
+  return logs.map((log) => {
+    if (!log.args) throw new Error(`Transfer log malformed: ${log}`);
+    if (!log.blockNumber) throw new Error("Block number not present");
+    if (!log.transactionHash) throw new Error("Transaction hash not present");
+    return {
+      ...log,
+      ...tokenRegistry.interface.parseLog(log)
+    };
+  });
+}, "parseLogs");
+const formatTokenTransferEvent = /* @__PURE__ */ __name((event, tokenRegistryAddress) => {
+  const type = identifyTokenTransferEvent(event, tokenRegistryAddress);
+  return {
+    type,
+    from: event.args.from,
+    to: event.args.to,
+    blockNumber: event.blockNumber,
+    transactionHash: event.transactionHash,
+    transactionIndex: event.transactionIndex
+  };
+}, "formatTokenTransferEvent");
+const identifyTokenTransferEvent = /* @__PURE__ */ __name((log, tokenRegistryAddress) => {
+  const InitialAddress = "0x0000000000000000000000000000000000000000";
+  const BurnAddress = "0x000000000000000000000000000000000000dEaD";
+  const { from, to } = log.args;
+  if (to === tokenRegistryAddress) return "SURRENDERED";
+  if (to === BurnAddress) return "SURRENDER_ACCEPTED";
+  if (from === tokenRegistryAddress) return "SURRENDER_REJECTED";
+  if (from === InitialAddress) return "INITIAL";
+  throw new Error("Unidentified transfer event");
+}, "identifyTokenTransferEvent");
+
+export { fetchTokenTransfers };

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

@@ -0,0 +1,94 @@
+import { groupBy } from 'lodash';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fetchEventTime = /* @__PURE__ */ __name(async (blockNumber, provider) => {
+  const msecToSec = 1e3;
+  const eventTimestamp = (await provider.getBlock(blockNumber)).timestamp * msecToSec;
+  return eventTimestamp;
+}, "fetchEventTime");
+const getHolderOwner = /* @__PURE__ */ __name((events) => {
+  let owner = "";
+  let holder = "";
+  for (const event of events) {
+    owner = event.owner || owner;
+    holder = event.holder || holder;
+  }
+  return { owner, holder };
+}, "getHolderOwner");
+const mergeTransfersV4 = /* @__PURE__ */ __name((transferEvents) => {
+  const groupedEventsDict = groupBy(
+    transferEvents,
+    "transactionHash"
+  );
+  const transactionHashValues = Object.values(groupedEventsDict);
+  const mergedTransaction = transactionHashValues.flatMap((groupedEvents) => {
+    if (groupedEvents.length === 1) return groupedEvents;
+    if (groupedEvents.length === 2) {
+      const type = "TRANSFER_OWNERS";
+      const base = groupedEvents[0];
+      const { owner, holder } = getHolderOwner(groupedEvents);
+      return [{ ...base, type, owner, holder }];
+    }
+    if (groupedEvents.length === 3) {
+      const base = groupedEvents[0];
+      const type = "INITIAL";
+      const { owner, holder } = getHolderOwner(groupedEvents);
+      const found = groupedEvents.find((x) => {
+        return x.type === "INITIAL" || x.type === "SURRENDER_ACCEPTED";
+      });
+      return [{ ...base, owner, holder, type: found?.type || type }];
+    }
+    throw new Error("Invalid hash, update your configuration");
+  });
+  return mergedTransaction;
+}, "mergeTransfersV4");
+const mergeTransfersV5 = /* @__PURE__ */ __name((transferEvents) => {
+  const groupedEventsDict = groupBy(
+    transferEvents,
+    "transactionHash"
+  );
+  const transactionHashValues = Object.values(groupedEventsDict);
+  const mergedTransaction = transactionHashValues.flatMap((groupedEvents) => {
+    if (groupedEvents.length === 1) return groupedEvents;
+    if (groupedEvents.length > 1) {
+      const { owner, holder } = getHolderOwner(groupedEvents);
+      const base = groupedEvents[0];
+      const type = identifyEventTypeFromLogs(groupedEvents);
+      return [{ ...base, owner, holder, type }];
+    }
+    throw new Error("Invalid hash, update your configuration");
+  });
+  return mergedTransaction;
+}, "mergeTransfersV5");
+const identifyEventTypeFromLogs = /* @__PURE__ */ __name((groupedEvents) => {
+  for (const event of groupedEvents) {
+    if ([
+      "INITIAL",
+      "RETURNED_TO_ISSUER",
+      "RETURN_TO_ISSUER_ACCEPTED",
+      "RETURN_TO_ISSUER_REJECTED"
+    ].includes(event.type) || event.type.startsWith("REJECT_")) {
+      return event.type;
+    }
+  }
+  const isTransferHolder = groupedEvents.some((event) => event.type === "TRANSFER_HOLDER");
+  const isTransferBeneficiary = groupedEvents.some(
+    (event) => event.type === "TRANSFER_BENEFICIARY"
+  );
+  if (isTransferHolder && isTransferBeneficiary) {
+    return "TRANSFER_OWNERS";
+  } else if (isTransferHolder) {
+    return "TRANSFER_HOLDER";
+  } else if (isTransferBeneficiary) {
+    return "TRANSFER_BENEFICIARY";
+  }
+  throw new Error("Unable to identify event type");
+}, "identifyEventTypeFromLogs");
+const sortLogChain = /* @__PURE__ */ __name((logChain) => {
+  return logChain.sort((a, b) => {
+    return a.blockNumber - b.blockNumber;
+  });
+}, "sortLogChain");
+
+export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain };

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

@@ -0,0 +1,6 @@
+export * from './fetchEscrowTransfer';
+export * from './fetchTokenTransfer';
+export * from './helpers';
+export * from './retrieveEndorsementChain';
+export * from './types';
+export * from './useEndorsementChain';

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

@@ -0,0 +1,41 @@
+import { sortLogChain, fetchEventTime } from '../endorsement-chain/helpers';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getEndorsementChain = /* @__PURE__ */ __name(async (provider, logChain) => {
+  const historyChain = [];
+  sortLogChain(logChain);
+  let previousBeneficiary = "";
+  let previousHolder = "";
+  const timestampPromises = logChain.map((log) => fetchEventTime(log.blockNumber, provider));
+  const timestamps = await Promise.all(timestampPromises);
+  logChain.forEach((log, index) => {
+    const timestamp = timestamps[index];
+    const transactionDetails = {
+      type: log.type,
+      transactionHash: log.transactionHash,
+      transactionIndex: log.transactionIndex,
+      blockNumber: log.blockNumber,
+      owner: log.owner || previousBeneficiary,
+      holder: log.holder || previousHolder,
+      timestamp,
+      remark: log?.remark || ""
+    };
+    if (log.type === "TRANSFER_OWNERS" || log.type === "TRANSFER_BENEFICIARY" || log.type === "TRANSFER_HOLDER" || log.type === "INITIAL") {
+      historyChain.push(transactionDetails);
+      previousHolder = transactionDetails.holder;
+      previousBeneficiary = transactionDetails.owner;
+    } else if (log.type === "SURRENDER_ACCEPTED" || log.type === "RETURN_TO_ISSUER_ACCEPTED") {
+      previousHolder = "";
+      previousBeneficiary = "";
+      historyChain.push(transactionDetails);
+    } else if (log.type === "SURRENDERED" || log.type === "SURRENDER_REJECTED" || log.type === "RETURNED_TO_ISSUER" || log.type === "RETURN_TO_ISSUER_REJECTED") {
+      historyChain.push(transactionDetails);
+    } else {
+      historyChain.push(transactionDetails);
+    }
+  });
+  return historyChain;
+}, "getEndorsementChain");
+
+export { getEndorsementChain };

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,98 @@
+import { ethers } from 'ethers';
+import { decrypt } from '../decrypt';
+import { fetchEscrowTransfersV4, fetchEscrowTransfersV5 } from '../endorsement-chain/fetchEscrowTransfer';
+import { fetchTokenTransfers } from '../endorsement-chain/fetchTokenTransfer';
+import { mergeTransfersV4, mergeTransfersV5 } from '../endorsement-chain/helpers';
+import { getEndorsementChain } from '../endorsement-chain/retrieveEndorsementChain';
+import { TradeTrustToken__factory } from '../../token-registry-v4/contracts';
+import { supportInterfaceIds } from '../../token-registry-v4/supportInterfaceIds';
+import { supportInterfaceIds as supportInterfaceIds$1 } from '../../token-registry-v5/supportInterfaceIds';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const TitleEscrowInterface = {
+  V4: supportInterfaceIds.TitleEscrow,
+  V5: supportInterfaceIds$1.TitleEscrow
+};
+const fetchTitleEscrowFactoryAddress = /* @__PURE__ */ __name(async (tokenRegistry) => {
+  return tokenRegistry.titleEscrowFactory();
+}, "fetchTitleEscrowFactoryAddress");
+const resolveTitleEscrowAddress = /* @__PURE__ */ __name(async (titleEscrowFactoryContract, tokenRegistryAddress, tokenId) => {
+  try {
+    return await titleEscrowFactoryContract.getEscrowAddress(tokenRegistryAddress, tokenId);
+  } catch {
+    return titleEscrowFactoryContract.getAddress(tokenRegistryAddress, tokenId);
+  }
+}, "resolveTitleEscrowAddress");
+const getTitleEscrowAddress = /* @__PURE__ */ __name(async (tokenRegistryAddress, tokenId, provider) => {
+  const tokenRegistryAbi = [
+    "function titleEscrowFactory() external view returns (address)",
+    "function ownerOf(uint256 tokenId) view returns (address)"
+  ];
+  const tokenRegistry = new ethers.Contract(tokenRegistryAddress, tokenRegistryAbi, provider);
+  const titleEscrowOwner = await tokenRegistry.ownerOf(tokenId);
+  const BURN_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+  const isInactiveEscrow = [BURN_ADDRESS, tokenRegistryAddress].map((address) => address.toLowerCase()).includes(titleEscrowOwner.toLowerCase());
+  if (!isInactiveEscrow) return titleEscrowOwner;
+  const titleEscrowFactoryAddress = await fetchTitleEscrowFactoryAddress(tokenRegistry);
+  const titleEscrowFactoryContract = new ethers.Contract(
+    titleEscrowFactoryAddress,
+    [
+      "function getAddress(address, uint256) view returns (address)",
+      "function getEscrowAddress(address, uint256) view returns (address)"
+    ],
+    provider
+  );
+  return resolveTitleEscrowAddress(titleEscrowFactoryContract, tokenRegistryAddress, tokenId);
+}, "getTitleEscrowAddress");
+const checkSupportsInterface = /* @__PURE__ */ __name(async (titleEscrowAddress, interfaceId, provider) => {
+  try {
+    const titleEscrowAbi = [
+      "function supportsInterface(bytes4 interfaceId) external view returns (bool)"
+    ];
+    const titleEscrowContract = new ethers.Contract(titleEscrowAddress, titleEscrowAbi, provider);
+    return await titleEscrowContract.supportsInterface(interfaceId);
+  } catch {
+    return false;
+  }
+}, "checkSupportsInterface");
+const isTitleEscrowVersion = /* @__PURE__ */ __name(async (versionInterface, tokenRegistryAddress, tokenId, provider) => {
+  try {
+    const titleEscrowAddress = await getTitleEscrowAddress(tokenRegistryAddress, tokenId, provider);
+    return await checkSupportsInterface(titleEscrowAddress, versionInterface, provider);
+  } catch {
+    return false;
+  }
+}, "isTitleEscrowVersion");
+const fetchEndorsementChain = /* @__PURE__ */ __name(async (tokenRegistry, tokenId, provider, keyId) => {
+  if (!tokenRegistry || !tokenId || !provider) {
+    throw new Error("Missing required dependencies");
+  }
+  const [isV4, isV5] = await Promise.all([
+    isTitleEscrowVersion(TitleEscrowInterface.V4, tokenRegistry, tokenId, provider),
+    isTitleEscrowVersion(TitleEscrowInterface.V5, tokenRegistry, tokenId, provider)
+  ]);
+  if (!isV4 && !isV5) {
+    throw new Error("Only Token Registry V4/V5 is supported");
+  }
+  const titleEscrowAddress = await getTitleEscrowAddress(tokenRegistry, tokenId, provider);
+  let transferEvents = [];
+  if (isV4) {
+    const tokenRegistryContract = TradeTrustToken__factory.connect(tokenRegistry, provider);
+    const [tokenLogs, titleEscrowLogs] = await Promise.all([
+      fetchTokenTransfers(tokenRegistryContract, tokenId),
+      fetchEscrowTransfersV4(provider, titleEscrowAddress)
+    ]);
+    transferEvents = mergeTransfersV4([...titleEscrowLogs, ...tokenLogs]);
+  } else if (isV5) {
+    const titleEscrowLogs = await fetchEscrowTransfersV5(provider, titleEscrowAddress);
+    transferEvents = mergeTransfersV5(titleEscrowLogs);
+  }
+  const endorsementChain = await getEndorsementChain(provider, transferEvents);
+  return isV4 ? endorsementChain : endorsementChain.map((event) => ({
+    ...event,
+    remark: event?.remark?.slice(2) ? decrypt(event.remark.slice(2), keyId ?? "") : ""
+  }));
+}, "fetchEndorsementChain");
+
+export { TitleEscrowInterface, fetchEndorsementChain, getTitleEscrowAddress, isTitleEscrowVersion };

package/dist/esm/core/index.js

@@ -1,3 +1,4 @@
 export * from './decrypt';
 export * from './encrypt';
 export * from './verify';
+export * from './endorsement-chain';