Merge branch 'main' into fix-witness-proof-endpoints

keyan-m · keyan-m · commit 90a451fa229b · 2025-06-17T13:11:03.000+02:00
diff --git a/demo/midgard-node/pnpm-lock.yaml b/demo/midgard-node/pnpm-lock.yaml
diff --git a/demo/midgard-node/src/transactions/state-queue/init.ts b/demo/midgard-node/src/transactions/state-queue/init.ts
@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { handleSignSubmit } from "../utils.js";
+import { ConfirmError, handleSignSubmit, SubmitError } from "../utils.js";
 import * as SDK from "@al-ft/midgard-sdk";
 import { AlwaysSucceeds } from "@/services/index.js";
 import { User } from "@/config.js";
@@ -14,5 +14,17 @@ export const stateQueueInit = Effect.gen(function* () {
     stateQueueMintingScript: mintScript,
   };
   const txBuilder = yield* SDK.Endpoints.initTxProgram(lucid, initParams);
-  return yield* handleSignSubmit(lucid, txBuilder);
+  const onSubmitFailure = (err: SubmitError) =>
+    Effect.gen(function* () {
+      yield* Effect.logError(`Sumbit tx error: ${err}`);
+      yield* Effect.fail(err.err);
+    });
+  const onConfirmFailure = (err: ConfirmError) =>
+    Effect.logError(`Confirm tx error: ${err}`);
+  return yield* handleSignSubmit(
+    lucid,
+    txBuilder,
+    onSubmitFailure,
+    onConfirmFailure,
+  );
 });
diff --git a/demo/midgard-node/src/transactions/state-queue/merge-to-confirm-state.ts b/demo/midgard-node/src/transactions/state-queue/merge-to-confirm-state.ts
@@ -12,7 +12,12 @@ import { findAllSpentAndProducedUTxOs } from "@/utils.js";
 import * as SDK from "@al-ft/midgard-sdk";
 import { LucidEvolution, Script, fromHex } from "@lucid-evolution/lucid";
 import { Effect, Metric } from "effect";
