@vultisig/core-chain 2.35.0 → 2.35.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @vultisig/core-chain
 
+## 2.35.1
+
+### Patch Changes
+
+- [#1846](https://github.com/vultisig/vultisig-sdk/pull/1846) [`8faa612`](https://github.com/vultisig/vultisig-sdk/commit/8faa612e6358af0a77cebf9c06d8865d832b69df) Thanks [@Ehsan-saradar](https://github.com/Ehsan-saradar)! - Reserve the OP-stack balance-check surcharges in the EVM fee amount, so a native max send on Optimism, Base, Blast or Mantle stays affordable at broadcast. op-geth requires `value + gasLimit * maxFeePerGas + l1Cost + operatorCost`, and an amount that left only the gas term behind was rejected by exactly the difference — after the keysign ceremony had already run. Both oracle reads fail open, so a chain whose oracle is unreachable or predates a term behaves exactly as before.
+
 ## 2.35.0
 
 ### Minor Changes

package/dist/chains/evm/opStack/getOpStackFeeSurcharge.d.ts

@@ -0,0 +1,22 @@
+import { OpStackChain } from './opStackChains.js';
+type GetOpStackFeeSurchargeInput = {
+    chain: OpStackChain;
+    gasLimit: bigint;
+    callDataSize: number;
+};
+/**
+ * The two terms op-geth adds to the balance check it runs before executing a
+ * transaction: the L1 data-availability cost and, from Isthmus onwards, the
+ * operator fee. The chain requires
+ * `value + gasLimit * maxFeePerGas + l1Cost + operatorCost` to be covered, so an
+ * amount that leaves only the gas term behind is rejected by exactly this much.
+ *
+ * Both terms fail open independently. A pre-Isthmus oracle reverts on
+ * `getOperatorFee`, and letting that failure take the L1 data fee down with it
+ * would leave the chain reserving nothing at all — a fee that cannot be read
+ * must never block a send that worked before. A negative answer is nonsense from
+ * a fee oracle and is floored rather than passed on to widen a max amount.
+ */
+export declare const getOpStackFeeSurcharge: ({ chain, gasLimit, callDataSize, }: GetOpStackFeeSurchargeInput) => Promise<bigint>;
+export {};
+//# sourceMappingURL=getOpStackFeeSurcharge.d.ts.map

package/dist/chains/evm/opStack/getOpStackFeeSurcharge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOpStackFeeSurcharge.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/getOpStackFeeSurcharge.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAoC9C,KAAK,2BAA2B,GAAG;IACjC,KAAK,EAAE,YAAY,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,GAAU,oCAI1C,2BAA2B,KAAG,OAAO,CAAC,MAAM,CAiC9C,CAAA"}

package/dist/chains/evm/opStack/getOpStackFeeSurcharge.js

@@ -0,0 +1,68 @@
+import { getEvmClient } from '@vultisig/core-chain/chains/evm/client';
+import { attempt, withFallback } from '@vultisig/lib-utils/attempt';
+import { bigIntMax } from '@vultisig/lib-utils/bigint/bigIntMax';
+import { l1FeeProbeData } from './l1FeeProbeData.js';
+/** Canonical `GasPriceOracle` predeploy address, identical on every OP-stack rollup. */
+const gasPriceOracleAddress = '0x420000000000000000000000000000000000000F';
+// `getL1Fee(bytes)` is preferred over the purpose-built `getL1FeeUpperBound(uint256)`,
+// which only exists from Fjord onwards — Blast's oracle predates it, while
+// `getL1Fee` has been there since Bedrock. `getOperatorFee(uint256)` arrives with
+// Isthmus and simply reverts on older oracles, which reads the same as "this chain
+// charges no operator fee".
+const gasPriceOracleAbi = [
+    {
+        name: 'getL1Fee',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: '_data', type: 'bytes' }],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+    {
+        name: 'getOperatorFee',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: '_gasUsed', type: 'uint256' }],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+];
+// Serialized size, in bytes, that the L1-fee probe stands in for on top of the
+// transaction's own calldata. The oracle wants the UNSIGNED transaction and adds
+// its own 68-byte allowance for the signature, so this models the ~70-byte
+// unsigned EIP-1559 envelope with deliberate margin: the transaction is not built
+// yet when its fee has to be reserved, and over-reserving leaves dust behind
+// where under-reserving costs a broadcast rejected after the keysign ceremony has
+// already run.
+const unsignedTxEnvelopeSize = 160;
+/**
+ * The two terms op-geth adds to the balance check it runs before executing a
+ * transaction: the L1 data-availability cost and, from Isthmus onwards, the
+ * operator fee. The chain requires
+ * `value + gasLimit * maxFeePerGas + l1Cost + operatorCost` to be covered, so an
+ * amount that leaves only the gas term behind is rejected by exactly this much.
+ *
+ * Both terms fail open independently. A pre-Isthmus oracle reverts on
+ * `getOperatorFee`, and letting that failure take the L1 data fee down with it
+ * would leave the chain reserving nothing at all — a fee that cannot be read
+ * must never block a send that worked before. A negative answer is nonsense from
+ * a fee oracle and is floored rather than passed on to widen a max amount.
+ */
+export const getOpStackFeeSurcharge = async ({ chain, gasLimit, callDataSize, }) => {
+    const client = getEvmClient(chain);
+    const l1DataFee = withFallback(attempt(client.readContract({
+        address: gasPriceOracleAddress,
+        abi: gasPriceOracleAbi,
+        functionName: 'getL1Fee',
+        args: [l1FeeProbeData(unsignedTxEnvelopeSize + callDataSize)],
+    })), 0n);
+    const operatorFee = gasLimit > 0n
+        ? withFallback(attempt(client.readContract({
+            address: gasPriceOracleAddress,
+            abi: gasPriceOracleAbi,
+            functionName: 'getOperatorFee',
+            args: [gasLimit],
+        })), 0n)
+        : Promise.resolve(0n);
+    const terms = await Promise.all([l1DataFee, operatorFee]);
+    return terms.reduce((total, term) => total + bigIntMax(0n, term), 0n);
+};
+//# sourceMappingURL=getOpStackFeeSurcharge.js.map

