@trustvc/trustvc 1.0.4 → 1.1.0

package/dist/core/endorsement-chain/fetchEscrowTransfer.d.mts

@@ -0,0 +1,8 @@
+import { providers } from 'ethers';
+import { TitleEscrowTransferEvent, TransferBaseEvent } from './types.mjs';
+import 'ethers/lib/utils';
+
+declare const fetchEscrowTransfersV4: (provider: providers.Provider, address: string) => Promise<TitleEscrowTransferEvent[]>;
+declare const fetchEscrowTransfersV5: (provider: providers.Provider, address: string) => Promise<TransferBaseEvent[]>;
+
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 };

package/dist/core/endorsement-chain/fetchEscrowTransfer.d.ts

@@ -0,0 +1,8 @@
+import { providers } from 'ethers';
+import { TitleEscrowTransferEvent, TransferBaseEvent } from './types.js';
+import 'ethers/lib/utils';
+
+declare const fetchEscrowTransfersV4: (provider: providers.Provider, address: string) => Promise<TitleEscrowTransferEvent[]>;
+declare const fetchEscrowTransfersV5: (provider: providers.Provider, address: string) => Promise<TransferBaseEvent[]>;
+
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 };

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

@@ -0,0 +1,167 @@
+'use strict';
+
+var contracts = require('../../token-registry-v4/contracts');
+var contracts$1 = require('../../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 = contracts.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 = contracts$1.TitleEscrow__factory.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");
+
+exports.fetchEscrowTransfersV4 = fetchEscrowTransfersV4;
+exports.fetchEscrowTransfersV5 = fetchEscrowTransfersV5;

package/dist/core/endorsement-chain/fetchTokenTransfer.d.mts

@@ -0,0 +1,8 @@
+import { TokenTransferEvent } from './types.mjs';
+import { TradeTrustToken } from '@tradetrust-tt/token-registry-v4/contracts';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const fetchTokenTransfers: (tokenRegistry: TradeTrustToken, tokenId: string) => Promise<TokenTransferEvent[]>;
+
+export { fetchTokenTransfers };

package/dist/core/endorsement-chain/fetchTokenTransfer.d.ts

@@ -0,0 +1,8 @@
+import { TokenTransferEvent } from './types.js';
+import { TradeTrustToken } from '@tradetrust-tt/token-registry-v4/contracts';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const fetchTokenTransfers: (tokenRegistry: TradeTrustToken, tokenId: string) => Promise<TokenTransferEvent[]>;
+
+export { fetchTokenTransfers };

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

@@ -0,0 +1,58 @@
+'use strict';
+
+var helpers = require('../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)
+  );
+  helpers.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");
+
+exports.fetchTokenTransfers = fetchTokenTransfers;

package/dist/core/endorsement-chain/helpers.d.mts

@@ -0,0 +1,11 @@
+import { Provider } from '@ethersproject/abstract-provider';
+import { TransferBaseEvent } from './types.mjs';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const fetchEventTime: (blockNumber: number, provider: Provider) => Promise<number>;
+declare const mergeTransfersV4: (transferEvents: TransferBaseEvent[]) => TransferBaseEvent[];
+declare const mergeTransfersV5: (transferEvents: TransferBaseEvent[]) => TransferBaseEvent[];
+declare const sortLogChain: (logChain: TransferBaseEvent[]) => TransferBaseEvent[];
+
+export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain };

package/dist/core/endorsement-chain/helpers.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from '@ethersproject/abstract-provider';
+import { TransferBaseEvent } from './types.js';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const fetchEventTime: (blockNumber: number, provider: Provider) => Promise<number>;
+declare const mergeTransfersV4: (transferEvents: TransferBaseEvent[]) => TransferBaseEvent[];
+declare const mergeTransfersV5: (transferEvents: TransferBaseEvent[]) => TransferBaseEvent[];
+declare const sortLogChain: (logChain: TransferBaseEvent[]) => TransferBaseEvent[];
+
+export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain };

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

@@ -0,0 +1,99 @@
+'use strict';
+
+var lodash = require('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 = lodash.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 = lodash.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");
+
+exports.fetchEventTime = fetchEventTime;
+exports.mergeTransfersV4 = mergeTransfersV4;
+exports.mergeTransfersV5 = mergeTransfersV5;
+exports.sortLogChain = sortLogChain;

package/dist/core/endorsement-chain/index.d.mts

@@ -0,0 +1,11 @@
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 } from './fetchEscrowTransfer.mjs';
+export { fetchTokenTransfers } from './fetchTokenTransfer.mjs';
+export { fetchEventTime, mergeTransfersV4, mergeTransfersV5, sortLogChain } from './helpers.mjs';
+export { getEndorsementChain } from './retrieveEndorsementChain.mjs';
+export { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent } from './types.mjs';
+export { TitleEscrowInterface, fetchEndorsementChain, getTitleEscrowAddress, isTitleEscrowVersion } from './useEndorsementChain.mjs';
+import 'ethers';
+import '@tradetrust-tt/token-registry-v4/contracts';
+import '@ethersproject/abstract-provider';
+import 'ethers/lib/utils';
+import '@ethersproject/providers';

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

