canton-amm-ledger-core 0.0.6 → 0.0.8

package/dist/src/main.js

@@ -1,14 +1,15 @@
 import { LedgerError, } from "./lib/ledger_json_api/client.js";
 import { z } from "zod";
-import { AmmSchema, UserRole, AmmState, AddLpProviderResultSchema, RemoveLpProviderResultSchema, AddSwapUserResultSchema, RemoveSwapUserResultSchema, CreateLiquidityAdditionAllocationRequestResultSchema, CreateLiquidityRemovalAllocationRequestResultSchema, CreateSwapAllocationRequestResultSchema, AddLpProviderArgsSchema, RemoveLpProviderArgsSchema, RemoveSwapUserArgsSchema, AddSwapUserArgsSchema, CreateLiquidityAdditionAllocationRequestArgsSchema, CancelProcessingArgsSchema, CancelProcessingResultSchema, CompleteProcessingArgsSchema, CompleteProcessingResultSchema, UpdateFeeRateResultSchema, UpdateFeeRateArgsSchema, UpdateSettlementExecutorArgsSchema, UpdateSettlementExecutorResultSchema, UpdateLpAdditionTimeInMicrosecondsArgsSchema, UpdateLpAdditionTimeInMicrosecondsResultSchema, UpdateLpRemovalTimeInMicrosecondsArgsSchema, UpdateLpRemovalTimeInMicrosecondsResultSchema, UpdateSwapTimeInMicrosecondsArgsSchema, UpdateSwapTimeInMicrosecondsResultSchema, AddAllocationToCurrentRequestResultSchema, AddAllocationToCurrentRequestArgsSchema, WithdrawAllocationFromCurrentRequestResultSchema, WithdrawAllocationFromCurrentRequestArgsSchema, CreateLiquidityRemovalAllocationRequestArgsSchema, CreateSwapAllocationRequestArgsSchema, AllocationViewSchema, AmmAllocationRequestViewSchema, AllocateRequiredOperatorFundsForCurrentRequestArgsSchema, AllocateRequiredOperatorFundsForCurrentRequestResultSchema, AddAmmManagerArgsSchema, AddAmmManagerResultSchema, RemoveAmmManagerResultSchema, RemoveAmmManagerArgsSchema, HoldingViewSchema, TransferInstructionSchema, TransferPreapprovalSchema, MergeDelegationProposalSchema, MergeDelegationSchema, ExerciseTransferInstructionChoiceResultSchema, ExecuteMergeDelegationProposalChoiceResultSchema, TransferInstructionResultSchema, FeaturedAppRightViewSchema, FeaturedAppActivityMarkerViewSchema, UpdateOperatorFeeRateArgsSchema, UpdateOperatorFeeRateResultSchema, } from "./schema.js";
+import { AmmSchema, UserRole, AmmState, AddLpProviderResultSchema, RemoveLpProviderResultSchema, AddSwapUserResultSchema, RemoveSwapUserResultSchema, CreateLiquidityAdditionAllocationRequestResultSchema, CreateLiquidityRemovalAllocationRequestResultSchema, CreateSwapAllocationRequestResultSchema, AddLpProviderArgsSchema, RemoveLpProviderArgsSchema, RemoveSwapUserArgsSchema, AddSwapUserArgsSchema, CreateLiquidityAdditionAllocationRequestArgsSchema, CancelProcessingArgsSchema, CancelProcessingResultSchema, CompleteProcessingArgsSchema, CompleteProcessingResultSchema, UpdateFeeRateResultSchema, UpdateFeeRateArgsSchema, UpdateSettlementExecutorArgsSchema, UpdateSettlementExecutorResultSchema, UpdateLpAdditionTimeInMicrosecondsArgsSchema, UpdateLpAdditionTimeInMicrosecondsResultSchema, UpdateLpRemovalTimeInMicrosecondsArgsSchema, UpdateLpRemovalTimeInMicrosecondsResultSchema, UpdateSwapTimeInMicrosecondsArgsSchema, UpdateSwapTimeInMicrosecondsResultSchema, AddAllocationToCurrentRequestResultSchema, AddAllocationToCurrentRequestArgsSchema, WithdrawAllocationFromCurrentRequestResultSchema, WithdrawAllocationFromCurrentRequestArgsSchema, CreateLiquidityRemovalAllocationRequestArgsSchema, CreateSwapAllocationRequestArgsSchema, AllocationViewSchema, AmmAllocationRequestViewSchema, AllocateRequiredOperatorFundsForCurrentRequestArgsSchema, AllocateRequiredOperatorFundsForCurrentRequestResultSchema, AddAmmManagerArgsSchema, AddAmmManagerResultSchema, RemoveAmmManagerResultSchema, RemoveAmmManagerArgsSchema, HoldingViewSchema, TransferInstructionSchema, TransferPreapprovalSchema, MergeDelegationProposalSchema, MergeDelegationSchema, ExerciseTransferInstructionChoiceResultSchema, ExecuteMergeDelegationProposalChoiceResultSchema, TransferInstructionResultSchema, TransferSchema, FeaturedAppRightViewSchema, FeaturedAppActivityMarkerViewSchema, UpdateOperatorFeeRateArgsSchema, UpdateOperatorFeeRateResultSchema, } from "./schema.js";
 import { Allocation, AllocationView as DtAllocationView, } from "@daml.js/splice-api-token-allocation-v1-1.0.0/lib/Splice/Api/Token/AllocationV1/module.js";
 import { Holding, HoldingView as DHoldingView, } from "@daml.js/splice-api-token-holding-v1-1.0.0/lib/Splice/Api/Token/HoldingV1/module.js";