package/dist/chains/evm/opStack/getOpStackFeeSurcharge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOpStackFeeSurcharge.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/getOpStackFeeSurcharge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AACrE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAA;AAEhE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGjD,wFAAwF;AACxF,MAAM,qBAAqB,GAAG,4CAA4C,CAAA;AAE1E,uFAAuF;AACvF,2EAA2E;AAC3E,kFAAkF;AAClF,mFAAmF;AACnF,4BAA4B;AAC5B,MAAM,iBAAiB,GAAG;IACxB;QACE,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,MAAM;QACvB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;QAC1C,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACzC;IACD;QACE,IAAI,EAAE,gBAAgB;QACtB,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,MAAM;QACvB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAC/C,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACzC;CACO,CAAA;AAEV,+EAA+E;AAC/E,iFAAiF;AACjF,2EAA2E;AAC3E,kFAAkF;AAClF,6EAA6E;AAC7E,kFAAkF;AAClF,eAAe;AACf,MAAM,sBAAsB,GAAG,GAAG,CAAA;AAQlC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,EAAE,EAC3C,KAAK,EACL,QAAQ,EACR,YAAY,GACgB,EAAmB,EAAE;IACjD,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,CAAA;IAElC,MAAM,SAAS,GAAG,YAAY,CAC5B,OAAO,CACL,MAAM,CAAC,YAAY,CAAC;QAClB,OAAO,EAAE,qBAAqB;QAC9B,GAAG,EAAE,iBAAiB;QACtB,YAAY,EAAE,UAAU;QACxB,IAAI,EAAE,CAAC,cAAc,CAAC,sBAAsB,GAAG,YAAY,CAAC,CAAC;KAC9D,CAAC,CACH,EACD,EAAE,CACH,CAAA;IAED,MAAM,WAAW,GACf,QAAQ,GAAG,EAAE;QACX,CAAC,CAAC,YAAY,CACV,OAAO,CACL,MAAM,CAAC,YAAY,CAAC;YAClB,OAAO,EAAE,qBAAqB;YAC9B,GAAG,EAAE,iBAAiB;YACtB,YAAY,EAAE,gBAAgB;YAC9B,IAAI,EAAE,CAAC,QAAQ,CAAC;SACjB,CAAC,CACH,EACD,EAAE,CACH;QACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAEzB,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAA;IAEzD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;AACvE,CAAC,CAAA"}

