@kairoguard/sdk 0.0.13 → 0.0.14

package/dist/client.js

@@ -14,6 +14,7 @@ import { Curve, fetchProtocolParams, deriveEncryptionKeys, generateSeed, generat
 import { Hash, SignatureAlgorithm, createUserSignMessageWithPublicOutput } from "@ika.xyz/sdk";
 import { computeEvmIntentFromUnsignedTxBytes } from "./evmIntent.js";
 import { keccak256, recoverTransactionAddress, serializeTransaction, } from "viem";
+import { convertWeiToUsdMicros, fetchEthUsdMicros } from "./price.js";
 const FALLBACK_SUI_RPC = "https://fullnode.testnet.sui.io:443";
 async function testRpcEndpoint(url) {
     try {
@@ -752,17 +753,30 @@ export class KairoClient {
         if (!wallet.policyObjectId || !wallet.bindingObjectId) {
             throw new Error("Wallet is missing policy binding metadata. Provision the wallet via dashboard or SDK before signing.");
         }
-        const mintOnce = () => this.backend.mintReceipt({
-            policyObjectId: wallet.policyObjectId ?? undefined,
-            bindingObjectId: wallet.bindingObjectId,
-            namespace: ctx.namespace,
-            // chainId is encoded as u64 bytes (16 hex chars)
-            chainId: ctx.chainId.toString(16).padStart(16, "0"),
-            intentHashHex: stripHexPrefix(ctx.intentHashHex),
-            destinationHex: stripHexPrefix(ctx.destinationHex),
-            nativeValueHex: ctx.nativeValue.toString(16).padStart(64, "0"),
-            contextDataHex: ctx.contextDataHex ? stripHexPrefix(ctx.contextDataHex) : undefined,
-        });
+        const mintOnce = async () => {
+            let normalizedNativeValue = ctx.nativeValue;
+            // MaxNativeValue rules are encoded in USD-micros; normalize EVM wei inputs.
+            if (ctx.namespace === 1) {
+                try {
+                    const ethUsdMicros = await fetchEthUsdMicros();
+                    normalizedNativeValue = convertWeiToUsdMicros(ctx.nativeValue, ethUsdMicros);
+                }
+                catch {
+                    // Keep raw value as fallback if price feed is unavailable.
+                }
+            }
+            return this.backend.mintReceipt({
+                policyObjectId: wallet.policyObjectId ?? undefined,
+                bindingObjectId: wallet.bindingObjectId,
+                namespace: ctx.namespace,
+                // chainId is encoded as u64 bytes (16 hex chars)
+                chainId: ctx.chainId.toString(16).padStart(16, "0"),
+                intentHashHex: stripHexPrefix(ctx.intentHashHex),
+                destinationHex: stripHexPrefix(ctx.destinationHex),
+                nativeValueHex: normalizedNativeValue.toString(16).padStart(64, "0"),
+                contextDataHex: ctx.contextDataHex ? stripHexPrefix(ctx.contextDataHex) : undefined,
+            });
+        };
         let response = await mintOnce();
         const initialError = String(response?.error ?? "");
         if (response.success === false && this.isReaffirmRequiredError(initialError)) {

package/dist/price.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchEthUsdMicros(): Promise<bigint>;
+export declare function convertWeiToUsdMicros(weiValue: bigint, ethUsdMicros: bigint): bigint;

package/dist/price.js

@@ -0,0 +1,65 @@
+const WEI_PER_ETH = 1000000000000000000n;
+const USD_MICROS_SCALE = 1000000n;
+const CACHE_MS = 60_000;
+let cachedEthUsdMicros = null;
+function parseUsdToMicros(input) {
+    const s = input.trim();
+    if (!s)
+        throw new Error("ETH/USD response is empty");
+    if (!/^\d+(\.\d+)?$/.test(s)) {
+        throw new Error(`Invalid ETH/USD amount: ${s}`);
+    }
+    const [wholeRaw, fracRaw = ""] = s.split(".");
+    const whole = BigInt(wholeRaw);
+    const frac = BigInt((fracRaw + "000000").slice(0, 6));
+    return whole * USD_MICROS_SCALE + frac;
+}
+async function fetchJsonWithTimeout(url, timeoutMs) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, { signal: ctrl.signal });
+        if (!resp.ok) {
+            throw new Error(`HTTP ${resp.status} from ${url}`);
+        }
+        return await resp.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function fetchEthUsdMicros() {
+    const now = Date.now();
+    if (cachedEthUsdMicros && now - cachedEthUsdMicros.atMs < CACHE_MS) {
+        return cachedEthUsdMicros.value;
+    }
+    const providers = [
+        async () => {
+            const j = await fetchJsonWithTimeout("https://api.coinbase.com/v2/prices/ETH-USD/spot", 7000);
+            const amount = String(j?.data?.amount ?? "").trim();
+            return parseUsdToMicros(amount);
+        },
+        async () => {
+            const j = await fetchJsonWithTimeout("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd", 7000);
+            const amount = String(j?.ethereum?.usd ?? "").trim();
+            return parseUsdToMicros(amount);
+        },
+    ];
+    let lastErr = null;
+    for (const getPrice of providers) {
+        try {
+            const value = await getPrice();
+            if (value > 0n) {
+                cachedEthUsdMicros = { value, atMs: now };
+                return value;
+            }
+        }
+        catch (error) {
+            lastErr = error;
+        }
+    }
+    throw new Error(`Could not fetch ETH/USD price${lastErr ? `: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}` : ""}`);
+}
+export function convertWeiToUsdMicros(weiValue, ethUsdMicros) {
+    return (weiValue * ethUsdMicros) / WEI_PER_ETH;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kairoguard/sdk",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Kairo SDK for multi-chain policy-based transaction signing with dWallet support (EVM, Bitcoin, Solana, Sui)",
   "license": "MIT",
   "author": "Kairo <mehraab@thewidercollective.com>",