Trade debugs

crates/common/src/lib.rs

@@ -9,6 +9,8 @@ pub mod fuzz;
 pub mod meta;
 pub mod rainlang;
 pub mod remove_order;
+#[cfg(not(target_family = "wasm"))]
+pub mod replays;
 pub mod subgraph;
 pub mod transaction;
 pub mod types;

crates/common/src/replays/mod.rs

@@ -0,0 +1,77 @@
+use alloy::primitives::B256;
+use rain_interpreter_eval::{
+    fork::{Forker, NewForkedEvm},
+    trace::RainEvalResult,
+};
+use url::Url;
+
+pub struct NewTradeReplayer {
+    pub fork_url: Url,
+}
+pub struct TradeReplayer {
+    forker: Forker,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum TradeReplayerError {
+    #[error("Forker error: {0}")]
+    ForkerError(#[from] rain_interpreter_eval::error::ForkCallError),
+}
+
+impl TradeReplayer {
+    pub async fn new(args: NewTradeReplayer) -> Result<Self, TradeReplayerError> {
+        let forker = Forker::new_with_fork(
+            NewForkedEvm {
+                fork_url: args.fork_url.to_string(),
+                fork_block_number: None,
+            },
+            None,
+            None,
+        )
+        .await?;
+
+        Ok(Self { forker })
+    }
+
+    pub async fn replay_tx(&mut self, tx_hash: B256) -> Result<RainEvalResult, TradeReplayerError> {
+        let res = self.forker.replay_transaction(tx_hash).await?;
+        Ok(res.into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy::primitives::U256;
+    use rain_orderbook_env::CI_DEPLOY_POLYGON_RPC_URL;
+    use std::str::FromStr;
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 10)]
+    async fn test_trade_replayer() {
+        let mut replayer = TradeReplayer::new(NewTradeReplayer {
+            fork_url: Url::from_str(CI_DEPLOY_POLYGON_RPC_URL).unwrap(),
+        })
+        .await
+        .unwrap();
+
+        let tx_hash: Result<alloy::primitives::FixedBytes<32>, alloy::hex::FromHexError> =
+            B256::from_str("0xceb48768613542fe2a05504200caa47dc19c4e508bd70ec3b18e648eebf58177");
+
+        let res = replayer.replay_tx(tx_hash.unwrap()).await.unwrap();
+
+        let vec = vec![
+            118952503035253418u128,
+            59922244745766602640u128,
+            7185901000000000000u128,
+            59922244745766602640u128,
+            713360056497221460u128,
+            1724882671000000000000000000u128,
+            1724882755000000000000000000,
+        ];
+
+        let expected_stack: Vec<U256> = vec.into_iter().map(U256::from).collect();
+
+        assert_eq!(res.traces[1].stack, expected_stack);
+        assert_eq!(res.traces.len(), 16);
+    }
+}

tauri-app/src-tauri/src/commands/mod.rs

@@ -8,5 +8,6 @@ pub mod dotrain_add_order_lsp;
 pub mod order;
 pub mod order_quote;
 pub mod order_take;
+pub mod trade_debug;
 pub mod vault;
 pub mod wallet;

tauri-app/src-tauri/src/commands/trade_debug.rs

@@ -0,0 +1,51 @@
+use alloy::primitives::{B256, U256};
+use rain_orderbook_common::replays::{NewTradeReplayer, TradeReplayer};
+
+use crate::error::CommandResult;
+
+#[tauri::command]
+pub async fn debug_trade(tx_hash: String, rpc_url: String) -> CommandResult<Vec<U256>> {
+    let mut replayer: TradeReplayer = TradeReplayer::new(NewTradeReplayer {
+        fork_url: rpc_url.parse()?,
+    })
+    .await?;
+    let tx_hash = tx_hash.parse::<B256>()?;
+    let res = replayer.replay_tx(tx_hash).await?;
+    let stack = res.traces[1].stack.iter().map(|x| x.clone()).collect();
+    Ok(stack)
+}
+
+#[cfg(test)]
+mod tests {
+    use rain_orderbook_env::CI_DEPLOY_POLYGON_RPC_URL;
+    use std::str::FromStr;
+
+    use super::*;
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 10)]
+    async fn test_trade_replayer() {
+        let tx_hash: Result<alloy::primitives::FixedBytes<32>, alloy::hex::FromHexError> =
+            B256::from_str("0xceb48768613542fe2a05504200caa47dc19c4e508bd70ec3b18e648eebf58177");
+
+        let res = debug_trade(
+            tx_hash.unwrap().to_string(),
+            CI_DEPLOY_POLYGON_RPC_URL.to_string(),
+        )
+        .await
+        .unwrap();
+
+        let vec = vec![
+            8255747967003398332u128,
+            5195342786557434200u128,
+            43067440648007307827u128,
+            5195342786557434200u128,
+            519534278655743420u128,
+            1724872944000000000000000000u128,
+            1724873082000000000000000000u128,
+        ];
+
+        let expected_stack: Vec<U256> = vec.into_iter().map(U256::from).collect();
+
+        assert_eq!(res, expected_stack);
+    }
+}