package/dist/chains/evm/opStack/l1FeeProbeData.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Stand-in bytes for the serialized transaction handed to the `GasPriceOracle`
+ * predeploy's `getL1Fee(bytes)`, which has to price a transaction that does not
+ * exist yet — the amount being priced is itself derived from the answer.
+ *
+ * The bytes are deliberately incompressible. From Fjord onwards the oracle
+ * charges for the FastLZ-compressed size of what it is handed, so a *periodic*
+ * payload prices far below what a real transaction costs: a plain counter wraps
+ * every 256 bytes and every window after the first lap is a back reference, at
+ * which point the quote stops growing with size at all.
+ *
+ * This stream repeats no 3-byte window — FastLZ's shortest encodable match —
+ * through its first 3,652 bytes, which covers every probe the callers build
+ * (a 160-byte envelope plus calldata, the largest being a ~3 KB swap router
+ * call). Past that the birthday bound makes isolated repeats inevitable in any
+ * uniformly distributed stream, and they are harmless: a lone 3-byte match
+ * costs more to encode as a back reference than it saves, so FastLZ does not
+ * take it. Measured against the live oracles, this stream prices identically to
+ * crypto-random bytes at 1–4 KB and 0.01% *above* them at 8–16 KB — it never
+ * quotes below the incompressible ideal.
+ */
+export declare const l1FeeProbeData: (size: number) => `0x${string}`;
+//# sourceMappingURL=l1FeeProbeData.d.ts.map

package/dist/chains/evm/opStack/l1FeeProbeData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1FeeProbeData.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/l1FeeProbeData.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,KAAK,MAAM,EAUxD,CAAA"}

package/dist/chains/evm/opStack/l1FeeProbeData.js

@@ -0,0 +1,38 @@
+import { bytesToHex } from 'viem';
+// Linear congruential generator (Numerical Recipes constants) seeded with the
+// golden-ratio word. Deterministic across runs, so the same send reserves the
+// same amount twice running, and aperiodic over any length we ask it for.
+const lcgSeed = 0x9e3779b9;
+const lcgMultiplier = 1_664_525;
+const lcgIncrement = 1_013_904_223;
+/**
+ * Stand-in bytes for the serialized transaction handed to the `GasPriceOracle`
+ * predeploy's `getL1Fee(bytes)`, which has to price a transaction that does not
+ * exist yet — the amount being priced is itself derived from the answer.
+ *
+ * The bytes are deliberately incompressible. From Fjord onwards the oracle
+ * charges for the FastLZ-compressed size of what it is handed, so a *periodic*
+ * payload prices far below what a real transaction costs: a plain counter wraps
+ * every 256 bytes and every window after the first lap is a back reference, at
+ * which point the quote stops growing with size at all.
+ *
+ * This stream repeats no 3-byte window — FastLZ's shortest encodable match —
+ * through its first 3,652 bytes, which covers every probe the callers build
+ * (a 160-byte envelope plus calldata, the largest being a ~3 KB swap router
+ * call). Past that the birthday bound makes isolated repeats inevitable in any
+ * uniformly distributed stream, and they are harmless: a lone 3-byte match
+ * costs more to encode as a back reference than it saves, so FastLZ does not
+ * take it. Measured against the live oracles, this stream prices identically to
+ * crypto-random bytes at 1–4 KB and 0.01% *above* them at 8–16 KB — it never
+ * quotes below the incompressible ideal.
+ */
+export const l1FeeProbeData = (size) => {
+    const bytes = new Uint8Array(Math.max(0, size));
+    let state = lcgSeed;
+    for (let i = 0; i < bytes.length; i++) {
+        state = (Math.imul(state, lcgMultiplier) + lcgIncrement) >>> 0;
+        bytes[i] = (state >>> 24) & 0xff;
+    }
+    return bytesToHex(bytes);
+};
+//# sourceMappingURL=l1FeeProbeData.js.map

package/dist/chains/evm/opStack/l1FeeProbeData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1FeeProbeData.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/l1FeeProbeData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAEjC,8EAA8E;AAC9E,8EAA8E;AAC9E,0EAA0E;AAC1E,MAAM,OAAO,GAAG,UAAU,CAAA;AAC1B,MAAM,aAAa,GAAG,SAAS,CAAA;AAC/B,MAAM,YAAY,GAAG,aAAa,CAAA;AAElC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAY,EAAiB,EAAE;IAC5D,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;IAE/C,IAAI,KAAK,GAAG,OAAO,CAAA;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,KAAK,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAA;QAC9D,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;IAClC,CAAC;IAED,OAAO,UAAU,CAAC,KAAK,CAAC,CAAA;AAC1B,CAAC,CAAA"}

package/dist/chains/evm/opStack/opStackChains.d.ts