-import { IAmmAllocationRequest } from "@daml.js/type7labs-api-amm-v0-0.0.1/lib/Type7Labs/Api/Amm/IAmmAllocationRequest/module.js";
-import { AmmView, IAmm, } from "@daml.js/type7labs-api-amm-v0-0.0.1/lib/Type7Labs/Api/Amm/IAmm/module.js";
-import { AmmV0 } from "@daml.js/type7labs-amm-v0-v0-0.0.1/lib/Type7Labs/Amm/AmmV0/module.js";
+import { IAmmAllocationRequest } from "@daml.js/type7labs-api-amm-v1-0.0.1/lib/Type7Labs/Api/Amm/IAmmAllocationRequest/module.js";
+import { AmmView, IAmm, } from "@daml.js/type7labs-api-amm-v1-0.0.1/lib/Type7Labs/Api/Amm/IAmm/module.js";
+import { AmmV0 } from "@daml.js/type7labs-amm-v0-v1-0.0.1/lib/Type7Labs/Amm/AmmV0/module.js";
 import { emptyMap } from "@daml/types";
 import { DAML_DECIMAL_PRECISION, EXTERNAL_PARTY_COMMAND_COMPLETION_FETCH_RETRIES_COUNT, EXTERNAL_PARTY_TRANSACTION_UPDATE_FETCH_RETRIES_COUNT, } from "./constant.js";
 import { FeaturedAppActivityMarker, FeaturedAppRight, } from "@daml.js/splice-api-featured-app-v1-1.0.0/lib/Splice/Api/FeaturedAppRightV1/module.js";