-import { fetchFirstBlockTxs, handleSignSubmit } from "../utils.js";
+import {
+  ConfirmError,
+  fetchFirstBlockTxs,
+  handleSignSubmit,
+  SubmitError,
+} from "../utils.js";
 
 const mergeBlockCounter = Metric.counter("merge_block_count", {
   description: "A counter for tracking merge blocks",
@@ -107,9 +112,19 @@ export const buildAndSubmitMergeTx = (
       ).pipe(Effect.withSpan("mergeToConfirmedStateProgram"));
 
       // Submit the transaction
-      yield* handleSignSubmit(lucid, txBuilder).pipe(
-        Effect.withSpan("handleSignSubmit-merge-tx"),
-      );
+      const onSubmitFailure = (err: SubmitError) =>
+        Effect.gen(function* () {
+          yield* Effect.logError(`Sumbit tx error: ${err}`);
+          yield* Effect.fail(err.err);
+        });
+      const onConfirmFailure = (err: ConfirmError) =>
+        Effect.logError(`Confirm tx error: ${err}`);
+      yield* handleSignSubmit(
+        lucid,
+        txBuilder,
+        onSubmitFailure,
+        onConfirmFailure,
+      ).pipe(Effect.withSpan("handleSignSubmit-merge-tx"));
       yield* Effect.logInfo(
         "🔸 Merge transaction submitted, updating the db...",
       );
diff --git a/demo/midgard-node/src/transactions/state-queue/reset.ts b/demo/midgard-node/src/transactions/state-queue/reset.ts
@@ -10,7 +10,7 @@ import {
 import { AlwaysSucceeds } from "@/services/index.js";
 import { User } from "@/config.js";
 import { Effect } from "effect";
-import { handleSignSubmit } from "../utils.js";
+import { ConfirmError, handleSignSubmit, SubmitError } from "../utils.js";
 
 const collectAndBurnStateQueueNodesProgram = (
   lucid: LucidEvolution,
@@ -35,7 +35,19 @@ const collectAndBurnStateQueueNodesProgram = (
       .attach.Script(stateQueueSpendingScript)
       .attach.Script(stateQueueMintingScript);
     const completed = yield* tx.completeProgram();
-    return yield* handleSignSubmit(lucid, completed);
+    const onSubmitFailure = (err: SubmitError) =>
+      Effect.gen(function* () {
+        yield* Effect.logError(`Sumbit tx error: ${err}`);
+        yield* Effect.fail(err.err);
+      });
+    const onConfirmFailure = (err: ConfirmError) =>
+      Effect.logError(`Confirm tx error: ${err}`);
+    return yield* handleSignSubmit(
+      lucid,
+      completed,
+      onSubmitFailure,
+      onConfirmFailure,
+    );
   });
 
 export const resetStateQueue = Effect.gen(function* () {
diff --git a/demo/midgard-node/src/transactions/utils.ts b/demo/midgard-node/src/transactions/utils.ts
@@ -6,7 +6,7 @@ import {
   UTxO,
   fromHex,
 } from "@lucid-evolution/lucid";
-import { Effect, Schedule } from "effect";
+import { Data, Effect, pipe, Schedule } from "effect";
 import * as BlocksDB from "../database/blocks.js";
 import * as ImmutableDB from "../database/immutable.js";
 import { Database } from "@/services/database.js";
@@ -21,26 +21,47 @@ import { Database } from "@/services/database.js";
 export const handleSignSubmit = (
   lucid: LucidEvolution,
   signBuilder: TxSignBuilder,
-): Effect.Effect<string, Error> =>
+  onSubmitFailure: (error: SubmitError) => Effect.Effect<void, Error>,
+  onConfirmFailure: (error: ConfirmError) => Effect.Effect<void, Error>,
+): Effect.Effect<string | void, Error> =>
   Effect.gen(function* () {
-    const signed = yield* signBuilder.sign.withWallet().completeProgram();
+    const signed = yield* signBuilder.sign
+      .withWallet()
+      .completeProgram()
+      .pipe(Effect.mapError((err) => new SignError({ err })));
     yield* Effect.logInfo("✉️  Submitting transaction...");
-    const txHash = yield* signed
-      .submitProgram()
-      .pipe(
-        Effect.retry(
-          Schedule.compose(Schedule.exponential(5_000), Schedule.recurs(5)),
-        ),
-      );
+    const txHash = yield* signed.submitProgram().pipe(
+      Effect.retry(
+        Schedule.compose(Schedule.exponential(5_000), Schedule.recurs(5)),
+      ),
+      Effect.mapError((err) => new SubmitError({ err })),
+    );
     yield* Effect.logInfo(`🚀 Transaction submitted: ${txHash}`);
     yield* Effect.logInfo(`⏳ Confirming Transaction...`);
-    yield* Effect.tryPromise(() => lucid.awaitTx(txHash, 10_000));
+    yield* Effect.tryPromise({
+      try: () => lucid.awaitTx(txHash, 10_000),
+      catch: (err: any) => new ConfirmError({ err, txHash }),
+    });
     yield* Effect.logInfo(`🎉 Transaction confirmed: ${txHash}`);
     yield* Effect.logInfo("⌛ Pausing for 10 seconds...");
     yield* Effect.sleep("10 seconds");
     yield* Effect.logInfo("✅ Pause ended.");
     return txHash;
-  });
+  }).pipe(
+    Effect.catchAll((err: HandleSignSubmitError) => {
+      switch (err._tag) {
+        case "SubmitError":
+          return onSubmitFailure(err);
+        case "ConfirmError":
+          return onConfirmFailure(err);
+        case "SignError":
+          return pipe(
+            Effect.logError(`Signing tx error: ${err.err}`),
+            Effect.flatMap(() => Effect.fail(err)),
+          );
+      }
+    }),
+  );
 
 /**
  * Handle the signing and submission of a transaction without waiting for the transaction to be confirmed.
@@ -50,19 +71,46 @@ export const handleSignSubmit = (
  */
 export const handleSignSubmitWithoutConfirmation = (
   signBuilder: TxSignBuilder,
-): Effect.Effect<string, Error> =>
+  onSubmitFailure: (error: SubmitError) => Effect.Effect<void, Error>,
+): Effect.Effect<string | void, Error> =>
   Effect.gen(function* () {
-    const signed = yield* signBuilder.sign.withWallet().completeProgram();
-    const txHash = yield* signed
-      .submitProgram()
-      .pipe(
-        Effect.retry(
-          Schedule.compose(Schedule.exponential(5_000), Schedule.recurs(5)),
-        ),
-      );
+    const signed = yield* signBuilder.sign
+      .withWallet()
+      .completeProgram()
+      .pipe(Effect.mapError((err) => new SignError({ err })));
+    const txHash = yield* signed.submitProgram().pipe(
+      Effect.retry(
+        Schedule.compose(Schedule.exponential(5_000), Schedule.recurs(5)),
+      ),
+      Effect.mapError((err) => new SubmitError({ err })),
+    );
     yield* Effect.logDebug(`🚀 Transaction submitted: ${txHash}`);
     return txHash;
-  });
+  }).pipe(
+    Effect.catchAll((err: SignError | SubmitError) =>
+      err._tag === "SubmitError"
+        ? onSubmitFailure(err)
+        : pipe(
+            Effect.logError(`Signing tx error: ${err.err}`),
+            Effect.flatMap(() => Effect.fail(err)),
+          ),
+    ),
+  );
+
+export type HandleSignSubmitError = SignError | SubmitError | ConfirmError;
+
+export class SignError extends Data.TaggedError("SignError")<{
+  readonly err: Error;
+}> {}
+
+export class SubmitError extends Data.TaggedError("SubmitError")<{
+  readonly err: Error;
+}> {}
+
+export class ConfirmError extends Data.TaggedError("ConfirmError")<{
+  readonly err: Error;
+  readonly txHash: string;
+}> {}
 
 /**
  * Fetch transactions of the first block by querying BlocksDB and ImmutableDB.
diff --git a/demo/midgard-node/src/workers/commit-block-header.ts b/demo/midgard-node/src/workers/commit-block-header.ts
@@ -8,7 +8,11 @@ import {
 } from "@/utils.js";
 import { makeAlwaysSucceedsServiceFn } from "@/services/always-succeeds.js";
 import { BlocksDB, ImmutableDB, MempoolDB } from "@/database/index.js";
-import { handleSignSubmit } from "@/transactions/utils.js";
+import {
+  ConfirmError,
+  handleSignSubmit,
+  SubmitError,
+} from "@/transactions/utils.js";
 import { fromHex, toHex } from "@lucid-evolution/lucid";
 import * as ETH from "@ethereumjs/mpt";
 import * as ETH_UTILS from "@ethereumjs/util";
@@ -22,11 +26,7 @@ const rootKey = ETH.ROOT_DB_KEY;
 
 const wrapper = (
   _input: WorkerInput,
-): Effect.Effect<
-  WorkerOutput,
-  Error,
-  NodeConfig | User | Database
-> =>
+): Effect.Effect<WorkerOutput, Error, NodeConfig | User | Database> =>
   Effect.gen(function* () {
     const nodeConfig = yield* NodeConfig;
     const { user: lucid } = yield* User;
@@ -200,9 +200,19 @@ const wrapper = (
 
       // Using sign and submit helper with confirmation so that databases are
       // only updated after a successful on-chain registration of the block.
-      yield* handleSignSubmit(lucid, txBuilder).pipe(
-        Effect.withSpan("handleSignSubmit-commit-block"),
-      );
+      const onSubmitFailure = (err: SubmitError) =>
+        Effect.gen(function* () {
+          yield* Effect.logError(`Sumbit tx error: ${err}`);
+          yield* Effect.fail(err.err);
+        });
+      const onConfirmFailure = (err: ConfirmError) =>
+        Effect.logError(`Confirm tx error: ${err}`);
+      yield* handleSignSubmit(
+        lucid,
+        txBuilder,
+        onSubmitFailure,
+        onConfirmFailure,
+      ).pipe(Effect.withSpan("handleSignSubmit-commit-block"));
 
       const batchSize = 100;
 
@@ -264,9 +274,7 @@ const wrapper = (
 
       return output;
     } else {
-      yield* Effect.logInfo(
-        "🔹 No transactions were found in MempoolDB",
-      );
+      yield* Effect.logInfo("🔹 No transactions were found in MempoolDB");
       const output: WorkerOutput = {
         txSize: 0,
         mempoolTxsCount: 0,
diff --git a/onchain/aiken/lib/midgard/common/utils.ak b/onchain/aiken/lib/midgard/common/utils.ak
@@ -258,8 +258,9 @@ pub fn authentic_value_has_tokens(
 }
 
 /// Traverses two lists in parallel, accumulating a value using the provided
-/// `with` function. The lists are traversed from right, and the smaller list
-/// determines the number of elements traversed.
+/// `with` function. The lists are traversed from left to right, stopping after
+/// the smaller list's elements are exhausted. However, the `with` function
+/// is applied in reverse order (i.e. right to left).
 pub fn zip_foldr(
   self: List<a>,
   bs: List<b>,
diff --git a/technical-spec/2-user-event-protocol/4-withdrawal-order.tex b/technical-spec/2-user-event-protocol/4-withdrawal-order.tex
@@ -32,7 +32,7 @@ \section{Withdrawal order (L1)}
     \item Send min-ADA to the Midgard withdrawal order address, along with the withdrawal order token and the above datum.
 \end{enumerate}
 
-\notebox{By adjusting incentives, users can be relieved from producing the withdrawal event utxo on L1 themselves, and rely on operators to take care of this second step.}
+\notebox{We could adapt Midgard's incentive structure to encourage operators to perform this second step on L1 on behalf of users, relieving users from this chore during normal protocol operation.}
 
 At the time of the L1 withdrawal order, its \code{inclusion\_time} is set to the sum of the L1 transaction's validity interval upper bound and the \code{event\_wait\_duration} Midgard protocol parameter.
 According to Midgard's ledger rules:
diff --git a/technical-spec/3-consensus-protocol/6-settlement-queue.tex b/technical-spec/3-consensus-protocol/6-settlement-queue.tex
@@ -62,7 +62,7 @@ \subsection{Minting policy}
           \item The transaction must burn the Midgard hub oracle NFT.
           \item The transaction must Deinit the \code{settlement\_queue} list.
       \end{enumerate}
-  \item[Append Settlement Node.] Append a settlement node to store a merged block's deposits, withdrawals and L2 transaction orders.
+  \item[Append Settlement Node.] Append a settlement node to store a merged block's deposits, withdrawals and transaction orders.
     Conditions:
       \begin{enumerate}
         \item The transaction must include the Midgard hub oracle NFT in a reference input.
@@ -123,7 +123,7 @@ \subsection{Spending validator}
         \item The spent input must be reproduced as a settlement node without a resolution claim.
         \item The transaction must include the Midgard hub oracle NFT in a reference input.
         \item Let \code{active\_operators}, \code{deposit}, \code{withdrawal}, and \code{tx\_order} be the corresponding policy IDs in the Midgard hub oracle.
-        \item The transaction must include either a deposit, a withdrawal, or an L2 transaction order as a reference input.
+        \item The transaction must include either a deposit, a withdrawal, or an transaction order as a reference input.
           Let that reference input be \code{unprocessed\_event}.
         \item A valid membership proof must be provided, proving that \code{unprocessed\_event} is a member of the corresponding tree in the settlement node.
         \item The transaction's time-validity upper bound must be earlier than the resolution claim's \code{resolution\_time}.