@@ -0,0 +1,11 @@
+export { fetchEscrowTransfersV4, fetchEscrowTransfersV5 } from './fetchEscrowTransfer.js';
+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, getTitleEscrowAddress, isTitleEscrowVersion } from './useEndorsementChain.js';
+import 'ethers';
+import '@tradetrust-tt/token-registry-v4/contracts';
+import '@ethersproject/abstract-provider';
+import 'ethers/lib/utils';
+import '@ethersproject/providers';

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

@@ -0,0 +1,47 @@
+'use strict';
+
+var fetchEscrowTransfer = require('./fetchEscrowTransfer');
+var fetchTokenTransfer = require('./fetchTokenTransfer');
+var helpers = require('./helpers');
+var retrieveEndorsementChain = require('./retrieveEndorsementChain');
+var types = require('./types');
+var useEndorsementChain = require('./useEndorsementChain');
+
+
+
+Object.keys(fetchEscrowTransfer).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return fetchEscrowTransfer[k]; }
+	});
+});
+Object.keys(fetchTokenTransfer).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return fetchTokenTransfer[k]; }
+	});
+});
+Object.keys(helpers).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return helpers[k]; }
+	});
+});
+Object.keys(retrieveEndorsementChain).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return retrieveEndorsementChain[k]; }
+	});
+});
+Object.keys(types).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return types[k]; }
+	});
+});
+Object.keys(useEndorsementChain).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return useEndorsementChain[k]; }
+	});
+});

package/dist/core/endorsement-chain/retrieveEndorsementChain.d.mts

@@ -0,0 +1,8 @@
+import { Provider } from '@ethersproject/abstract-provider';
+import { TransferBaseEvent, EndorsementChain } from './types.mjs';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const getEndorsementChain: (provider: Provider, logChain: TransferBaseEvent[]) => Promise<EndorsementChain>;
+
+export { getEndorsementChain };

