CR andrey 1

Author: paulbalaji

typescript/keyfunder/README.md

@@ -75,13 +75,18 @@ chainsToSkip: []
 | `chains.<chain>.sweep.enabled`           | Enable sweep functionality                                                                       |
 | `chains.<chain>.sweep.address`           | Address to sweep funds to (required when enabled)                                                |
 | `chains.<chain>.sweep.threshold`         | Base threshold for sweep calculations (required when enabled; decimal string; up to 18 decimals) |
-| `chains.<chain>.sweep.targetMultiplier`  | Multiplier for target balance (default: 1.5)                                                     |
-| `chains.<chain>.sweep.triggerMultiplier` | Multiplier for trigger threshold (default: 2.0)                                                  |
+| `chains.<chain>.sweep.targetMultiplier`  | Multiplier for target balance (default: 1.5; 2 decimal precision, floored)                       |
+| `chains.<chain>.sweep.triggerMultiplier` | Multiplier for trigger threshold (default: 2.0; 2 decimal precision, floored)                    |
 | `metrics.pushGateway`                    | Prometheus push gateway URL                                                                      |
 | `metrics.jobName`                        | Job name for metrics                                                                             |
 | `metrics.labels`                         | Additional labels for metrics                                                                    |
 | `chainsToSkip`                           | Array of chain names to skip                                                                     |
 
+### Precision Notes
+
+- **Balance strings**: Support up to 18 decimal places (standard ETH precision). Must include leading digit (e.g., `"0.5"` not `".5"`).
+- **Multipliers**: Calculated with 2 decimal precision using floor (e.g., `1.555` is treated as `1.55`, not `1.56`).
+
 ## Environment Variables
 
 | Variable                | Description                                                                                                                                  | Required |

typescript/keyfunder/src/config/types.test.ts

@@ -1,4 +1,7 @@
 import { expect } from 'chai';
+import { BigNumber } from 'ethers';
+
+import { calculateMultipliedBalance } from '../core/KeyFunder.js';
 
 import {
   ChainConfigSchema,
@@ -181,6 +184,60 @@ describe('KeyFunderConfig Schemas', () => {
       const result = ChainConfigSchema.safeParse(config);
       expect(result.success).to.be.false;
     });
+
+    it('should reject balance without leading digit (.5)', () => {
+      const config = {
+        balances: {
+          'hyperlane-relayer': '.5',
+        },
+      };
+      const result = ChainConfigSchema.safeParse(config);
+      expect(result.success).to.be.false;
+    });
+
+    it('should accept balance with leading zero (0.5)', () => {
+      const config = {
+        balances: {
+          'hyperlane-relayer': '0.5',
+        },
+      };
+      const result = ChainConfigSchema.safeParse(config);
+      expect(result.success).to.be.true;
+    });
+
+    it('should accept high precision balances (up to 18 decimals)', () => {
+      const config = {
+        balances: {
+          'hyperlane-relayer': '0.000000000000000001',
+        },
+      };
+      const result = ChainConfigSchema.safeParse(config);
+      expect(result.success).to.be.true;
+    });
+  });
+
+  describe('Multiplier precision (calculateMultipliedBalance)', () => {
+    const oneEther = BigNumber.from('1000000000000000000');
+
+    it('should calculate 1.5x correctly (1 ETH * 1.5 = 1.5 ETH)', () => {
+      const result = calculateMultipliedBalance(oneEther, 1.5);
+      expect(result.toString()).to.equal('1500000000000000000');
+    });
+
+    it('should calculate 2.0x correctly (1 ETH * 2.0 = 2 ETH)', () => {
+      const result = calculateMultipliedBalance(oneEther, 2.0);
+      expect(result.toString()).to.equal('2000000000000000000');
+    });
+
+    it('should floor third decimal (1 ETH * 1.555 = 1.55 ETH, not 1.56 ETH)', () => {
+      const result = calculateMultipliedBalance(oneEther, 1.555);
+      expect(result.toString()).to.equal('1550000000000000000');
+    });
+
+    it('should floor (1 ETH * 1.999 = 1.99 ETH, not 2 ETH)', () => {
+      const result = calculateMultipliedBalance(oneEther, 1.999);
+      expect(result.toString()).to.equal('1990000000000000000');
+    });
   });
 
   describe('KeyFunderConfigSchema', () => {

typescript/keyfunder/src/config/types.ts

@@ -7,11 +7,12 @@ const AddressSchema = z
     'Must be a valid Ethereum address (0x-prefixed, 40 hex characters)',
   );
 
+// Requires leading digit (e.g., "0.5" not ".5") for YAML readability
 const BalanceStringSchema = z
   .string()
   .regex(
     /^(?:\d+)(?:\.\d{1,18})?$/,
-    'Must be a valid non-negative decimal string (up to 18 decimals)',
+    'Must be a valid non-negative decimal string with leading digit (e.g., "0.5" not ".5", up to 18 decimals)',
   );
 
 export const RoleConfigSchema = z.object({

typescript/keyfunder/src/core/KeyFunder.ts

@@ -285,12 +285,14 @@ export class KeyFunder {
     }
 
     const threshold = ethers.utils.parseEther(sweepConfig.threshold);
-    const targetBalance = threshold
-      .mul(Math.round(sweepConfig.targetMultiplier * 100))
-      .div(100);
-    const triggerThreshold = threshold
-      .mul(Math.round(sweepConfig.triggerMultiplier * 100))
-      .div(100);
+    const targetBalance = calculateMultipliedBalance(
+      threshold,
+      sweepConfig.targetMultiplier,
+    );
+    const triggerThreshold = calculateMultipliedBalance(
+      threshold,
+      sweepConfig.triggerMultiplier,
+    );
 
     const funderBalance = await this.multiProvider
       .getSigner(chain)
@@ -341,6 +343,17 @@ export class KeyFunder {
   }
 }
 
+/**
+ * Multiplies a BigNumber by a decimal multiplier with 2 decimal precision (floored).
+ * e.g., 1 ETH * 1.555 = 1.55 ETH (not 1.56 ETH)
+ */
+export function calculateMultipliedBalance(
+  base: BigNumber,
+  multiplier: number,
+): BigNumber {
+  return base.mul(Math.floor(multiplier * 100)).div(100);
+}
+
 function createTimeoutPromise(
   timeoutMs: number,
   errorMessage: string,

typescript/keyfunder/src/index.ts

@@ -18,5 +18,9 @@ export type {
   ResolvedKeyConfig,
 } from './config/types.js';
 
-export { KeyFunder, type KeyFunderOptions } from './core/KeyFunder.js';
+export {
+  KeyFunder,
+  calculateMultipliedBalance,
+  type KeyFunderOptions,
+} from './core/KeyFunder.js';
 export { KeyFunderMetrics } from './metrics/Metrics.js';

typescript/keyfunder/src/service.ts

@@ -121,11 +121,21 @@ async function main(): Promise<void> {
       igp,
     });
 
-    await funder.fundAllChains();
+    let fundingError: Error | undefined;
+    try {
+      await funder.fundAllChains();
+    } catch (error) {
+      fundingError = error as Error;
+    }
 
+    // Always push metrics, even on failure (matches original fund-keys-from-deployer.ts behavior)
     await metrics.push();
     logger.info('Metrics pushed to gateway');
 
+    if (fundingError) {
+      throw fundingError;
+    }
+
     logger.info('KeyFunder completed successfully');
     process.exit(0);
   } catch (error) {