fix(app2): retry and last throws

Author: Swepool

app2/src/lib/components/Transfer/transfer.svelte.ts

@@ -6,13 +6,21 @@ import {
   hasFailedExit as hasCosmosFailedExit,
   isComplete as isCosmosComplete,
   nextState as cosmosNextState,
-  TransferSubmission as CosmosTransferSubmission
+  TransferSubmission as CosmosTransferSubmission,
+  SwitchChainState,
+  ApprovalSubmitState,
+  TransferSubmitState
 } from "$lib/services/transfer-ucs03-cosmos"
 import {
   hasFailedExit as hasEvmFailedExit,
   isComplete as isEvmComplete,
   nextState as evmNextState,
-  TransferSubmission as EvmTransferSubmission
+  TransferSubmission as EvmTransferSubmission,
+  SwitchChainState as EvmSwitchChainState,
+  ApprovalSubmitState as EvmApprovalSubmitState,
+  ApprovalReceiptState,
+  TransferSubmitState as EvmTransferSubmitState,
+  TransferReceiptState
 } from "$lib/services/transfer-ucs03-evm"
 import { chains } from "$lib/stores/chains.svelte.ts"
 import { type Address, fromHex, type Hex } from "viem"
@@ -291,8 +299,45 @@ export class Transfer {
     const sourceChainValue = this.sourceChain.value
 
     if (sourceChainValue.rpc_type === "evm") {
-      const evmState =
-        this.state._tag === "EVM" ? this.state.state : EvmTransferSubmission.Filling()
+      let evmState: EvmTransferSubmission
+      if (this.state._tag === "EVM") {
+        // If failed, reset the failed step to InProgress
+        if (hasEvmFailedExit(this.state.state)) {
+          switch (this.state.state._tag) {
+            case "SwitchChain":
+              evmState = EvmTransferSubmission.SwitchChain({
+                state: EvmSwitchChainState.InProgress()
+              })
+              break
+            case "ApprovalSubmit":
+              evmState = EvmTransferSubmission.ApprovalSubmit({
+                state: EvmApprovalSubmitState.InProgress()
+              })
+              break
+            case "ApprovalReceipt":
+              evmState = EvmTransferSubmission.ApprovalReceipt({
+                state: ApprovalReceiptState.InProgress({ hash: this.state.state.state.hash })
+              })
+              break
+            case "TransferSubmit":
+              evmState = EvmTransferSubmission.TransferSubmit({
+                state: EvmTransferSubmitState.InProgress()
+              })
+              break
+            case "TransferReceipt":
+              evmState = EvmTransferSubmission.TransferReceipt({
+                state: TransferReceiptState.InProgress({ hash: this.state.state.state.hash })
+              })
+              break
+            default:
+              evmState = EvmTransferSubmission.Filling()
+          }
+        } else {
+          evmState = this.state.state
+        }
+      } else {
+        evmState = EvmTransferSubmission.Filling()
+      }
 
       const newState = await evmNextState(evmState, this.transferResult.args, sourceChainValue)
       this._stateOverride = newState !== null ? TransferState.EVM(newState) : TransferState.Empty()
@@ -311,8 +356,35 @@ export class Transfer {
         if (currentEvmState !== null && isEvmComplete(currentEvmState)) break
       }
     } else {
-      const cosmosState =
-        this.state._tag === "Cosmos" ? this.state.state : CosmosTransferSubmission.Filling()
+      let cosmosState: CosmosTransferSubmission
+      if (this.state._tag === "Cosmos") {
+        // If failed, reset the failed step to InProgress
+        if (hasCosmosFailedExit(this.state.state)) {
+          switch (this.state.state._tag) {
+            case "SwitchChain":
+              cosmosState = CosmosTransferSubmission.SwitchChain({
+                state: SwitchChainState.InProgress()
+              })
+              break
+            case "ApprovalSubmit":
+              cosmosState = CosmosTransferSubmission.ApprovalSubmit({
+                state: ApprovalSubmitState.InProgress()
+              })
+              break
+            case "TransferSubmit":
+              cosmosState = CosmosTransferSubmission.TransferSubmit({
+                state: TransferSubmitState.InProgress()
+              })
+              break
+            default:
+              cosmosState = CosmosTransferSubmission.Filling()
+          }
+        } else {
+          cosmosState = this.state.state
+        }
+      } else {
+        cosmosState = CosmosTransferSubmission.Filling()
+      }
 
       const newState = await cosmosNextState(
         cosmosState,

app2/src/lib/services/cosmos/clients.ts

@@ -11,9 +11,11 @@ import { CosmWasmError } from "$lib/services/transfer-ucs03-cosmos"
 export const getCosmWasmClient = (chain: Chain, connectedWallet: CosmosWalletId) =>
   Effect.gen(function* () {
     if (!chain.rpcs) {
-      throw new CosmWasmError({
-        cause: "No RPCs available for chain"
-      })
+      return yield* Effect.fail(
+        new CosmWasmError({
+          cause: "No RPCs available for chain"
+        })
+      )
     }
 
     const offlineSigner = yield* Effect.mapError(
@@ -25,10 +27,9 @@ export const getCosmWasmClient = (chain: Chain, connectedWallet: CosmosWalletId)
     )
 
     if (!offlineSigner) {
-      throw new CosmWasmError({ cause: "Offline signer is undefined" })
+      return yield* Effect.fail(new CosmWasmError({ cause: "Offline signer is undefined" }))
     }
 
-    // Get gas price
     const gasPriceInfo = yield* Effect.mapError(
       getGasPriceForChain(chain, connectedWallet),
       error =>
@@ -41,9 +42,11 @@ export const getCosmWasmClient = (chain: Chain, connectedWallet: CosmosWalletId)
 
     const rpcUrl = chain.getRpcUrl("rpc")
     if (Option.isNone(rpcUrl)) {
-      throw new CosmWasmError({
-        cause: "No RPC URL of type 'rpc' available for chain"
-      })
+      return yield* Effect.fail(
+        new CosmWasmError({
+          cause: "No RPC URL of type 'rpc' available for chain"
+        })
+      )
     }
 
     return yield* Effect.tryPromise({
@@ -65,23 +68,22 @@ export const getCosmosPublicClient = (rpc: URL | string) =>
       return CosmWasmClient.connect(rpcString)
     },
     catch: err =>
-      new Error(`Failed to create CosmWasm client with RPC ${rpc} ${err}`, { cause: err })
+      new CosmWasmError({
+        cause: `Failed to create CosmWasm client with RPC ${rpc}: ${String(err)}`
+      })
   })
 
-export const getCosmosWalletClient = (): Effect.Effect<CosmosWallet, Error, never> =>
-  Effect.try({
-    try: () => {
-      const { connectedWallet, connectionStatus } = cosmosStore
-      if (connectionStatus === "connected" && connectedWallet) {
-        // Type assertion to help TypeScript understand this will be a cosmos wallet
-        const wallet = window[connectedWallet as keyof Window] as CosmosWallet
-        if (!wallet) {
-          throw new Error(`Wallet ${connectedWallet} not found`)
-        }
-        return wallet
-      }
+export const getCosmosWalletClient = (): Effect.Effect<CosmosWallet, CosmWasmError, never> =>
+  Effect.gen(function* () {
+    const { connectedWallet, connectionStatus } = cosmosStore
+    if (connectionStatus !== "connected" || !connectedWallet) {
+      return yield* Effect.fail(new CosmWasmError({ cause: "Wallet not connected" }))
+    }
 
-      throw new Error("Wallet not connected")
-    },
-    catch: err => new Error(`Failed to get cosmos wallet client`, { cause: err })
+    const wallet = window[connectedWallet as keyof Window] as CosmosWallet
+    if (!wallet) {
+      return yield* Effect.fail(new CosmWasmError({ cause: `Wallet ${connectedWallet} not found` }))
+    }
+
+    return wallet
   })