+import BigNumber from "bignumber.js";
 export class LedgerCoreError extends Error {
     partyId;
     contractId;
@@ -899,17 +900,17 @@ export async function createAmmV0(user, client, logger, createAmmChoiceArgs) {
                                 swapUsers: [],
                                 tokenX: {
                                     id: createAmmChoiceArgs.tokenX,
-                                    amount: "0.0",
+                                    amount: "0",
                                 },
                                 tokenY: {
                                     id: createAmmChoiceArgs.tokenY,
-                                    amount: "0.0",
+                                    amount: "0",
                                 },
                                 // tokenLp: {
                                 //   id: createAmmChoiceArgs.tokenLp,
-                                //   amount: "0.0",
+                                //   amount: "0",
                                 // },
-                                tokenLpTotal: "0.0",
+                                tokenLpTotal: "0",
                                 tokenLpDistribution: emptyMap(),
                                 settlementFactoryData: {
                                     settlementExecutor: createAmmChoiceArgs.settlementFactoryData
@@ -919,18 +920,18 @@ export async function createAmmV0(user, client, logger, createAmmChoiceArgs) {
                                     swapTimeInMicroseconds: createAmmChoiceArgs.settlementFactoryData.swapTimeInMicroseconds.toString(),
                                     metadata: createAmmChoiceArgs.metadata,
                                 },
-                                fee: createAmmChoiceArgs.fee.toFixed(DAML_DECIMAL_PRECISION),
-                                operatorFee: createAmmChoiceArgs.operatorFee.toFixed(DAML_DECIMAL_PRECISION),
+                                fee: createAmmChoiceArgs.fee.toString(),
+                                operatorFee: createAmmChoiceArgs.operatorFee.toString(),
                                 changesOnProcessingCompletion: {
-                                    deltaX: "0.0",
-                                    deltaY: "0.0",
-                                    deltaLp: "0.0",
-                                    operatorFee: "0.0",
+                                    deltaX: "0",
+                                    deltaY: "0",
+                                    deltaLp: "0",
+                                    operatorFee: "0",
                                     deducibleFromX: false,
                                 },
                                 processingAllocationRequest: null,
                                 metadata: createAmmChoiceArgs.metadata,
-                                initial_liquidity_to_burn: createAmmChoiceArgs.initialLiquidityToBurn.toFixed(DAML_DECIMAL_PRECISION),
+                                initial_liquidity_to_burn: createAmmChoiceArgs.initialLiquidityToBurn.toString(),
                             }),
                         },
                     },
