@canton-network/core-tx-parser 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1019 @@
+'use strict';
+
+var coreTokenStandard = require('@canton-network/core-token-standard');
+var coreLedgerClientTypes = require('@canton-network/core-ledger-client-types');
+var BigNumber = require('bignumber.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var BigNumber__default = /*#__PURE__*/_interopDefault(BigNumber);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function splitInterfaceId(interfaceId) {
+  const regExp = /^#?([^:]+):([^:]+):([^:]+)$/;
+  const match = regExp.exec(interfaceId);
+  if (!match) return null;
+  const [, packageName, moduleName, entityName] = match;
+  return {
+    packageName,
+    moduleName,
+    entityName
+  };
+}
+function matchInterfaceIds(a, b) {
+  const aParts = splitInterfaceId(a);
+  const bParts = splitInterfaceId(b);
+  return aParts !== null && bParts !== null && aParts.moduleName === bParts.moduleName && aParts.entityName === bParts.entityName;
+}
+var TokenStandardTransactionInterfaces = [
+  coreTokenStandard.HOLDING_INTERFACE_ID,
+  coreTokenStandard.TRANSFER_FACTORY_INTERFACE_ID,
+  coreTokenStandard.TRANSFER_INSTRUCTION_INTERFACE_ID,
+  coreTokenStandard.ALLOCATION_FACTORY_INTERFACE_ID,
+  coreTokenStandard.ALLOCATION_INSTRUCTION_INTERFACE_ID,
+  coreTokenStandard.ALLOCATION_INTERFACE_ID,
+  coreTokenStandard.ALLOCATION_REQUEST_INTERFACE_ID
+];
+var SpliceMetaKeyPrefix = "splice.lfdecentralizedtrust.org/";
+var TxKindMetaKey = `${SpliceMetaKeyPrefix}tx-kind`;
+var SenderMetaKey = `${SpliceMetaKeyPrefix}sender`;
+var ReasonMetaKey = `${SpliceMetaKeyPrefix}reason`;
+var BurnedMetaKey = `${SpliceMetaKeyPrefix}burned`;
+var AllKnownMetaKeys = [
+  TxKindMetaKey,
+  SenderMetaKey,
+  ReasonMetaKey,
+  BurnedMetaKey
+];
+function hasInterface(interfaceId, event) {
+  return (event.implementedInterfaces || []).some(
+    (id) => matchInterfaceIds(id, interfaceId)
+  );
+}
+function getInterfaceView(createdEvent) {
+  const interfaceViews = createdEvent.interfaceViews || null;
+  return interfaceViews && interfaceViews[0] || null;
+}
+function getKnownInterfaceView(createdEvent) {
+  const interfaceView = getInterfaceView(createdEvent);
+  if (!interfaceView) {
+    return null;
+  } else if (matchInterfaceIds(coreTokenStandard.HOLDING_INTERFACE_ID, interfaceView.interfaceId)) {
+    return {
+      type: "Holding",
+      viewValue: interfaceView.viewValue
+    };
+  } else if (matchInterfaceIds(
+    coreTokenStandard.TRANSFER_INSTRUCTION_INTERFACE_ID,
+    interfaceView.interfaceId
+  )) {
+    return {
+      type: "TransferInstruction",
+      viewValue: interfaceView.viewValue
+    };
+  } else {
+    return null;
+  }
+}
+function ensureInterfaceViewIsPresent(createdEvent, interfaceId) {
+  const interfaceView = getInterfaceView(createdEvent);
+  if (!interfaceView) {
+    throw new Error(
+      `Expected to have interface views, but didn't: ${JSON.stringify(
+        createdEvent
+      )}`
+    );
+  }
+  if (!matchInterfaceIds(interfaceId, interfaceView.interfaceId)) {
+    throw new Error(
+      `Not a ${interfaceId} but a ${interfaceView.interfaceId}: ${JSON.stringify(createdEvent)}`
+    );
+  }
+  return interfaceView;
+}
+function mergeMetas(event, extra) {
+  const choiceArgument = event.choiceArgument;
+  const lastWriteWins = [
+    choiceArgument?.transfer?.meta,
+    choiceArgument?.extraArgs?.meta,
+    choiceArgument?.meta,
+    extra,
+    event.exerciseResult?.meta
+  ];
+  const result = {};
+  lastWriteWins.forEach((meta) => {
+    const values = meta?.values || {};
+    Object.entries(values).forEach(([k, v]) => {
+      result[k] = v;
+    });
+  });
+  if (Object.keys(result).length === 0) {
+    return void 0;
+  } else {
+    return { values: result };
+  }
+}
+function getMetaKeyValue(key, meta) {
+  return (meta?.values || {})[key] || null;
+}
+function removeParsedMetaKeys(meta) {
+  return {
+    values: Object.fromEntries(
+      Object.entries(meta?.values || {}).filter(
+        ([k]) => !AllKnownMetaKeys.includes(k)
+      )
+    )
+  };
+}
+
+// src/types.ts
+var renderTransaction = (t) => {
+  return { ...t, events: t.events.map(renderTransactionEvent) };
+};
+var renderTransactionEvent = (e) => {
+  const lockedHoldingsChangeSummaries = e.lockedHoldingsChangeSummaries.map(renderHoldingsChangeSummary).filter((s) => s !== null);
+  const unlockedHoldingsChangeSummaries = e.unlockedHoldingsChangeSummaries.map(renderHoldingsChangeSummary).filter((s) => s !== null);
+  const lockedHoldingsChange = renderHoldingsChange(e.lockedHoldingsChange);
+  const unlockedHoldingsChange = renderHoldingsChange(
+    e.unlockedHoldingsChange
+  );
+  return {
+    ...e,
+    lockedHoldingsChange,
+    unlockedHoldingsChange,
+    lockedHoldingsChangeSummaries,
+    // Deprecated
+    lockedHoldingsChangeSummary: renderHoldingsChangeSummary(
+      e.lockedHoldingsChangeSummary
+    ),
+    unlockedHoldingsChangeSummaries,
+    // Deprecated
+    unlockedHoldingsChangeSummary: renderHoldingsChangeSummary(
+      e.unlockedHoldingsChangeSummary
+    )
+  };
+};
+var renderHoldingsChangeSummary = (s) => {
+  if (s.numInputs === 0 && s.numOutputs === 0 && s.inputAmount === "0" && s.outputAmount === "0" && s.amountChange === "0") {
+    return null;
+  }
+  return {
+    ...(s.instrumentId.admin !== "" || s.instrumentId.id !== "") && {
+      instrumentId: s.instrumentId
+    },
+    ...s.numInputs !== 0 && { numInputs: s.numInputs },
+    ...s.inputAmount !== "0" && { inputAmount: s.inputAmount },
+    ...s.numOutputs !== 0 && { numOutputs: s.numOutputs },
+    ...s.outputAmount !== "0" && { outputAmount: s.outputAmount },
+    ...s.amountChange !== "0" && { amountChange: s.amountChange }
+  };
+};
+var renderHoldingsChange = (c) => {
+  if (c.creates.length === 0 && c.archives.length === 0) {
+    return null;
+  }
+  return {
+    ...c.creates.length !== 0 && { creates: c.creates },
+    ...c.archives.length !== 0 && { archives: c.archives }
+  };
+};
+
+// src/instrumentmap.ts
+var InstrumentMap = class {
+  constructor() {
+    __publicField(this, "map");
+    this.map = /* @__PURE__ */ new Map();
+  }
+  encodeKey(instrumentId) {
+    return JSON.stringify([instrumentId.admin, instrumentId.id]);
+  }
+  decodeKey(key) {
+    const [admin, id] = JSON.parse(key);
+    return { admin, id };
+  }
+  set(key, value) {
+    this.map.set(this.encodeKey(key), value);
+  }
+  get(key) {
+    return this.map.get(this.encodeKey(key));
+  }
+  has(key) {
+    return this.map.has(this.encodeKey(key));
+  }
+  delete(key) {
+    return this.map.delete(this.encodeKey(key));
+  }
+  *entries() {
+    for (const [key, value] of this.map.entries()) {
+      yield [this.decodeKey(key), value];
+    }
+  }
+};
+function currentStatusFromChoiceOrResult(choice, resultTag) {
+  if (resultTag === "TransferInstructionResult_Failed") return "Failed";
+  if (resultTag === "TransferInstructionResult_Completed") return "Completed";
+  switch (choice) {
+    case "TransferInstruction_Reject":
+      return "Rejected";
+    case "TransferInstruction_Withdraw":
+      return "Withdrawn";
+    case "TransferInstruction_Accept":
+    case "TransferInstruction_Update":
+      return "Pending";
+    default:
+      return "Pending";
+  }
+}
+function getCorrelationIdFromTransferInstruction(currentInstructionCid, originalInstructionCid) {
+  return originalInstructionCid ?? currentInstructionCid;
+}
+function getPendingTransferInstructionCid(exercisedEvent) {
+  const output = exercisedEvent.exerciseResult?.output;
+  if (output?.tag !== "TransferInstructionResult_Pending") return void 0;
+  const cid = output.value?.transferInstructionCid;
+  return cid ?? void 0;
+}
+function isTransferObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  const instrumentId = v.instrumentId;
+  const meta = v.meta;
+  return typeof v.sender === "string" && typeof v.receiver === "string" && typeof v.amount === "string" && typeof v.requestedAt === "string" && typeof v.executeBefore === "string" && Array.isArray(v.inputHoldingCids) && v.inputHoldingCids.every((cid) => typeof cid === "string") && !!instrumentId && typeof instrumentId.admin === "string" && typeof instrumentId.id === "string" && !!meta && typeof meta.values === "object" && meta.values !== null;
+}
+var TransactionParser = class {
+  constructor(transaction, ledgerClient, partyId, isMasterUser) {
+    __publicField(this, "ledgerClient");
+    __publicField(this, "partyId");
+    __publicField(this, "transaction");
+    __publicField(this, "isMasterUser");
+    this.ledgerClient = ledgerClient;
+    this.partyId = partyId;
+    this.transaction = transaction;
+    this.isMasterUser = isMasterUser;
+  }
+  async parseTransaction() {
+    const tx = this.transaction;
+    const events = await this.parseEvents([...tx.events || []].reverse());
+    return {
+      updateId: tx.updateId,
+      offset: tx.offset,
+      recordTime: tx.recordTime,
+      synchronizerId: tx.synchronizerId,
+      events
+    };
+  }
+  async parseTransferObjects() {
+    const eventsStack = [...this.transaction.events || []].reverse();
+    const results = await this.fetchTransferObjectChoice(eventsStack);
+    return results;
+  }
+  async fetchTransferObjectChoice(eventsStack) {
+    const result = [];
+    while (eventsStack.length > 0) {
+      const currentEvent = eventsStack.pop();
+      const { exercisedEvent } = getNodeIdAndEvent(currentEvent);
+      if (exercisedEvent && (exercisedEvent.choice === "TransferFactory_Transfer" || exercisedEvent.choice === "TransferRule_Transfer")) {
+        const { choiceArgument } = exercisedEvent;
+        if (choiceArgument && typeof choiceArgument === "object" && "transfer" in choiceArgument) {
+          const transfer = choiceArgument.transfer;
+          if (isTransferObject(transfer)) {
+            result.push(transfer);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async parseEvents(eventsStack) {
+    let callStack = [];
+    let continueAfterNodeId = -1;
+    const result = [];
+    while (eventsStack.length > 0) {
+      const currentEvent = eventsStack.pop();
+      const { nodeId, createdEvent, archivedEvent, exercisedEvent } = getNodeIdAndEvent(currentEvent);
+      callStack = callStack.filter((s) => s.untilNodeId <= nodeId);
+      const parentChoice = callStack[callStack.length - 1] && callStack[callStack.length - 1].parentChoiceName || "none (root node)";
+      let parsed;
+      if (nodeId <= continueAfterNodeId) {
+        parsed = null;
+      } else if (createdEvent) {
+        parsed = this.parseRawCreate(createdEvent, parentChoice);
+      } else if (archivedEvent) {
+        parsed = await this.parseRawArchive(archivedEvent, parentChoice);
+      } else if (exercisedEvent) {
+        parsed = await this.parseExercise(exercisedEvent);
+      } else {
+        throw new Error(
+          `Impossible event: ${JSON.stringify(currentEvent)}`
+        );
+      }
+      if (parsed && isLeafEventNode(parsed)) {
+        if (holdingChangesNonEmpty(parsed.event)) {
+          result.push({
+            ...parsed.event,
+            label: {
+              ...parsed.event.label,
+              meta: removeParsedMetaKeys(parsed.event.label.meta)
+            }
+          });
+        }
+        continueAfterNodeId = parsed.continueAfterNodeId;
+      } else if (parsed) {
+        callStack.push({
+          parentChoiceName: parsed.parentChoiceName,
+          untilNodeId: parsed.lastDescendantNodeId
+        });
+      }
+    }
+    return result;
+  }
+  parseRawCreate(create, parentChoice) {
+    return this.buildRawEvent(create, create.nodeId, (result) => {
+      return {
+        // TODO: this code currently only looks at the first instrument
+        // to determine the type of the Event.
+        type: Number(
+          result.lockedHoldingsChangeSummaries[0]?.amountChange
+        ) > 0 ? "Lock" : "Create",
+        parentChoice,
+        contractId: create.contractId,
+        offset: create.offset,
+        templateId: create.templateId,
+        payload: result.payload,
+        packageName: create.packageName,
+        meta: void 0
+      };
+    });
+  }
+  async parseRawArchive(archive, parentChoice) {
+    const events = await this.getEventsForArchive(archive);
+    if (!events) {
+      return null;
+    }
+    return this.buildRawEvent(
+      events.created.createdEvent,
+      archive.nodeId,
+      (result) => {
+        return {
+          type: "Archive",
+          parentChoice,
+          contractId: archive.contractId,
+          offset: archive.offset,
+          templateId: archive.templateId,
+          packageName: archive.packageName,
+          actingParties: archive.actingParties || [],
+          payload: result.payload,
+          meta: void 0
+        };
+      }
+    );
+  }
+  buildRawEvent(originalCreate, nodeId, buildLabel) {
+    const view = getKnownInterfaceView(originalCreate);
+    let result;
+    switch (view?.type) {
+      case "Holding": {
+        const holdingView = view.viewValue;
+        if (this.partyId !== holdingView.owner) {
+          result = null;
+        } else {
+          const isLocked = !!holdingView.lock;
+          const summary = {
+            instrumentId: holdingView.instrumentId,
+            amountChange: holdingView.amount,
+            numInputs: 0,
+            inputAmount: "0",
+            numOutputs: 1,
+            outputAmount: holdingView.amount
+          };
+          const lockedHoldingsChangeSummaries = isLocked ? [summary] : [];
+          const unlockedHoldingsChangeSummaries = isLocked ? [] : [summary];
+          result = {
+            payload: holdingView,
+            unlockedHoldingsChange: {
+              creates: isLocked ? [] : [holdingView],
+              archives: []
+            },
+            lockedHoldingsChange: {
+              creates: isLocked ? [holdingView] : [],
+              archives: []
+            },
+            lockedHoldingsChangeSummaries,
+            lockedHoldingsChangeSummary: lockedHoldingsChangeSummaries[0] ?? emptyHoldingsChangeSummary,
+            unlockedHoldingsChangeSummaries,
+            unlockedHoldingsChangeSummary: unlockedHoldingsChangeSummaries[0] ?? emptyHoldingsChangeSummary,
+            transferInstruction: null
+          };
+        }
+        break;
+      }
+      case "TransferInstruction": {
+        const transferInstructionView = view.viewValue;
+        if (![
+          transferInstructionView.transfer.sender,
+          transferInstructionView.transfer.receiver
+        ].some((stakeholder) => stakeholder === this.partyId)) {
+          result = null;
+        } else {
+          const multiStepCorrelationId = getCorrelationIdFromTransferInstruction(
+            originalCreate.contractId,
+            transferInstructionView.originalInstructionCid ?? null
+          );
+          result = {
+            payload: transferInstructionView,
+            transferInstruction: {
+              originalInstructionCid: transferInstructionView.originalInstructionCid,
+              transfer: transferInstructionView.transfer,
+              meta: transferInstructionView.meta,
+              status: {
+                before: transferInstructionView.status,
+                // raw DAML pending sub-state
+                current: { tag: "Pending", value: {} }
+                // normalized
+              },
+              multiStepCorrelationId
+            },
+            unlockedHoldingsChange: { creates: [], archives: [] },
+            lockedHoldingsChange: { creates: [], archives: [] },
+            unlockedHoldingsChangeSummaries: [],
+            unlockedHoldingsChangeSummary: emptyHoldingsChangeSummary,
+            lockedHoldingsChangeSummaries: [],
+            lockedHoldingsChangeSummary: emptyHoldingsChangeSummary
+          };
+        }
+        break;
+      }
+      default:
+        result = null;
+    }
+    return result && {
+      continueAfterNodeId: nodeId,
+      event: {
+        label: buildLabel(result),
+        unlockedHoldingsChange: result.unlockedHoldingsChange,
+        lockedHoldingsChange: result.lockedHoldingsChange,
+        lockedHoldingsChangeSummaries: result.lockedHoldingsChangeSummaries,
+        lockedHoldingsChangeSummary: result.lockedHoldingsChangeSummary,
+        unlockedHoldingsChangeSummaries: result.unlockedHoldingsChangeSummaries,
+        unlockedHoldingsChangeSummary: result.unlockedHoldingsChangeSummary,
+        transferInstruction: result.transferInstruction
+      }
+    };
+  }
+  async parseExercise(exercise) {
+    let result = null;
+    const tokenStandardChoice = {
+      name: exercise.choice,
+      choiceArgument: exercise.choiceArgument,
+      exerciseResult: exercise.exerciseResult
+    };
+    switch (exercise.choice) {
+      case "TransferRule_Transfer":
+      case "TransferFactory_Transfer":
+        result = await this.buildTransfer(exercise, tokenStandardChoice);
+        break;
+      case "TransferInstruction_Accept":
+      case "TransferInstruction_Reject":
+      case "TransferInstruction_Withdraw":
+      case "TransferInstruction_Update":
+        result = await this.buildFromTransferInstructionExercise(
+          exercise,
+          tokenStandardChoice
+        );
+        break;
+      case "BurnMintFactory_BurnMint":
+        result = await this.buildMergeSplit(
+          exercise,
+          tokenStandardChoice
+        );
+        break;
+      default: {
+        const meta = mergeMetas(exercise);
+        const txKind = getMetaKeyValue(TxKindMetaKey, meta);
+        if (txKind) {
+          result = await this.parseViaTxKind(exercise, txKind);
+        }
+        break;
+      }
+    }
+    if (!result) {
+      return {
+        lastDescendantNodeId: exercise.lastDescendantNodeId,
+        parentChoiceName: exercise.choice
+      };
+    } else {
+      const lockedHoldingsChange = {
+        creates: result.children.creates.filter(
+          (h) => !!h.lock && h.owner === this.partyId
+        ),
+        archives: result.children.archives.filter(
+          (h) => !!h.lock && h.owner === this.partyId
+        )
+      };
+      const unlockedHoldingsChange = {
+        creates: result.children.creates.filter(
+          (h) => !h.lock && h.owner === this.partyId
+        ),
+        archives: result.children.archives.filter(
+          (h) => !h.lock && h.owner === this.partyId
+        )
+      };
+      const lockedHoldingsChangeSummaries = computeSummaries(
+        lockedHoldingsChange,
+        this.partyId
+      );
+      const unlockedHoldingsChangeSummaries = computeSummaries(
+        unlockedHoldingsChange,
+        this.partyId
+      );
+      return {
+        event: {
+          label: result.label,
+          lockedHoldingsChange,
+          lockedHoldingsChangeSummaries,
+          lockedHoldingsChangeSummary: lockedHoldingsChangeSummaries[0] ?? emptyHoldingsChangeSummary,
+          unlockedHoldingsChange,
+          unlockedHoldingsChangeSummaries,
+          unlockedHoldingsChangeSummary: unlockedHoldingsChangeSummaries[0] ?? emptyHoldingsChangeSummary,
+          transferInstruction: result.transferInstruction
+        },
+        continueAfterNodeId: exercise.lastDescendantNodeId
+      };
+    }
+  }
+  async parseViaTxKind(exercisedEvent, txKind) {
+    switch (txKind) {
+      case "transfer":
+        return await this.buildTransfer(exercisedEvent, null);
+      case "merge-split":
+      case "burn":
+      case "mint":
+        return await this.buildMergeSplit(exercisedEvent, null);
+      case "unlock":
+        return await this.buildBasic(exercisedEvent, "Unlock", null);
+      case "expire-dust":
+        return await this.buildBasic(exercisedEvent, "ExpireDust", null);
+      default:
+        throw new Error(
+          `Unknown tx-kind '${txKind}' in ${JSON.stringify(exercisedEvent)}`
+        );
+    }
+  }
+  async buildTransfer(exercisedEvent, tokenStandardChoice, transferInstructions) {
+    const meta = mergeMetas(
+      exercisedEvent,
+      transferInstructions?.transfer?.meta
+    );
+    const reason = getMetaKeyValue(ReasonMetaKey, meta);
+    const choiceArgumentTransfer = exercisedEvent.choiceArgument.transfer;
+    const sender = transferInstructions?.transfer?.sender || getMetaKeyValue(SenderMetaKey, meta) || choiceArgumentTransfer.sender;
+    if (!sender) {
+      console.error(
+        `Malformed transfer didn't contain sender. Will instead attempt to parse the children.
+        Transfer: ${JSON.stringify(exercisedEvent)}`
+      );
+      return null;
+    }
+    const resultTag = exercisedEvent.exerciseResult?.output?.tag || void 0;
+    const pendingCid = getPendingTransferInstructionCid(exercisedEvent);
+    const currentTag = currentStatusFromChoiceOrResult(
+      exercisedEvent.choice,
+      resultTag
+    );
+    const children = await this.getChildren(exercisedEvent);
+    const receiverAmounts = /* @__PURE__ */ new Map();
+    children.creates.filter((h) => h.owner !== sender).forEach(
+      (holding) => receiverAmounts.set(
+        holding.owner,
+        (receiverAmounts.get(holding.owner) || BigNumber__default.default("0")).plus(
+          BigNumber__default.default(holding.amount)
+        )
+      )
+    );
+    const amountChanges = computeAmountChanges(children, meta, this.partyId);
+    let label;
+    if (receiverAmounts.size === 0) {
+      label = {
+        ...amountChanges,
+        type: "MergeSplit",
+        tokenStandardChoice,
+        reason,
+        meta
+      };
+    } else if (sender === this.partyId) {
+      label = {
+        ...amountChanges,
+        type: "TransferOut",
+        receiverAmounts: [...receiverAmounts].map(([k, v]) => {
+          return { receiver: k, amount: v.toString() };
+        }),
+        tokenStandardChoice,
+        reason,
+        meta
+      };
+    } else {
+      label = {
+        type: "TransferIn",
+        // for Transfers, the burn/mint is always 0 for the receiving party (i.e., 0 for TransferIn)
+        burnAmount: "0",
+        mintAmount: "0",
+        sender,
+        tokenStandardChoice,
+        reason,
+        meta
+      };
+    }
+    if (transferInstructions) {
+      transferInstructions.status.current = transferInstructions.status.current || { tag: currentTag, value: {} };
+      return {
+        label,
+        children,
+        transferInstruction: transferInstructions
+      };
+    }
+    const transferInstruction = {
+      originalInstructionCid: null,
+      ...choiceArgumentTransfer !== void 0 && {
+        transfer: choiceArgumentTransfer
+      },
+      status: {
+        before: null,
+        current: { tag: currentTag, value: {} }
+      },
+      meta: null,
+      ...pendingCid ? { multiStepCorrelationId: pendingCid } : {}
+    };
+    return {
+      label,
+      children,
+      transferInstruction
+    };
+  }
+  async buildMergeSplit(exercisedEvent, tokenStandardChoice) {
+    let type;
+    const meta = mergeMetas(exercisedEvent);
+    switch (getMetaKeyValue(TxKindMetaKey, meta)) {
+      case "burn":
+        type = "Burn";
+        break;
+      case "mint":
+        type = "Mint";
+        break;
+      default:
+        type = "MergeSplit";
+    }
+    const reason = getMetaKeyValue(ReasonMetaKey, meta);
+    const children = await this.getChildren(exercisedEvent);
+    const amountChanges = computeAmountChanges(children, meta, this.partyId);
+    const label = {
+      ...amountChanges,
+      type,
+      tokenStandardChoice,
+      reason,
+      meta
+    };
+    return {
+      label,
+      children,
+      transferInstruction: null
+    };
+  }
+  async buildFromTransferInstructionExercise(exercisedEvent, tokenStandardChoice) {
+    const instructionCid = exercisedEvent.contractId;
+    const transferInstructionEvents = await this.getEventsForArchive(exercisedEvent);
+    if (!transferInstructionEvents) {
+      return null;
+    }
+    const transferInstructionView = ensureInterfaceViewIsPresent(
+      transferInstructionEvents.created.createdEvent,
+      coreTokenStandard.TRANSFER_INSTRUCTION_INTERFACE_ID
+    ).viewValue;
+    const multiStepCorrelationId = getCorrelationIdFromTransferInstruction(
+      instructionCid,
+      transferInstructionView.originalInstructionCid ?? null
+    );
+    const resultTag = exercisedEvent.exerciseResult?.output?.tag || void 0;
+    const currentTag = currentStatusFromChoiceOrResult(
+      exercisedEvent.choice,
+      resultTag
+    );
+    const transferInstruction = {
+      originalInstructionCid: transferInstructionView.originalInstructionCid,
+      multiStepCorrelationId,
+      transfer: transferInstructionView.transfer,
+      meta: transferInstructionView.meta,
+      status: {
+        before: transferInstructionView.status,
+        current: { tag: currentTag, value: {} }
+      }
+    };
+    const exerciseResultOutputTag = resultTag;
+    let result = null;
+    switch (exerciseResultOutputTag) {
+      case "TransferInstructionResult_Failed":
+      case "TransferInstructionResult_Pending":
+        result = await this.buildMergeSplit(
+          exercisedEvent,
+          tokenStandardChoice
+        );
+        break;
+      case "TransferInstructionResult_Completed":
+        result = await this.buildTransfer(
+          exercisedEvent,
+          tokenStandardChoice,
+          transferInstruction
+        );
+        break;
+      default:
+        throw new Error(
+          `Unknown TransferInstructionResult: ${exerciseResultOutputTag}`
+        );
+    }
+    return result && {
+      ...result,
+      transferInstruction
+    };
+  }
+  async buildBasic(exercisedEvent, type, tokenStandardChoice) {
+    const children = await this.getChildren(exercisedEvent);
+    const meta = mergeMetas(exercisedEvent);
+    const amountChanges = computeAmountChanges(children, meta, this.partyId);
+    const reason = getMetaKeyValue(ReasonMetaKey, meta);
+    return {
+      label: {
+        ...amountChanges,
+        type,
+        tokenStandardChoice,
+        reason,
+        meta
+      },
+      children,
+      transferInstruction: null
+    };
+  }
+  async getChildren(exercisedEvent) {
+    const mutatingResult = { creates: [], archives: [] };
+    const childrenEventsSlice = (this.transaction.events || []).map(getNodeIdAndEvent).filter(
+      ({ nodeId }) => nodeId > exercisedEvent.nodeId && nodeId <= exercisedEvent.lastDescendantNodeId
+    );
+    if (exercisedEvent.consuming && hasInterface(coreTokenStandard.HOLDING_INTERFACE_ID, exercisedEvent)) {
+      const selfEvent = await this.getEventsForArchive(exercisedEvent);
+      if (selfEvent) {
+        const holdingView = ensureInterfaceViewIsPresent(
+          selfEvent.created.createdEvent,
+          coreTokenStandard.HOLDING_INTERFACE_ID
+        ).viewValue;
+        mutatingResult.archives.push({
+          amount: holdingView.amount,
+          instrumentId: holdingView.instrumentId,
+          contractId: exercisedEvent.contractId,
+          owner: holdingView.owner,
+          meta: holdingView.meta,
+          lock: holdingView.lock
+        });
+      }
+    }
+    for (const {
+      createdEvent,
+      archivedEvent,
+      exercisedEvent: exercisedEvent2
+    } of childrenEventsSlice) {
+      if (createdEvent) {
+        const interfaceView = getInterfaceView(createdEvent);
+        if (interfaceView && matchInterfaceIds(
+          coreTokenStandard.HOLDING_INTERFACE_ID,
+          interfaceView.interfaceId
+        )) {
+          const holdingView = interfaceView.viewValue;
+          mutatingResult.creates.push({
+            amount: holdingView.amount,
+            instrumentId: holdingView.instrumentId,
+            contractId: createdEvent.contractId,
+            owner: holdingView.owner,
+            meta: holdingView.meta,
+            lock: holdingView.lock
+          });
+        }
+      } else if (archivedEvent && hasInterface(coreTokenStandard.HOLDING_INTERFACE_ID, archivedEvent) || exercisedEvent2 && exercisedEvent2.consuming && hasInterface(coreTokenStandard.HOLDING_INTERFACE_ID, exercisedEvent2)) {
+        const contractEvents = await this.getEventsForArchive(
+          archivedEvent || exercisedEvent2
+        );
+        if (contractEvents) {
+          const holdingView = ensureInterfaceViewIsPresent(
+            contractEvents.created?.createdEvent,
+            coreTokenStandard.HOLDING_INTERFACE_ID
+          ).viewValue;
+          mutatingResult.archives.push({
+            amount: holdingView.amount,
+            instrumentId: holdingView.instrumentId,
+            contractId: archivedEvent?.contractId || exercisedEvent2.contractId,
+            owner: holdingView.owner,
+            meta: holdingView.meta,
+            lock: holdingView.lock
+          });
+        }
+      }
+    }
+    return {
+      // remove transient contracts
+      creates: mutatingResult.creates.filter(
+        (create) => !mutatingResult.archives.some(
+          (archive) => create.contractId === archive.contractId
+        )
+      ),
+      archives: mutatingResult.archives.filter(
+        (archive) => !mutatingResult.creates.some(
+          (create) => create.contractId === archive.contractId
+        )
+      )
+    };
+  }
+  async getEventsForArchive(archivedEvent) {
+    if (!(archivedEvent.witnessParties || []).includes(this.partyId)) {
+      return null;
+    }
+    const basePayload = {
+      contractId: archivedEvent.contractId,
+      eventFormat: coreLedgerClientTypes.EventFilterBySetup({
+        interfaceIds: [
+          coreTokenStandard.HOLDING_INTERFACE_ID,
+          coreTokenStandard.TRANSFER_INSTRUCTION_INTERFACE_ID
+        ],
+        isMasterUser: this.isMasterUser,
+        partyId: this.partyId,
+        verbose: true
+      })
+    };
+    const payload = this.ledgerClient.getCurrentClientVersion() === "3.3" ? { ...basePayload, requestingParties: [] } : basePayload;
+    const events = await this.ledgerClient.postWithRetry("/v2/events/events-by-contract-id", payload).catch((err) => {
+      if (err.code === "CONTRACT_EVENTS_NOT_FOUND") {
+        return null;
+      } else {
+        throw err;
+      }
+    });
+    if (!events) {
+      return null;
+    }
+    const created = events.created;
+    const archived = events.archived;
+    if (!created || !archived) {
+      throw new Error(
+        `Archival of ${archivedEvent.contractId} does not have a corresponding create/archive event: ${JSON.stringify(
+          events
+        )}`
+      );
+    }
+    return { created, archived };
+  }
+};
+function isLeafEventNode(result) {
+  return !!result.event;
+}
+function getNodeIdAndEvent(event) {
+  if ("ExercisedEvent" in event) {
+    if (event.ExercisedEvent.choice === "Archive") {
+      return {
+        nodeId: event.ExercisedEvent.nodeId,
+        archivedEvent: event.ExercisedEvent
+      };
+    } else {
+      return {
+        nodeId: event.ExercisedEvent.nodeId,
+        exercisedEvent: event.ExercisedEvent
+      };
+    }
+  } else if ("CreatedEvent" in event) {
+    return {
+      nodeId: event.CreatedEvent.nodeId,
+      createdEvent: event.CreatedEvent
+    };
+  } else if ("ArchivedEvent" in event) {
+    return {
+      nodeId: event.ArchivedEvent.nodeId,
+      archivedEvent: event.ArchivedEvent
+    };
+  } else {
+    throw new Error(`Impossible event type: ${event}`);
+  }
+}
+function sumHoldingsChange(change, filter) {
+  return sumHoldings(
+    change.creates.filter((create) => filter(create.owner, create.lock))
+  ).minus(
+    sumHoldings(
+      change.archives.filter(
+        (archive) => filter(archive.owner, archive.lock)
+      )
+    )
+  );
+}
+function sumHoldings(holdings) {
+  if (holdings.length > 0) {
+    const instrumentId = holdings[0].instrumentId;
+    for (const holding of holdings) {
+      if (holding.instrumentId.admin !== instrumentId.admin || holding.instrumentId.id !== instrumentId.id) {
+        throw new Error(
+          `Attempted to call sumHoldings on heterogeneous instruments: ${JSON.stringify(instrumentId)} != ${JSON.stringify(holding.instrumentId)}`
+        );
+      }
+    }
+  }
+  return BigNumber__default.default.sum(
+    ...holdings.map((h) => h.amount).concat(["0"])
+    // avoid NaN
+  );
+}
+function computeAmountChanges(children, meta, partyId) {
+  const burnAmount = BigNumber__default.default(getMetaKeyValue(BurnedMetaKey, meta) || "0");
+  const partyHoldingAmountChange = sumHoldingsChange(
+    children,
+    (owner) => owner === partyId
+  );
+  const otherPartiesHoldingAmountChange = sumHoldingsChange(
+    children,
+    (owner) => owner !== partyId
+  );
+  const mintAmount = partyHoldingAmountChange.plus(burnAmount).plus(otherPartiesHoldingAmountChange);
+  return {
+    burnAmount: burnAmount.toString(),
+    mintAmount: mintAmount.toString()
+  };
+}
+function computeSummary(instrumentId, changes, partyId) {
+  const amountChange = sumHoldingsChange(
+    changes,
+    (owner) => owner === partyId
+  );
+  const outputAmount = sumHoldings(changes.creates);
+  const inputAmount = sumHoldings(changes.archives);
+  return {
+    instrumentId,
+    amountChange: amountChange.toString(),
+    numOutputs: changes.creates.length,
+    outputAmount: outputAmount.toString(),
+    numInputs: changes.archives.length,
+    inputAmount: inputAmount.toString()
+  };
+}
+function holdingsChangeByInstrument(changes) {
+  const map = new InstrumentMap();
+  for (const create of changes.creates) {
+    if (map.has(create.instrumentId)) {
+      map.get(create.instrumentId).creates.push(create);
+    } else {
+      map.set(create.instrumentId, { creates: [create], archives: [] });
+    }
+  }
+  for (const archive of changes.archives) {
+    if (map.has(archive.instrumentId)) {
+      map.get(archive.instrumentId).archives.push(archive);
+    } else {
+      map.set(archive.instrumentId, { creates: [], archives: [archive] });
+    }
+  }
+  return map;
+}
+function computeSummaries(changes, partyId) {
+  const byInstrument = holdingsChangeByInstrument(changes);
+  return [...byInstrument.entries()].map(
+    ([instrumentId, change]) => computeSummary(instrumentId, change, partyId)
+  );
+}
+function holdingChangesNonEmpty(event) {
+  return event.unlockedHoldingsChange.creates.length > 0 || event.unlockedHoldingsChange.archives.length > 0 || event.lockedHoldingsChange.creates.length > 0 || event.lockedHoldingsChange.archives.length > 0;
+}
+var emptyHoldingsChangeSummary = {
+  // This is obviously incorrect, but the field was introduced at the same
+  // time at which we introduced the more correct per-instrument summaries,
+  // so we know that old code couldn't use this (broken) field, and new code
+  // should use the correct summaries.
+  instrumentId: { admin: "", id: "" },
+  numInputs: 0,
+  numOutputs: 0,
+  inputAmount: "0",
+  outputAmount: "0",
+  amountChange: "0"
+};
+
+exports.AllKnownMetaKeys = AllKnownMetaKeys;
+exports.BurnedMetaKey = BurnedMetaKey;
+exports.ReasonMetaKey = ReasonMetaKey;
+exports.SenderMetaKey = SenderMetaKey;
+exports.TokenStandardTransactionInterfaces = TokenStandardTransactionInterfaces;
+exports.TransactionParser = TransactionParser;
+exports.TxKindMetaKey = TxKindMetaKey;
+exports.ensureInterfaceViewIsPresent = ensureInterfaceViewIsPresent;
+exports.getInterfaceView = getInterfaceView;
+exports.getKnownInterfaceView = getKnownInterfaceView;
+exports.getMetaKeyValue = getMetaKeyValue;
+exports.hasInterface = hasInterface;
+exports.matchInterfaceIds = matchInterfaceIds;
+exports.mergeMetas = mergeMetas;
+exports.removeParsedMetaKeys = removeParsedMetaKeys;
+exports.renderTransaction = renderTransaction;
+exports.splitInterfaceId = splitInterfaceId;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map