@@ -0,0 +1,19 @@
+import { Chain } from '@vultisig/core-chain/Chain';
+/**
+ * EVM chains that settle to Ethereum through the OP stack and therefore expose
+ * the `GasPriceOracle` predeploy. op-geth bills these chains' transactions an
+ * L1 data-availability cost — and, from Isthmus onwards, an operator fee — on
+ * top of L2 execution gas, and adds both to the balance check it runs before a
+ * transaction executes.
+ *
+ * Membership is asserted, not detected: the predeploy answers on exactly these
+ * four and has no code on every other EVM chain in the registry. An omission is
+ * safe but silent — the chain reserves nothing extra, which is how every chain
+ * behaved before the oracle was read at all — so a newly added OP-stack rollup
+ * has to be listed here or its max sends will under-reserve.
+ */
+export declare const opStackChains: readonly ["Optimism", "Base", "Blast", "Mantle"];
+export type OpStackChain = (typeof opStackChains)[number];
+/** Narrows a chain to one whose node prices an L1 data fee through the `GasPriceOracle` predeploy. */
+export declare const isOpStackChain: (chain: Chain) => chain is OpStackChain;
+//# sourceMappingURL=opStackChains.d.ts.map

package/dist/chains/evm/opStack/opStackChains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opStackChains.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/opStackChains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,MAAM,4BAA4B,CAAA;AAG5D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,kDAA+E,CAAA;AAEzG,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAEzD,sGAAsG;AACtG,eAAO,MAAM,cAAc,GAAI,OAAO,KAAK,KAAG,KAAK,IAAI,YAA6C,CAAA"}

package/dist/chains/evm/opStack/opStackChains.js

@@ -0,0 +1,19 @@
+import { EvmChain } from '@vultisig/core-chain/Chain';
+import { isOneOf } from '@vultisig/lib-utils/array/isOneOf';
+/**
+ * EVM chains that settle to Ethereum through the OP stack and therefore expose
+ * the `GasPriceOracle` predeploy. op-geth bills these chains' transactions an
+ * L1 data-availability cost — and, from Isthmus onwards, an operator fee — on
+ * top of L2 execution gas, and adds both to the balance check it runs before a
+ * transaction executes.
+ *
+ * Membership is asserted, not detected: the predeploy answers on exactly these
+ * four and has no code on every other EVM chain in the registry. An omission is
+ * safe but silent — the chain reserves nothing extra, which is how every chain
+ * behaved before the oracle was read at all — so a newly added OP-stack rollup
+ * has to be listed here or its max sends will under-reserve.
+ */
+export const opStackChains = [EvmChain.Optimism, EvmChain.Base, EvmChain.Blast, EvmChain.Mantle];
+/** Narrows a chain to one whose node prices an L1 data fee through the `GasPriceOracle` predeploy. */
+export const isOpStackChain = (chain) => isOneOf(chain, opStackChains);
+//# sourceMappingURL=opStackChains.js.map

package/dist/chains/evm/opStack/opStackChains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opStackChains.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/evm/opStack/opStackChains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAU,CAAA;AAIzG,sGAAsG;AACtG,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAY,EAAyB,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/core-chain",
-  "version": "2.35.0",
+  "version": "2.35.1",
   "description": "Blockchain chain logic shared across Vultisig clients",
   "license": "MIT",
   "repository": {
@@ -640,6 +640,21 @@
       "import": "./dist/chains/evm/noon/index.js",
       "default": "./dist/chains/evm/noon/index.js"
     },
+    "./chains/evm/opStack/getOpStackFeeSurcharge": {
+      "types": "./dist/chains/evm/opStack/getOpStackFeeSurcharge.d.ts",
+      "import": "./dist/chains/evm/opStack/getOpStackFeeSurcharge.js",
+      "default": "./dist/chains/evm/opStack/getOpStackFeeSurcharge.js"
+    },
+    "./chains/evm/opStack/l1FeeProbeData": {
+      "types": "./dist/chains/evm/opStack/l1FeeProbeData.d.ts",
+      "import": "./dist/chains/evm/opStack/l1FeeProbeData.js",
+      "default": "./dist/chains/evm/opStack/l1FeeProbeData.js"
+    },
+    "./chains/evm/opStack/opStackChains": {
+      "types": "./dist/chains/evm/opStack/opStackChains.d.ts",
+      "import": "./dist/chains/evm/opStack/opStackChains.js",
+      "default": "./dist/chains/evm/opStack/opStackChains.js"
+    },
     "./chains/evm/tx/fee": {
       "types": "./dist/chains/evm/tx/fee/index.d.ts",
       "import": "./dist/chains/evm/tx/fee/index.js",