feat(app2): consider L1 data fee for BOB

Signed-off-by: Eric Hegnes <[email protected]>

Author: ehegnes

app2/src/lib/gasprice/index.ts

@@ -1,6 +1,6 @@
 import { chainInfoMap } from "$lib/services/cosmos/chain-info/config"
 import { createViemPublicClient } from "@unionlabs/sdk/evm"
-import type { Chain } from "@unionlabs/sdk/schema"
+import { type Chain, NumberFromHexString, UniversalChainId } from "@unionlabs/sdk/schema"
 import {
   Array as A,
   BigDecimal,
@@ -11,9 +11,12 @@ import {
   Option as O,
   pipe,
   Record as R,
+  Schema as S,
   unsafeCoerce,
 } from "effect"
 import { type GetGasPriceErrorType, http } from "viem"
+import type * as V from "viem"
+import { publicActionsL2 } from "viem/op-stack"
 import { GasPriceError } from "./error"
 import * as GasPrice from "./service"
 
@@ -29,14 +32,22 @@ export class GasPriceMap extends LayerMap.Service<GasPriceMap>()("GasPriceByChai
         Layer.effect(
           GasPrice.GasPrice,
           Effect.gen(function*() {
-            const client = yield* pipe(
-              chain.toViemChain(),
-              Effect.flatMap((chain) =>
-                createViemPublicClient({
-                  chain,
-                  transport: http(),
+            const viemChain = yield* chain.toViemChain().pipe(
+              Effect.mapError((cause) =>
+                new GasPriceError({
+                  module: "Evm",
+                  method: "chain",
+                  description: "could not convert internal chain to viem chain",
+                  cause,
                 })
               ),
+            )
+
+            const client = yield* pipe(
+              createViemPublicClient({
+                chain: viemChain,
+                transport: http(),
+              }),
               Effect.mapError((cause) =>
                 new GasPriceError({
                   module: "Evm",
@@ -47,6 +58,38 @@ export class GasPriceMap extends LayerMap.Service<GasPriceMap>()("GasPriceByChai
               ),
             )
 
+            const additiveFee = yield* pipe(
+              Match.value(chain.universal_chain_id),
+              Match.whenOr(
+                Match.is(UniversalChainId.make("bob.60808")),
+                Match.is(UniversalChainId.make("bob.808813")),
+                (id) =>
+                  pipe(
+                    client.extend(publicActionsL2()),
+                    (client) =>
+                      Effect.tryPromise({
+                        try: () =>
+                          client.estimateL1Fee({
+                            // TODO: re-evaluate correctness
+                            account: "0x0000000000000000000000000000000000000000",
+                            chain: undefined,
+                          }),
+                        catch: (cause) =>
+                          new GasPriceError({
+                            module: "Evm",
+                            method: "additiveFee",
+                            description: `Could not calculate L1 fee for ${id}`,
+                            cause,
+                          }),
+                      }),
+                    Effect.map((atomic) => BigDecimal.make(atomic, 0)),
+                    Effect.map(GasPrice.AtomicGasPrice),
+                  ),
+              ),
+              Match.option,
+              Effect.transposeOption,
+            )
+
             const of = pipe(
               Effect.tryPromise({
                 try: () => client.getGasPrice(),
@@ -60,10 +103,13 @@ export class GasPriceMap extends LayerMap.Service<GasPriceMap>()("GasPriceByChai
               }),
               // XXX: take from constants file
               Effect.tap((x) =>
-                Effect.logDebug(`${chain.display_name} gas price (atomic): ${JSON.stringify(x)}`)
+                Effect.logDebug(
+                  `${chain.display_name} gas price (atomic): ${JSON.stringify(x)}`,
+                )
               ),
               Effect.map((a) => ({
                 value: GasPrice.BaseGasPrice(BigDecimal.make(a, 18)),
+                additiveFee,
                 decimals: 18,
               })),
               Effect.tap((x) =>
@@ -115,6 +161,7 @@ export class GasPriceMap extends LayerMap.Service<GasPriceMap>()("GasPriceByChai
                         GasPrice.BaseGasPrice,
                         (value) => ({
                           value,
+                          additiveFee: O.none<GasPrice.AtomicGasPrice>(),
                           decimals,
                         }),
                       )

app2/src/lib/gasprice/service.ts

@@ -1,4 +1,4 @@
-import { BigDecimal, Brand, Context, Effect } from "effect"
+import { BigDecimal, Brand, Context, Effect, Option as O } from "effect"
 import type { GasPriceError } from "./error"
 
 export type AtomicGasPrice = BigDecimal.BigDecimal & Brand.Brand<"AtomicGasPrice">
@@ -30,6 +30,10 @@ export declare namespace GasPrice {
   export interface Service {
     readonly of: Effect.Effect<{
       value: BaseGasPrice
+      /**
+       * e.g. L1 fee on BOB
+       */
+      additiveFee: O.Option<AtomicGasPrice>
       decimals: number
     }, GasPriceError>
   }

app2/src/lib/stores/fee.svelte.ts

@@ -78,11 +78,13 @@ const createFeeStore = () => {
         source: {
           gas: BaseGasPrice
           gasDecimals: number
+          additiveFee: O.Option<AtomicGasPrice>
           usd: PriceResult
         }
         destination: {
           gas: BaseGasPrice
           gasDecimals: number
+          additiveFee: O.Option<AtomicGasPrice>
           usd: PriceResult
         }
       },
@@ -130,6 +132,7 @@ const createFeeStore = () => {
             return {
               gas: gas.value,
               gasDecimals: gas.decimals,
+              additiveFee: gas.additiveFee,
               usd,
             }
           })
@@ -183,7 +186,8 @@ const createFeeStore = () => {
 
   const decorate = (
     self: {
-      gasPrice: { value: BaseGasPrice; decimals: number }
+      // TODO: consolidate type
+      gasPrice: { value: BaseGasPrice; additiveFee: O.Option<AtomicGasPrice>; decimals: number }
       ratio: BigDecimal.BigDecimal
     } & typeof config,
   ) => {
@@ -244,6 +248,21 @@ const createFeeStore = () => {
       return f(self.gasPrice.value)
     }
 
+    const applyAdditiveFeeK = (
+      amount: AtomicGasPrice,
+    ): Writer.Writer<readonly string[], AtomicGasPrice> => {
+      const result = self.gasPrice.additiveFee.pipe(
+        O.map(BigDecimal.sum(amount)),
+        O.getOrElse(() => amount),
+        AtomicGasPrice,
+      )
+
+      return [
+        result,
+        [`additive (L1) fee for BOB is ${self.gasPrice.additiveFee.toString()}`],
+      ]
+    }
+
     const applyRatioK = (a: BaseGasPrice): Writer.Writer<readonly string[], BaseGasPrice> => {
       const ratio = BigDecimal.round(self.ratio, { scale: gasDecimals, mode: "from-zero" })
       const result = pipe(
@@ -336,6 +355,7 @@ const createFeeStore = () => {
       applyGasPriceK,
       asBaseUnitK,
       asAtomicUnitK,
+      applyAdditiveFeeK,
       applyFeeMultiplierK,
       applyRatioK,
       applyBatchDivisionK,
@@ -377,12 +397,6 @@ const createFeeStore = () => {
     O.map(x => x.source.gas),
   ))
 
-  const destGasUnitPrice = $derived(pipe(
-    data,
-    O.flatMap(O.getRight),
-    O.map(x => x.destination.gas),
-  ))
-
   const decoratedConfig = $derived(pipe(
     O.all({
       // XXX: source / dest here should be determined on per-transaction basis
@@ -392,6 +406,7 @@ const createFeeStore = () => {
         O.map(x => ({
           value: x.destination.gas,
           decimals: x.destination.gasDecimals,
+          additiveFee: x.destination.additiveFee,
         })),
       ),
       ratio: maybeRatio,
@@ -407,6 +422,7 @@ const createFeeStore = () => {
         PACKET_SEND_LC_UPDATE_L1: flow(
           pipe( // TODO: extract
             config.applyGasPriceK,
+            composeK(config.applyAdditiveFeeK),
             composeK(config.asBaseUnitK),
             composeK(config.applyFeeMultiplierK),
             composeK(config.applyBatchDivisionK),
@@ -416,6 +432,7 @@ const createFeeStore = () => {
         PACKET_SEND_LC_UPDATE_L0: flow(
           pipe( // TODO: extract
             config.applyGasPriceK,
+            composeK(config.applyAdditiveFeeK),
             composeK(config.asBaseUnitK),
             composeK(config.applyFeeMultiplierK),
             composeK(config.applyBatchDivisionK),
@@ -425,6 +442,7 @@ const createFeeStore = () => {
         PACKET_RECV: flow(
           pipe( // TODO: extract
             config.applyGasPriceK,
+            composeK(config.applyAdditiveFeeK),
             composeK(config.asBaseUnitK),
             composeK(config.applyFeeMultiplierK),
             composeK(config.applyRatioK),

app2/src/lib/transfer/shared/components/FeeDetails.svelte

@@ -156,6 +156,7 @@ const calculating = false
                   <div class="text-sm">
                     <div class="font-semibold text-white mb-2">{item.label}</div>
                     <div class="text-zinc-300 mb-4">{item.description}</div>
+                    <!-- <div>{@html item.steps.calc}</div> -->
                   </div>
                 {/snippet}
               </Tooltip>

ts-sdk/src/evm/client.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect } from "effect"
+import { Array as A, Context, Data, Effect, pipe, Predicate } from "effect"
 import {
   type Account,
   type Chain,
@@ -62,11 +62,23 @@ export class CreateViemWalletClientError extends Data.TaggedError("CreateViemWal
   cause: CreateWalletClientErrorType
 }> {}
 
+type Extension = Parameters<ReturnType<typeof createPublicClient>["extend"]>[0]
+
 export const createViemPublicClient = (
   parameters: PublicClientConfig,
+  extensions?: ReadonlyArray<Extension> | Extension | undefined,
 ): Effect.Effect<PublicClient, CreateViemPublicClientError> =>
   Effect.try({
-    try: () => createPublicClient(parameters),
+    try: () =>
+      pipe(
+        A.ensure(extensions),
+        A.filter(Predicate.isNotUndefined),
+        (xs) =>
+          xs.reduce(
+            (client, extension) => client.extend(extension as unknown as any),
+            createPublicClient(parameters),
+          ),
+      ),
     catch: err =>
       new CreateViemPublicClientError({
         cause: extractErrorDetails(err as CreatePublicClientErrorType),

ts-sdk/src/schema/hex.ts

@@ -1,3 +1,5 @@
+import { Effect, ParseResult } from "effect"
+import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
 import { fromHex, toHex } from "viem"
 
@@ -26,3 +28,24 @@ export const HexFromString = S.transform(S.String, Hex, {
   encode: hex => fromHex(hex, "string"),
 })
 export type HexFromString = typeof HexFromString.Type
+
+/**
+ * TODO: handle signed hex?
+ */
+export const NumberFromHexString = S.transformOrFail(
+  Hex,
+  S.Positive,
+  {
+    decode: (fromA, _, ast) =>
+      pipe(
+        Effect.try({
+          try: () => Number.parseInt(fromA, 16),
+          catch: (e) => new Error(String(e)),
+        }),
+        Effect.mapError((e) => new ParseResult.Type(ast, fromA, e.message)),
+      ),
+    encode: (toI) => Effect.succeed(`0x${toI.toString(16)}` as const),
+    strict: true,
+  },
+)
+export type NumberFromHexString = typeof NumberFromHexString.Type