@@ -1121,9 +1122,9 @@ const CHOICE_CONFIGS = {
     createLiquidityAdditionRequest: createChoiceConfig(IAmm.CreateLiquidityAdditionAllocationRequest.choiceName, CreateLiquidityAdditionAllocationRequestArgsSchema, CreateLiquidityAdditionAllocationRequestResultSchema, async (_, args) => {
         return {
             provider: args.provider,
-            tokenXAmount: args.tokenXAmount.toFixed(DAML_DECIMAL_PRECISION),
-            tokenYAmount: args.tokenYAmount.toFixed(DAML_DECIMAL_PRECISION),
-            minLpTokenAmount: args.minLpTokenAmount.toFixed(DAML_DECIMAL_PRECISION),
+            tokenXAmount: args.tokenXAmount.toString(),
+            tokenYAmount: args.tokenYAmount.toString(),
+            minLpTokenAmount: args.minLpTokenAmount.toString(),
             extraArgs: args.extraArgs,
             records: args.records.map((record) => ({
                 transferLegId: record.transferLegId,
@@ -1140,9 +1141,9 @@ const CHOICE_CONFIGS = {
     createLiquidityRemovalRequest: createChoiceConfig(IAmm.CreateLiquidityRemovalAllocationRequest.choiceName, CreateLiquidityRemovalAllocationRequestArgsSchema, CreateLiquidityRemovalAllocationRequestResultSchema, async (_, args) => {
         return {
             provider: args.provider,
-            lpTokenAmount: args.lpTokenAmount.toFixed(DAML_DECIMAL_PRECISION),
-            minTokenXAmount: args.minTokenXAmount.toFixed(DAML_DECIMAL_PRECISION),
-            minTokenYAmount: args.minTokenYAmount.toFixed(DAML_DECIMAL_PRECISION),
+            lpTokenAmount: args.lpTokenAmount.toString(),
+            minTokenXAmount: args.minTokenXAmount.toString(),
+            minTokenYAmount: args.minTokenYAmount.toString(),
             extraArgs: args.extraArgs,
             // records: args.records.map((record) => ({
             //   transferLegId: record.transferLegId,
@@ -1160,8 +1161,8 @@ const CHOICE_CONFIGS = {
         return {
             swapUser: args.user,
             isXtoY: args.isXtoY,
-            inputTokenAmount: args.inputTokenAmount.toFixed(DAML_DECIMAL_PRECISION),
-            minOutputTokenAmount: args.minOutputTokenAmount.toFixed(DAML_DECIMAL_PRECISION),
+            inputTokenAmount: args.inputTokenAmount.toString(),
+            minOutputTokenAmount: args.minOutputTokenAmount.toString(),
             extraArgs: args.extraArgs,
             records: args.records.map((record) => ({
                 transferLegId: record.transferLegId,
@@ -1239,14 +1240,14 @@ const CHOICE_CONFIGS = {
     updateFeeRate: createChoiceConfig(IAmm.UpdateFeeRate.choiceName, UpdateFeeRateArgsSchema, UpdateFeeRateResultSchema, async (_, args) => {
         return {
             manager: args.manager,
-            newFeeRate: args.newFeeRate.toFixed(DAML_DECIMAL_PRECISION),
+            newFeeRate: args.newFeeRate.toString(),
             extraArgs: args.extraArgs,
         };
     }, IAmm.UpdateFeeRate.argumentEncode),
     updateOperatorFeeRate: createChoiceConfig(IAmm.UpdateOperatorFeeRate.choiceName, UpdateOperatorFeeRateArgsSchema, UpdateOperatorFeeRateResultSchema, async (_, args) => {
         return {
             manager: args.manager,
-            newOperatorFeeRate: args.newOperatorFeeRate.toFixed(DAML_DECIMAL_PRECISION),
+            newOperatorFeeRate: args.newOperatorFeeRate.toString(),
             extraArgs: args.extraArgs,
         };
     }, IAmm.UpdateOperatorFeeRate.argumentEncode),
@@ -1422,11 +1423,11 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
         throw await errorHandler(error);
     }
     await externalSigner.statusUpdates?.("submitted");
-    let completionResult = null;
+    let applicableUpdateId = null;
     try {
         for (let i = 0; i < EXTERNAL_PARTY_COMMAND_COMPLETION_FETCH_RETRIES_COUNT; i++) {
             try {
-                completionResult = await client
+                const completionResult = await client
                     .path("/v2/commands/completions")
                     .method("post")
                     .create()({
@@ -1438,9 +1439,36 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
                     message: "Completion result",
                     completionResult: completionResult,
                 });
-                if (completionResult.data.length > 0) {
+                if (!completionResult) {
+                    if (i < EXTERNAL_PARTY_COMMAND_COMPLETION_FETCH_RETRIES_COUNT - 1) {
+                        await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, i)));
+                    }
+                    continue;
+                }
+                // Find the applicable completion with all validations
+                const foundCompletion = completionResult.data.find((completion) => {
+                    if (!("Completion" in completion.completionResponse))
+                        return false;
+                    if (!(completion.completionResponse.Completion.value.actAs || []).includes(user.partyId))
+                        return false;
+                    if (completion.completionResponse.Completion.value.commandId !==
+                        commandId)
+                        return false;
+                    if (completion.completionResponse.Completion.value.submissionId !==
+                        submissionId)
+                        return false;
+                    return true;
+                });
+                if (foundCompletion) {
+                    // for type safety, check if Completion is present
+                    if (!("Completion" in foundCompletion.completionResponse)) {
+                        throw await getLedgerCoreApiError("response_parsing", "Completion is not present", null, user.partyId, null, null);
+                    }
+                    applicableUpdateId =
+                        foundCompletion.completionResponse.Completion.value.updateId;
                     break;
                 }
+                // If we didn't find the applicable completion, retry
                 if (i < EXTERNAL_PARTY_COMMAND_COMPLETION_FETCH_RETRIES_COUNT - 1) {
                     await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, i)));
                 }
@@ -1456,32 +1484,9 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
     catch (error) {
         throw await errorHandler(error);
     }
-    if (!completionResult) {
-        throw await getLedgerCoreApiError("offchain_validation", "No completion result found", null, user.partyId, null, null);
-    }
-    const applicableCompletion = completionResult.data.find((completion) => {
-        if (!("Completion" in completion.completionResponse))
-            return false;
-        if (!(completion.completionResponse.Completion.value.actAs || []).includes(user.partyId))
-            return false;
-        if (completion.completionResponse.Completion.value.commandId !== commandId)
-            return false;
-        if (completion.completionResponse.Completion.value.submissionId !==
-            submissionId)
-            return false;
-        return true;
-    })?.completionResponse || null;
-    if (!applicableCompletion) {
-        throw await getLedgerCoreApiError("offchain_validation", "No applicable completion found", null, user.partyId, null, null);
-    }
-    if (!("Completion" in applicableCompletion)) {
-        throw await getLedgerCoreApiError("response_parsing", "Completion is not present", null, user.partyId, null, null);
+    if (!applicableUpdateId) {
+        throw await getLedgerCoreApiError("offchain_validation", "No applicable update ID found", null, user.partyId, null, null);
     }
-    const applicableUpdateId = applicableCompletion.Completion.value.updateId;
-    logger.debug({
-        message: "Applicable update ID",
-        applicableUpdateId: applicableUpdateId,
-    });
     let transactionByUpdateIdResponse = null;
     try {
         for (let i = 0; i < EXTERNAL_PARTY_TRANSACTION_UPDATE_FETCH_RETRIES_COUNT; i++) {
@@ -1506,7 +1511,6 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
                             },
                             verbose: false,
                         },
-                        // todo check this
                         transactionShape: "TRANSACTION_SHAPE_LEDGER_EFFECTS",
                     },
                 });
@@ -1515,15 +1519,6 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
                     transactionByUpdateIdResponse: transactionByUpdateIdResponse,
                     attempt: i + 1,
                 });
-                if (transactionByUpdateIdResponse?.data?.transaction !== null &&
-                    transactionByUpdateIdResponse?.data?.transaction !== undefined) {
-                    break;
-                }
-                // If transaction is null/undefined, wait before retrying
-                if (i < EXTERNAL_PARTY_TRANSACTION_UPDATE_FETCH_RETRIES_COUNT - 1) {
-                    // Wait with exponential backoff: 100ms, 200ms, 400ms, 800ms
-                    await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, i)));
-                }
             }
             catch (error) {
                 logger.debug({
@@ -1546,10 +1541,6 @@ async function executeExternalPartyExerciseCommand(user, client, logger, command
     if (!transactionByUpdateIdResponse) {
         throw await getLedgerCoreApiError("query", "Failed to get transaction by update ID", null, user.partyId, null, null);
     }
-    if (!transactionByUpdateIdResponse.data ||
-        !transactionByUpdateIdResponse.data.transaction) {
-        throw await getLedgerCoreApiError("query", `Transaction not found for update ID ${applicableUpdateId} after retries. Response: ${JSON.stringify(transactionByUpdateIdResponse)}`, null, user.partyId, null, null);
-    }
     return transactionByUpdateIdResponse.data.transaction;
 }
 export async function exerciseAmmChoice(user, client, logger, choiceName, args, externalSigner) {
@@ -2553,4 +2544,365 @@ export async function getFeaturedAppActivityMarkersVisibleToParty(user, client,
         featuredAppActivityMarker: featuredAppActivityMarker,
     }));
 }
+export async function getLatestPrunedOffsets(client) {
+    try {
+        return (await client
+            .path("/v2/state/latest-pruned-offsets")
+            .method("get")
+            .create()({})).data.participantPrunedUpToInclusive;
+    }
+    catch (error) {
+        throw await getLedgerCoreApiError("query", "An unexpected error occurred in query error handler for get latest pruned offsets", error, null, null, null);
+    }
+}
+const InterfaceViewSchema = z.object({
+    interfaceId: z.string(),
+    viewStatus: z.unknown(),
+    viewValue: z.unknown().optional(),
+});
+const CreatedEventSchema = z.object({
+    contractId: z.string(),
+    templateId: z.string().optional(),
+    interfaceViews: z.array(InterfaceViewSchema).optional(),
+    effectiveAt: z.string().optional(),
+    offset: z.number().optional(),
+    nodeId: z.number().optional(),
+});
+const ExercisedEventSchema = z.object({
+    contractId: z.string(),
+    choice: z.string(),
+    choiceArgument: z.unknown().optional(),
+    exerciseResult: TransferInstructionResultSchema.optional(),
+    effectiveAt: z.string().optional(),
+    offset: z.number().optional(),
+    nodeId: z.number().optional(),
+});
+const ArchivedEventSchema = z.object({
+    contractId: z.string(),
+    templateId: z.string().optional(),
+    offset: z.number().optional(),
+    nodeId: z.number().optional(),
+});
+const EventSchema = z.union([
+    z.object({ CreatedEvent: CreatedEventSchema }),
+    z.object({ ExercisedEvent: ExercisedEventSchema }),
+    z.object({ ArchivedEvent: ArchivedEventSchema }),
+]);
+const JsTransactionSchema = z.object({
+    updateId: z.string(),
+    commandId: z.string().optional(),
+    workflowId: z.string().optional(),
+    effectiveAt: z.string(),
+    events: z.array(EventSchema).optional(),
+    offset: z.number(),
+    synchronizerId: z.string().optional(),
+    recordTime: z.string().optional(),
+});
+const TransactionSchema = z.object({
+    value: JsTransactionSchema,
+});
+const UpdateResponseSchema = z.object({
+    update: z.union([
+        z.object({ Transaction: TransactionSchema }),
+        z.object({ OffsetCheckpoint: z.unknown() }),
+        z.object({ Reassignment: z.unknown() }),
+        z.object({ TopologyTransaction: z.unknown() }),
+    ]),
+});
+const UpdatesResponseSchema = z.array(UpdateResponseSchema);
+// Schema for TransferFactory_Transfer choice argument
+const TransferChoiceArgumentSchema = z.object({
+    transfer: TransferSchema,
+});
+export async function getHistoryForParty(user, client, logger, beginExclusive) {
+    let startOffset = beginExclusive;
+    if (startOffset === undefined) {
+        try {
+            startOffset = await getLatestPrunedOffsets(client);
+        }
+        catch (error) {
+            if (error instanceof LedgerCoreError) {
+                throw error;
+            }
+            throw await getLedgerCoreApiError("query", "An unexpected error occurred in query error handler for get latest pruned offsets", error, user.partyId, null, null);
+        }
+    }
+    const TOKEN_STANDARD_INTERFACES = [
+        SPLICE_API_TOKEN_TRANSFER_INSTRUCTION_V1_TRANSFER_INSTRUCTION_INTERFACE_ID,
+        SPLICE_API_TOKEN_TRANSFER_INSTRUCTION_V1_TRANSFER_FACTORY_INTERFACE_ID,
+    ];
+    let updates = null;
+    try {
+        updates = (await client.path("/v2/updates/flats").method("post").create()({
+            updateFormat: {
+                includeTransactions: {
+                    eventFormat: {
+                        filtersByParty: {
+                            [user.partyId]: {
+                                cumulative: TOKEN_STANDARD_INTERFACES.map((i) => ({
+                                    identifierFilter: {
+                                        InterfaceFilter: {
+                                            value: {
+                                                interfaceId: i,
+                                                includeInterfaceView: true,
+                                                includeCreatedEventBlob: false,
+                                            },
+                                        },
+                                    },
+                                })),
+                            },
+                        },
+                        verbose: false,
+                    },
+                    transactionShape: "TRANSACTION_SHAPE_LEDGER_EFFECTS",
+                },
+            },
+            verbose: false,
+            beginExclusive: startOffset,
+        })).data;
+    }
+    catch (error) {
+        throw await getLedgerCoreApiError("query", "An unexpected error occurred in query error handler for get updates for party", error, user.partyId, null, null);
+    }
+    const activities = [];
+    let endExclusive = startOffset;
+    // Parse updates response with zod
+    const parsedUpdates = UpdatesResponseSchema.safeParse(updates);
+    if (!parsedUpdates.success) {
+        logger.debug({
+            message: "Failed to parse updates response",
+            error: parsedUpdates.error,
+        });
+        return {
+            activities,
+            beginExclusive: startOffset,
+            endExclusive,
+        };
+    }
+    // Helper to match interface IDs (handles both # prefix and package ID formats)
+    const matchesTransferInstructionInterface = (interfaceId) => interfaceId.endsWith(":Splice.Api.Token.TransferInstructionV1:TransferInstruction");
+    const transferInstructions = new Map();
+    // First pass: collect all events
+    for (const updateResponse of parsedUpdates.data) {
+        if (!("Transaction" in updateResponse.update))
+            continue;
+        const transaction = updateResponse.update.Transaction.value;
+        const timestamp = transaction.effectiveAt
+            ? new Date(transaction.effectiveAt)
+            : new Date();
+        const transactionId = transaction.updateId || transaction.offset?.toString() || "";
+        if (transaction.offset !== undefined) {
+            endExclusive = Math.max(endExclusive, transaction.offset);
+        }
+        if (!transaction.events)
+            continue;
+        for (const event of transaction.events) {
+            // Handle TransferInstruction CreatedEvent
+            if ("CreatedEvent" in event) {
+                const created = event.CreatedEvent;
+                const interfaceViews = created.interfaceViews || [];
+                const transferInstructionView = interfaceViews.find((view) => matchesTransferInstructionInterface(view.interfaceId));
+                if (transferInstructionView?.viewValue) {
+                    const parsedViewValue = TransferInstructionSchema.safeParse(transferInstructionView.viewValue);
+                    if (parsedViewValue.success) {
+                        const transfer = parsedViewValue.data.transfer;
+                        const isSender = transfer.sender === user.partyId;
+                        const isReceiver = transfer.receiver === user.partyId;
+                        if (isSender || isReceiver) {
+                            transferInstructions.set(created.contractId, {
+                                contractId: created.contractId,
+                                sender: transfer.sender,
+                                receiver: transfer.receiver,
+                                amount: transfer.amount,
+                                instrumentId: transfer.instrumentId,
+                                createTimestamp: timestamp,
+                                createTransactionId: transactionId,
+                            });
+                        }
+                    }
+                    else {
+                        logger.debug({
+                            message: "Failed to parse TransferInstruction view value",
+                            error: parsedViewValue.error,
+                            contractId: created.contractId,
+                        });
+                    }
+                }
+            }
+            // Handle ExercisedEvent
+            if ("ExercisedEvent" in event) {
+                const exercised = event.ExercisedEvent;
+                // Update transfer instruction final state
+                if (exercised.choice === "TransferInstruction_Accept") {
+                    const instruction = transferInstructions.get(exercised.contractId);
+                    if (instruction) {
+                        instruction.finalState = "accepted";
+                        instruction.finalTimestamp = timestamp;
+                        instruction.finalTransactionId = transactionId;
+                    }
+                }
+                else if (exercised.choice === "TransferInstruction_Reject") {
+                    const instruction = transferInstructions.get(exercised.contractId);
+                    if (instruction) {
+                        instruction.finalState = "rejected";
+                        instruction.finalTimestamp = timestamp;
+                        instruction.finalTransactionId = transactionId;
+                    }
+                }
+                else if (exercised.choice === "TransferInstruction_Withdraw") {
+                    const instruction = transferInstructions.get(exercised.contractId);
+                    if (instruction) {
+                        instruction.finalState = "withdrawn";
+                        instruction.finalTimestamp = timestamp;
+                        instruction.finalTransactionId = transactionId;
+                    }
+                }
+                // TransferFactory_Transfer - check exercise result
+                if (exercised.choice === "TransferFactory_Transfer") {
+                    if (exercised.choiceArgument && exercised.exerciseResult) {
+                        const parsedChoiceArgument = TransferChoiceArgumentSchema.safeParse(exercised.choiceArgument);
+                        if (parsedChoiceArgument.success) {
+                            const transfer = parsedChoiceArgument.data.transfer;
+                            const isSender = transfer.sender === user.partyId;
+                            const isReceiver = transfer.receiver === user.partyId;
+                            const result = exercised.exerciseResult.output;
+                            // Completed → sent/received
+                            if ("TransferInstructionResult_Completed" in result) {
+                                if (isSender) {
+                                    activities.push({
+                                        type: "sent",
+                                        id: transactionId,
+                                        timestamp,
+                                        instrumentId: transfer.instrumentId,
+                                        amount: transfer.amount,
+                                        receiver: transfer.receiver,
+                                        contractId: exercised.contractId,
+                                    });
+                                }
+                                if (isReceiver) {
+                                    activities.push({
+                                        type: "received",
+                                        id: transactionId,
+                                        timestamp,
+                                        instrumentId: transfer.instrumentId,
+                                        amount: transfer.amount,
+                                        sender: transfer.sender,
+                                        contractId: exercised.contractId,
+                                    });
+                                }
+                            }
+                            // Pending → handled by CreatedEvent (TransferInstruction created)
+                            // No action needed here as the pending transfer instruction will
+                            // appear in transferInstructions map from its CreatedEvent
+                            // Failed → failed activity
+                            if ("TransferInstructionResult_Failed" in result) {
+                                if (isSender || isReceiver) {
+                                    activities.push({
+                                        type: "failed",
+                                        id: transactionId,
+                                        timestamp,
+                                        instrumentId: transfer.instrumentId,
+                                        amount: transfer.amount,
+                                        otherParty: isSender ? transfer.receiver : transfer.sender,
+                                        contractId: exercised.contractId,
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            logger.debug({
+                                message: "Failed to parse TransferFactory_Transfer choice argument",
+                                error: parsedChoiceArgument.error,
+                                contractId: exercised.contractId,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Second pass: build activities from transfer instructions
+    for (const instruction of transferInstructions.values()) {
+        const isSender = instruction.sender === user.partyId;
+        const isReceiver = instruction.receiver === user.partyId;
+        if (instruction.finalState === "accepted") {
+            // Accepted → sent/received (hide the Create, show as completed transfer)
+            if (isSender) {
+                activities.push({
+                    type: "sent",
+                    id: instruction.finalTransactionId || instruction.createTransactionId,
+                    timestamp: instruction.finalTimestamp || instruction.createTimestamp,
+                    instrumentId: instruction.instrumentId,
+                    amount: instruction.amount,
+                    receiver: instruction.receiver,
+                    contractId: instruction.contractId,
+                });
+            }
+            if (isReceiver) {
+                activities.push({
+                    type: "received",
+                    id: instruction.finalTransactionId || instruction.createTransactionId,
+                    timestamp: instruction.finalTimestamp || instruction.createTimestamp,
+                    instrumentId: instruction.instrumentId,
+                    amount: instruction.amount,
+                    sender: instruction.sender,
+                    contractId: instruction.contractId,
+                });
+            }
+        }
+        else if (instruction.finalState === "rejected") {
+            activities.push({
+                type: "rejected",
+                id: instruction.finalTransactionId || instruction.createTransactionId,
+                timestamp: instruction.finalTimestamp || instruction.createTimestamp,
+                instrumentId: instruction.instrumentId,
+                amount: instruction.amount,
+                otherParty: isSender ? instruction.receiver : instruction.sender,
+                contractId: instruction.contractId,
+            });
+        }
+        else if (instruction.finalState === "withdrawn") {
+            activities.push({
+                type: "withdrawn",
+                id: instruction.finalTransactionId || instruction.createTransactionId,
+                timestamp: instruction.finalTimestamp || instruction.createTimestamp,
+                instrumentId: instruction.instrumentId,
+                amount: instruction.amount,
+                otherParty: isSender ? instruction.receiver : instruction.sender,
+                contractId: instruction.contractId,
+            });
+        }
+        else {
+            // No final state → pending
+            if (isSender) {
+                activities.push({
+                    type: "pending_outgoing",
+                    id: instruction.createTransactionId,
+                    timestamp: instruction.createTimestamp,
+                    instrumentId: instruction.instrumentId,
+                    amount: instruction.amount,
+                    receiver: instruction.receiver,
+                    contractId: instruction.contractId,
+                });
+            }
+            else if (isReceiver) {
+                activities.push({
+                    type: "pending_incoming",
+                    id: instruction.createTransactionId,
+                    timestamp: instruction.createTimestamp,
+                    instrumentId: instruction.instrumentId,
+                    amount: instruction.amount,
+                    sender: instruction.sender,
+                    contractId: instruction.contractId,
+                });
+            }
+        }
+    }
+    activities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    return {
+        activities,
+        beginExclusive: startOffset,
+        endExclusive,
+    };
+}
 //# sourceMappingURL=main.js.map