tauri-app/src-tauri/src/error.rs

@@ -90,6 +90,9 @@ pub enum CommandError {
 
     #[error(transparent)]
     FromUintParseError(#[from] FromUintParseError),
+
+    #[error(transparent)]
+    TradeReplayerError(#[from] rain_orderbook_common::replays::TradeReplayerError),
 }
 
 impl Serialize for CommandError {

tauri-app/src-tauri/src/main.rs

@@ -19,6 +19,7 @@ use commands::order::{
 };
 use commands::order_quote::batch_order_quotes;
 use commands::order_take::{order_takes_list, order_takes_list_write_csv};
+use commands::trade_debug::debug_trade;
 use commands::vault::{
     vault_balance_changes_list, vault_balance_changes_list_write_csv, vault_deposit,
     vault_deposit_approve_calldata, vault_deposit_calldata, vault_detail, vault_withdraw,
@@ -74,6 +75,7 @@ fn run_tauri_app() {
             get_authoring_meta_v2_for_scenarios,
             compose_from_scenario,
             batch_order_quotes,
+            debug_trade
             get_app_commit_sha,
             validate_raindex_version
         ])

tauri-app/src/lib/components/modal/ModalTradeDebug.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import { queryClient } from '$lib/queries/queryClient';
+  import { tradeDebug } from '$lib/queries/tradeDebug';
+  import { createQuery } from '@tanstack/svelte-query';
+  import {
+    Alert,
+    Modal,
+    Spinner,
+    Table,
+    TableBody,
+    TableBodyCell,
+    TableBodyRow,
+    TableHead,
+    TableHeadCell,
+  } from 'flowbite-svelte';
+  import { formatEther, hexToBigInt } from 'viem';
+
+  export let open: boolean;
+  export let txHash: string;
+  export let rpcUrl: string;
+
+  $: debugQuery = createQuery(
+    {
+      queryKey: [txHash + rpcUrl],
+      queryFn: () => {
+        return tradeDebug(txHash, rpcUrl);
+      },
+      retry: 0,
+    },
+    queryClient,
+  );
+</script>
+
+<Modal title="Debug trade" bind:open outsideclose size="lg">
+  <div class="flex flex-col gap-y-2 text-sm">
+    <span data-testid="modal-trade-debug-tx-hash">Trade transaction: {txHash}</span>
+    <span data-testid="modal-trade-debug-rpc-url">RPC: {rpcUrl}</span>
+  </div>
+  {#if $debugQuery.isLoading}
+    <div data-testid="modal-trade-debug-loading-message" class="flex items-center gap-x-2">
+      <Spinner size="4" />
+      <span>Replaying trade... this can take a while.</span>
+    </div>
+  {/if}
+  {#if $debugQuery.isError}
+    <Alert data-testid="modal-trade-debug-error" color="red">{$debugQuery.error}</Alert>
+  {/if}
+  {#if $debugQuery.data}
+    <Table divClass="cursor-pointer rounded-lg overflow-hidden dark:border-none border">
+      <TableHead>
+        <TableHeadCell>Stack item</TableHeadCell>
+        <TableHeadCell>Value</TableHeadCell>
+        <TableHeadCell>Hex</TableHeadCell>
+      </TableHead>
+      <TableBody>
+        {#each $debugQuery.data as value, i}
+          <TableBodyRow>
+            <TableBodyCell data-testid="modal-trade-debug-stack">{i}</TableBodyCell>
+            <TableBodyCell data-testid="modal-trade-debug-value"
+              >{formatEther(hexToBigInt(value))}</TableBodyCell
+            >
+            <TableBodyCell data-testid="modal-trade-debug-value-hex">{value}</TableBodyCell>
+          </TableBodyRow>
+        {/each}
+      </TableBody>
+    </Table>
+  {/if}
+</Modal>