@trustvc/trustvc 1.0.5 → 1.1.1

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';

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

@@ -1,3 +1,3 @@
-export { roleHash as v5RoleHash } from './roleHash';
 export { contractAddress as v5ContractAddress } from './contractAddress';
+export { roleHash as v5RoleHash } from './roleHash';
 export * from '@tradetrust-tt/token-registry-v5';

package/dist/esm/token-registry-v5/typedContractMethod.js

@@ -1 +1 @@
-export { TypedContractMethod } from '@tradetrust-tt/token-registry-v5/dist/contracts/common';
+

package/dist/esm/w3c/types.js

@@ -1,2 +1 @@
-export { RawVerifiableCredential, SignedVerifiableCredential, SigningResult, VerificationResult } from '@trustvc/w3c-vc';
-export { PrivateKeyPair } from '@trustvc/w3c-issuer';
+

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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 };

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

@@ -0,0 +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/{index-DK8Em_TZ.d.ts → types/index-BVNDN0vp.d.ts}

@@ -1,9 +1,10 @@
 import { openAttestationDidIdentityProof, openAttestationDidSignedDocumentStatus, openAttestationDnsDidIdentityProof, openAttestationDnsTxtIdentityProof, openAttestationEthereumDocumentStoreStatus, openAttestationEthereumTokenRegistryStatus, openAttestationHash } from '@tradetrust-tt/tt-verify';
 import { w3cSignatureIntegrity } from './verify/fragments/document-integrity/w3cSignatureIntegrity.js';
-import { credentialStatusTransferableRecordVerifier } from './verify/fragments/document-status/transferableRecords/transferableRecordVerifier.js';
+import { TRANSFERABLE_RECORDS_TYPE, credentialStatusTransferableRecordVerifier } from './verify/fragments/document-status/transferableRecords/transferableRecordVerifier.js';
 import { w3cCredentialStatus } from './verify/fragments/document-status/w3cCredentialStatus.js';
 import { w3cIssuerIdentity } from './verify/fragments/issuer-identity/w3cIssuerIdentity.js';
 
+declare const index_TRANSFERABLE_RECORDS_TYPE: typeof TRANSFERABLE_RECORDS_TYPE;
 declare const index_credentialStatusTransferableRecordVerifier: typeof credentialStatusTransferableRecordVerifier;
 declare const index_openAttestationDidIdentityProof: typeof openAttestationDidIdentityProof;
 declare const index_openAttestationDidSignedDocumentStatus: typeof openAttestationDidSignedDocumentStatus;
@@ -16,7 +17,7 @@ declare const index_w3cCredentialStatus: typeof w3cCredentialStatus;
 declare const index_w3cIssuerIdentity: typeof w3cIssuerIdentity;
 declare const index_w3cSignatureIntegrity: typeof w3cSignatureIntegrity;
 declare namespace index {
-  export { index_credentialStatusTransferableRecordVerifier as credentialStatusTransferableRecordVerifier, index_openAttestationDidIdentityProof as openAttestationDidIdentityProof, index_openAttestationDidSignedDocumentStatus as openAttestationDidSignedDocumentStatus, index_openAttestationDnsDidIdentityProof as openAttestationDnsDidIdentityProof, index_openAttestationDnsTxtIdentityProof as openAttestationDnsTxtIdentityProof, index_openAttestationEthereumDocumentStoreStatus as openAttestationEthereumDocumentStoreStatus, index_openAttestationEthereumTokenRegistryStatus as openAttestationEthereumTokenRegistryStatus, index_openAttestationHash as openAttestationHash, index_w3cCredentialStatus as w3cCredentialStatus, index_w3cIssuerIdentity as w3cIssuerIdentity, index_w3cSignatureIntegrity as w3cSignatureIntegrity };
+  export { index_TRANSFERABLE_RECORDS_TYPE as TRANSFERABLE_RECORDS_TYPE, index_credentialStatusTransferableRecordVerifier as credentialStatusTransferableRecordVerifier, index_openAttestationDidIdentityProof as openAttestationDidIdentityProof, index_openAttestationDidSignedDocumentStatus as openAttestationDidSignedDocumentStatus, index_openAttestationDnsDidIdentityProof as openAttestationDnsDidIdentityProof, index_openAttestationDnsTxtIdentityProof as openAttestationDnsTxtIdentityProof, index_openAttestationEthereumDocumentStoreStatus as openAttestationEthereumDocumentStoreStatus, index_openAttestationEthereumTokenRegistryStatus as openAttestationEthereumTokenRegistryStatus, index_openAttestationHash as openAttestationHash, index_w3cCredentialStatus as w3cCredentialStatus, index_w3cIssuerIdentity as w3cIssuerIdentity, index_w3cSignatureIntegrity as w3cSignatureIntegrity };
 }
 
 export { index as i };