package/dist/core/endorsement-chain/retrieveEndorsementChain.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from '@ethersproject/abstract-provider';
+import { TransferBaseEvent, EndorsementChain } from './types.js';
+import 'ethers';
+import 'ethers/lib/utils';
+
+declare const getEndorsementChain: (provider: Provider, logChain: TransferBaseEvent[]) => Promise<EndorsementChain>;
+
+export { getEndorsementChain };

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var helpers = require('../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 = [];
+  helpers.sortLogChain(logChain);
+  let previousBeneficiary = "";
+  let previousHolder = "";
+  const timestampPromises = logChain.map((log) => helpers.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");
+
+exports.getEndorsementChain = getEndorsementChain;

package/dist/core/endorsement-chain/types.d.mts

@@ -0,0 +1,50 @@
+import { Event } from 'ethers';
+import { EventFragment, Result } from 'ethers/lib/utils';
+
+type TradeTrustTokenEventType = 'INITIAL' | 'NEW_OWNERS' | 'ENDORSE' | 'TRANSFER' | 'SURRENDERED' | 'RETURNED_TO_ISSUER' | 'SURRENDER_REJECTED' | 'RETURN_TO_ISSUER_REJECTED' | 'SURRENDER_ACCEPTED' | 'RETURN_TO_ISSUER_ACCEPTED' | 'TRANSFER_TO_WALLET' | 'INVALID';
+type TransferEventType = TokenTransferEventType | TitleEscrowTransferEventType;
+interface TransferBaseEvent {
+    type: TransferEventType;
+    transactionIndex: number;
+    holder?: string;
+    owner?: string;
+    transactionHash: string;
+    blockNumber: number;
+    remark?: string;
+}
+type TokenTransferEventType = 'INITIAL' | 'SURRENDERED' | 'RETURNED_TO_ISSUER' | 'SURRENDER_REJECTED' | 'RETURN_TO_ISSUER_REJECTED' | 'SURRENDER_ACCEPTED' | 'RETURN_TO_ISSUER_ACCEPTED';
+interface TitleEscrowTransferEvent extends TransferBaseEvent {
+    type: TitleEscrowTransferEventType;
+}
+type TitleEscrowTransferEventType = 'TRANSFER_BENEFICIARY' | 'TRANSFER_HOLDER' | 'TRANSFER_OWNERS' | 'REJECT_TRANSFER_BENEFICIARY' | 'REJECT_TRANSFER_HOLDER' | 'REJECT_TRANSFER_OWNERS';
+interface TokenTransferEvent extends TransferBaseEvent {
+    type: TokenTransferEventType;
+    from: string;
+    to: string;
+}
+interface TransferEvent extends TransferBaseEvent {
+    timestamp: number;
+    holder: string;
+    owner: string;
+}
+type EndorsementChain = TransferEvent[];
+interface ParsedLog {
+    eventFragment: EventFragment;
+    name: string;
+    signature: string;
+    topic: string;
+    args: Result;
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    logIndex: number;
+    transactionHash: string;
+    address: string;
+    data: string;
+}
+interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+    args: TArgsArray & TArgsObject;
+}
+
+export type { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent };

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

@@ -0,0 +1,50 @@
+import { Event } from 'ethers';
+import { EventFragment, Result } from 'ethers/lib/utils';
+
+type TradeTrustTokenEventType = 'INITIAL' | 'NEW_OWNERS' | 'ENDORSE' | 'TRANSFER' | 'SURRENDERED' | 'RETURNED_TO_ISSUER' | 'SURRENDER_REJECTED' | 'RETURN_TO_ISSUER_REJECTED' | 'SURRENDER_ACCEPTED' | 'RETURN_TO_ISSUER_ACCEPTED' | 'TRANSFER_TO_WALLET' | 'INVALID';
+type TransferEventType = TokenTransferEventType | TitleEscrowTransferEventType;
+interface TransferBaseEvent {
+    type: TransferEventType;
+    transactionIndex: number;
+    holder?: string;
+    owner?: string;
+    transactionHash: string;
+    blockNumber: number;
+    remark?: string;
+}
+type TokenTransferEventType = 'INITIAL' | 'SURRENDERED' | 'RETURNED_TO_ISSUER' | 'SURRENDER_REJECTED' | 'RETURN_TO_ISSUER_REJECTED' | 'SURRENDER_ACCEPTED' | 'RETURN_TO_ISSUER_ACCEPTED';
+interface TitleEscrowTransferEvent extends TransferBaseEvent {
+    type: TitleEscrowTransferEventType;
+}
+type TitleEscrowTransferEventType = 'TRANSFER_BENEFICIARY' | 'TRANSFER_HOLDER' | 'TRANSFER_OWNERS' | 'REJECT_TRANSFER_BENEFICIARY' | 'REJECT_TRANSFER_HOLDER' | 'REJECT_TRANSFER_OWNERS';
+interface TokenTransferEvent extends TransferBaseEvent {
+    type: TokenTransferEventType;
+    from: string;
+    to: string;
+}
+interface TransferEvent extends TransferBaseEvent {
+    timestamp: number;
+    holder: string;
+    owner: string;
+}
+type EndorsementChain = TransferEvent[];
+interface ParsedLog {
+    eventFragment: EventFragment;
+    name: string;
+    signature: string;
+    topic: string;
+    args: Result;
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    logIndex: number;
+    transactionHash: string;
+    address: string;
+    data: string;
+}
+interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+    args: TArgsArray & TArgsObject;
+}
+
+export type { EndorsementChain, ParsedLog, TitleEscrowTransferEvent, TitleEscrowTransferEventType, TokenTransferEvent, TokenTransferEventType, TradeTrustTokenEventType, TransferBaseEvent, TransferEvent, TransferEventType, TypedEvent };

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

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

package/dist/core/endorsement-chain/useEndorsementChain.d.mts

@@ -0,0 +1,14 @@
+import { Provider } from '@ethersproject/providers';
+import { ethers } from 'ethers';
+import { EndorsementChain } from './types.mjs';
+import 'ethers/lib/utils';
+
+declare const TitleEscrowInterface: {
+    V4: string;
+    V5: string;
+};
+declare const getTitleEscrowAddress: (tokenRegistryAddress: string, tokenId: string, provider: ethers.providers.Provider) => Promise<string>;
+declare const isTitleEscrowVersion: (versionInterface: string, tokenRegistryAddress: string, tokenId: string, provider: ethers.providers.Provider) => Promise<boolean>;
+declare const fetchEndorsementChain: (tokenRegistry: string, tokenId: string, provider: Provider, keyId?: string) => Promise<EndorsementChain>;
+
+export { TitleEscrowInterface, fetchEndorsementChain, getTitleEscrowAddress, isTitleEscrowVersion };

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

@@ -0,0 +1,14 @@
+import { Provider } from '@ethersproject/providers';
+import { ethers } from 'ethers';
+import { EndorsementChain } from './types.js';
+import 'ethers/lib/utils';
+
+declare const TitleEscrowInterface: {
+    V4: string;
+    V5: string;
+};
+declare const getTitleEscrowAddress: (tokenRegistryAddress: string, tokenId: string, provider: ethers.providers.Provider) => Promise<string>;
+declare const isTitleEscrowVersion: (versionInterface: string, tokenRegistryAddress: string, tokenId: string, provider: ethers.providers.Provider) => Promise<boolean>;
+declare const fetchEndorsementChain: (tokenRegistry: string, tokenId: string, provider: Provider, keyId?: string) => Promise<EndorsementChain>;
+
+export { TitleEscrowInterface, fetchEndorsementChain, getTitleEscrowAddress, isTitleEscrowVersion };