@kairoguard/sdk 0.0.1

package/dist/client.js

@@ -0,0 +1,767 @@
+/**
+ * KairoClient -- the main entry point for agents.
+ *
+ * Usage:
+ *   const kairo = new KairoClient({
+ *     apiKey: "ka_abc123...",
+ *   });
+ *   const wallet = await kairo.createWallet();
+ *   // { walletId: "0xabc...", address: "0x742d...", curve: "secp256k1" }
+ */
+import { BackendClient, } from "./backend.js";
+import { KeyStore } from "./keystore.js";
+import { Curve, fetchProtocolParams, deriveEncryptionKeys, generateSeed, generateSessionIdentifier, runDKG, computeUserOutputSignature, fetchDWallet, } from "./ika-protocol.js";
+import { Hash, SignatureAlgorithm, createUserSignMessageWithPublicOutput } from "@ika.xyz/sdk";
+import { computeEvmIntentFromUnsignedTxBytes } from "./evmIntent.js";
+import { keccak256, recoverTransactionAddress, serializeTransaction, } from "viem";
+const DEFAULT_SUI_RPC = "https://fullnode.testnet.sui.io:443";
+const DEFAULT_EVM_RPC_URLS = {
+    1: "https://rpc.ankr.com/eth",
+    11155111: "https://rpc.ankr.com/eth_sepolia",
+};
+const DKG_POLL_INTERVAL_MS = 2_000;
+const DKG_POLL_TIMEOUT_MS = 120_000;
+const PRESIGN_POLL_INTERVAL_MS = 2_000;
+const PRESIGN_POLL_TIMEOUT_MS = 120_000;
+const SIGN_POLL_INTERVAL_MS = 2_000;
+const SIGN_POLL_TIMEOUT_MS = 180_000;
+function curveToNumber(curve) {
+    return curve === "ed25519" ? 2 : 0;
+}
+export class KairoClient {
+    backend;
+    store;
+    suiRpcUrl;
+    network;
+    evmRpcUrls;
+    constructor(opts) {
+        this.backend = new BackendClient({ backendUrl: opts.backendUrl, apiKey: opts.apiKey });
+        this.store = new KeyStore(opts.storePath);
+        this.suiRpcUrl = opts.suiRpcUrl ?? DEFAULT_SUI_RPC;
+        this.network = opts.network ?? "testnet";
+        this.evmRpcUrls = { ...DEFAULT_EVM_RPC_URLS, ...(opts.evmRpcUrls ?? {}) };
+    }
+    /**
+     * Create a new dWallet. Runs DKG on the agent's machine, submits to backend,
+     * and optionally provisions the wallet in the vault.
+     *
+     * The agent's secret share is stored locally and never sent to the server.
+     */
+    async createWallet(opts) {
+        const curve = opts?.curve ?? "secp256k1";
+        // 1. Generate encryption seed and derive keys
+        const seed = generateSeed();
+        const encryptionKeys = await deriveEncryptionKeys(seed, curve);
+        // 2. Fetch protocol params from Ika network (runs locally, avoids backend memory limit)
+        const protocolParams = await fetchProtocolParams(curve, this.suiRpcUrl, this.network);
+        // 3. Generate session identifier
+        const sessionIdentifier = generateSessionIdentifier();
+        // 4. Get backend admin address (DKG must target the admin signer)
+        const health = await this.backend.getHealth();
+        const adminAddress = health.adminAddress;
+        // 5. Run client-side DKG
+        const dkgOutputs = await runDKG({
+            protocolPublicParameters: protocolParams,
+            curve,
+            encryptionKey: encryptionKeys.encryptionKey,
+            sessionIdentifier,
+            adminAddress,
+        });
+        // 6. Submit DKG to backend
+        const encKeySignature = await encryptionKeys.getEncryptionKeySignature();
+        const submitResult = await this.backend.submitDKG({
+            userPublicOutput: dkgOutputs.userPublicOutput,
+            userDkgMessage: dkgOutputs.userDKGMessage,
+            encryptedUserShareAndProof: dkgOutputs.encryptedUserShareAndProof,
+            sessionIdentifier: Array.from(sessionIdentifier),
+            signerPublicKey: Array.from(encryptionKeys.getPublicKey().toRawBytes()),
+            encryptionKeyAddress: encryptionKeys.getSuiAddress(),
+            encryptionKey: Array.from(encryptionKeys.encryptionKey),
+            encryptionKeySignature: Array.from(encKeySignature),
+            curve: curveToNumber(curve),
+        });
+        if (!submitResult.success) {
+            throw new Error(`DKG submit failed: ${submitResult.requestId}`);
+        }
+        // 7. Poll for DKG completion
+        const dkgResult = await this.pollDKGStatus(submitResult.requestId);
+        const walletId = dkgResult.dWalletObjectId;
+        const address = (curve === "ed25519" ? dkgResult.solanaAddress : dkgResult.ethereumAddress) ?? "";
+        const encryptedShareId = dkgResult.encryptedUserSecretKeyShareId ?? "";
+        // 8. Activate the dWallet (sign to accept encrypted key share)
+        if (encryptedShareId) {
+            await this.activateWallet(walletId, encryptedShareId, encryptionKeys, dkgOutputs.userPublicOutput);
+        }
+        // 9. Provision into vault (binding + registration) if policy is provided
+        let bindingObjectId;
+        if (opts?.policyObjectId) {
+            const provisionResult = await this.backend.provision({
+                dwalletObjectId: walletId,
+                policyObjectId: opts.policyObjectId,
+                stableId: opts.stableId ?? `agent-wallet-${walletId.slice(0, 8)}`,
+            });
+            bindingObjectId = provisionResult.bindingObjectId ?? undefined;
+        }
+        // 10. Save secret share locally
+        const record = {
+            walletId,
+            dWalletCapId: dkgResult.dWalletCapObjectId,
+            address,
+            curve,
+            seed: Array.from(seed),
+            userSecretKeyShare: dkgOutputs.userSecretKeyShare,
+            userPublicOutput: dkgOutputs.userPublicOutput,
+            encryptedUserSecretKeyShareId: encryptedShareId,
+            bindingObjectId,
+            policyObjectId: opts?.policyObjectId,
+            createdAt: Date.now(),
+        };
+        this.store.save(record);
+        return {
+            walletId,
+            address,
+            curve,
+            bindingObjectId,
+            createdAt: record.createdAt,
+        };
+    }
+    /** List all wallets in local key store. */
+    listWallets() {
+        return this.store.list().map((r) => ({
+            walletId: r.walletId,
+            address: r.address,
+            curve: r.curve,
+            bindingObjectId: r.bindingObjectId,
+            createdAt: r.createdAt,
+        }));
+    }
+    /** Get a wallet from local key store by ID. */
+    getWallet(walletId) {
+        const r = this.store.load(walletId);
+        if (!r)
+            return null;
+        return {
+            walletId: r.walletId,
+            address: r.address,
+            curve: r.curve,
+            bindingObjectId: r.bindingObjectId,
+            createdAt: r.createdAt,
+        };
+    }
+    /**
+     * Governance-first policy update: creates a new policy + version, then proposes
+     * a change for approvers. This method does NOT execute/reaffirm directly.
+     */
+    async updatePolicy(params) {
+        return this.proposePolicyUpdate(params);
+    }
+    /**
+     * Create and register a new policy version, then create governance proposal.
+     * This is the safe default for agents so policy changes require approvers.
+     */
+    async proposePolicyUpdate(params) {
+        const wallet = this.requireWalletRecord(params.walletId);
+        if (!wallet.bindingObjectId) {
+            throw new Error("Wallet is missing bindingObjectId. Provision the wallet before proposing policy updates.");
+        }
+        const createBody = {
+            stableId: params.stableId,
+            version: params.version,
+            expiresAtMs: params.expiresAtMs,
+            allowNamespaces: params.allowNamespaces,
+            allowChainIds: params.allowChainIds,
+            allowDestinations: params.allowDestinations,
+            denyDestinations: params.denyDestinations,
+            rules: params.rules,
+        };
+        const created = await this.backend.createPolicyV4(createBody);
+        if (!created.success || !created.policyObjectId?.startsWith("0x")) {
+            throw new Error(created.error ?? "Failed to create policy");
+        }
+        const registered = await this.backend.registerPolicyVersionFromPolicy({
+            policyObjectId: created.policyObjectId,
+            note: params.note ?? `sdk policy update ${params.version}`,
+            registryObjectId: params.registryObjectId,
+        });
+        if (!registered.success || !registered.policyVersionObjectId?.startsWith("0x")) {
+            throw new Error(registered.error ?? "Failed to register policy version");
+        }
+        const proposed = await this.backend.proposeGovernancePolicyChange({
+            governanceId: params.governanceId,
+            bindingId: wallet.bindingObjectId,
+            targetVersionId: registered.policyVersionObjectId,
+        });
+        if (!proposed.success || !proposed.proposalId?.startsWith("0x")) {
+            throw new Error(proposed.error ?? "Failed to propose governance policy change");
+        }
+        // Track latest policy target locally; governance execution still required.
+        this.store.save({
+            ...wallet,
+            policyObjectId: created.policyObjectId,
+        });
+        return {
+            walletId: params.walletId,
+            governanceId: params.governanceId,
+            bindingObjectId: wallet.bindingObjectId,
+            policyObjectId: created.policyObjectId,
+            policyVersionObjectId: registered.policyVersionObjectId,
+            proposalId: proposed.proposalId,
+            policyDigest: created.digest,
+            registerDigest: registered.digest,
+            proposalDigest: proposed.digest,
+        };
+    }
+    async approvePolicyUpdate(params) {
+        const r = await this.backend.approveGovernancePolicyChange(params);
+        if (!r.success) {
+            throw new Error(r.error ?? "Failed to approve policy update proposal");
+        }
+        return { digest: r.digest };
+    }
+    async executePolicyUpdate(params) {
+        const wallet = this.requireWalletRecord(params.walletId);
+        if (!wallet.bindingObjectId) {
+            throw new Error("Wallet is missing bindingObjectId. Provision the wallet before executing policy updates.");
+        }
+        const r = await this.backend.executeAndReaffirmGovernancePolicyChange({
+            governanceId: params.governanceId,
+            proposalId: params.proposalId,
+            bindingObjectId: wallet.bindingObjectId,
+        });
+        if (!r.success) {
+            throw new Error(r.error ?? "Failed to execute and reaffirm policy update");
+        }
+        return { digest: r.digest };
+    }
+    async getPolicyUpdateStatus(proposalId) {
+        const proposalResp = await this.backend.getGovernanceProposal(proposalId);
+        if (!proposalResp.success || !proposalResp.proposal) {
+            throw new Error(proposalResp.error ?? "Failed to fetch governance proposal");
+        }
+        const proposal = proposalResp.proposal;
+        let threshold;
+        let timelockDurationMs;
+        if (proposal.governanceId?.startsWith("0x")) {
+            const govResp = await this.backend.getGovernance(proposal.governanceId);
+            if (govResp.success && govResp.governance) {
+                threshold = Number(govResp.governance.threshold);
+                timelockDurationMs = Number(govResp.governance.timelockDurationMs);
+            }
+        }
+        const approvalsCollected = proposal.approvals?.length ?? 0;
+        const approvalsNeeded = threshold !== undefined ? Math.max(0, threshold - approvalsCollected) : undefined;
+        let state = "awaiting_approvals";
+        if (proposal.cancelled) {
+            state = "cancelled";
+        }
+        else if (proposal.executed) {
+            state = "executed";
+        }
+        else if (threshold !== undefined && approvalsCollected < threshold) {
+            state = "awaiting_approvals";
+        }
+        else if (proposal.thresholdMetAtMs > 0 &&
+            timelockDurationMs !== undefined &&
+            timelockDurationMs > 0 &&
+            Date.now() < proposal.thresholdMetAtMs + timelockDurationMs) {
+            state = "awaiting_timelock";
+        }
+        else {
+            state = "ready_to_execute";
+        }
+        return {
+            proposal,
+            threshold,
+            timelockDurationMs,
+            approvalsCollected,
+            approvalsNeeded,
+            state,
+        };
+    }
+    async getPolicy(walletId) {
+        const wallet = this.requireWalletRecord(walletId);
+        if (!wallet.policyObjectId) {
+            throw new Error("Wallet has no policyObjectId recorded");
+        }
+        const response = await this.backend.getPolicy(wallet.policyObjectId);
+        if (!response.success || !response.policy) {
+            throw new Error(response.error ?? "Failed to fetch policy");
+        }
+        return response.policy;
+    }
+    async createPresign(walletId) {
+        const wallet = this.requireWalletRecord(walletId);
+        const req = await this.backend.requestPresign({
+            dWalletId: wallet.walletId,
+        });
+        if (!req.success) {
+            throw new Error(`Failed to request presign for wallet ${walletId}`);
+        }
+        const status = await this.pollPresignStatus(req.requestId);
+        return {
+            requestId: req.requestId,
+            presignId: status.presignId,
+            presignBytes: new Uint8Array(status.presignBytes),
+        };
+    }
+    async sign(walletId, messageHex, opts) {
+        const wallet = this.requireWalletRecord(walletId);
+        if (wallet.curve !== "secp256k1") {
+            throw new Error(`sign() currently supports secp256k1 wallets only (wallet curve: ${wallet.curve})`);
+        }
+        const messageHexNoPrefix = stripHexPrefix(messageHex);
+        if (!messageHexNoPrefix || messageHexNoPrefix.length % 2 !== 0) {
+            throw new Error("messageHex must be a non-empty even-length hex string");
+        }
+        let presignId = opts?.presignId;
+        let presignBytes = opts?.presignBytes;
+        if (!presignId || !presignBytes) {
+            if (presignId || presignBytes) {
+                throw new Error("When overriding presign, both presignId and presignBytes are required");
+            }
+            const presign = await this.createPresign(walletId);
+            presignId = presign.presignId;
+            presignBytes = presign.presignBytes;
+        }
+        const protocolParams = await fetchProtocolParams("secp256k1", this.suiRpcUrl, this.network);
+        const messageBytes = new Uint8Array(Buffer.from(messageHexNoPrefix, "hex"));
+        const userSignMessage = await this.computeUserSignMessageWithExtensionFallback(wallet, protocolParams, presignBytes, messageBytes);
+        const policyContext = opts?.policyContext ?? {
+            namespace: 1,
+            chainId: 1,
+            intentHashHex: keccak256(ensureHexPrefix(messageHexNoPrefix)),
+            destinationHex: "0x0000000000000000000000000000000000000000",
+            nativeValue: 0n,
+        };
+        const policyReceiptId = await this.mintPolicyReceipt(wallet, policyContext);
+        const dWalletCapId = wallet.dWalletCapId;
+        if (!dWalletCapId) {
+            throw new Error("Wallet record is missing dWalletCapId. Recreate/provision this wallet before signing.");
+        }
+        const req = await this.backend.requestSign({
+            dWalletId: wallet.walletId,
+            dWalletCapId,
+            encryptedUserSecretKeyShareId: wallet.encryptedUserSecretKeyShareId ?? "",
+            userOutputSignature: [],
+            presignId,
+            messageHex: messageHexNoPrefix,
+            userSignMessage: Array.from(userSignMessage),
+            policyReceiptId,
+            policyBindingObjectId: wallet.bindingObjectId,
+            policyObjectId: wallet.policyObjectId,
+            policyVersion: opts?.policyVersion ?? "1.0.0",
+            ethTx: opts?.ethTx,
+        });
+        if (!req.success) {
+            throw new Error(`Failed to request sign for wallet ${walletId}`);
+        }
+        const signStatus = await this.pollSignStatus(req.requestId);
+        return {
+            requestId: req.requestId,
+            signId: signStatus.signId,
+            presignId,
+            signatureHex: ensureHexPrefix(signStatus.signatureHex),
+        };
+    }
+    async signEvm(params) {
+        const wallet = this.requireWalletRecord(params.walletId);
+        const rpcUrl = this.resolveEvmRpcUrl(params.chainId, params.rpcUrl);
+        const value = toBigInt(params.value);
+        const nonceHex = await this.evmRpcCall(rpcUrl, "eth_getTransactionCount", [
+            wallet.address,
+            "pending",
+        ]);
+        const nonce = Number(BigInt(nonceHex));
+        const data = params.data ?? "0x";
+        const gasHex = await this.evmRpcCall(rpcUrl, "eth_estimateGas", [
+            {
+                from: wallet.address,
+                to: params.to,
+                value: ensureHexPrefix(value.toString(16)),
+                data,
+            },
+        ]);
+        const gas = BigInt(gasHex);
+        const gasPriceHex = await this.evmRpcCall(rpcUrl, "eth_gasPrice", []);
+        const gasPrice = BigInt(gasPriceHex);
+        const maxPriorityFeePerGas = gasPrice;
+        const maxFeePerGas = gasPrice * 2n;
+        const unsignedTx = {
+            type: "eip1559",
+            chainId: params.chainId,
+            nonce,
+            to: params.to,
+            value,
+            data,
+            gas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+        };
+        const serializedUnsigned = serializeTransaction(unsignedTx);
+        const evmIntent = computeEvmIntentFromUnsignedTxBytes({
+            chainId: params.chainId,
+            unsignedTxBytesHex: serializedUnsigned,
+        });
+        const signResult = await this.sign(params.walletId, serializedUnsigned, {
+            policyContext: {
+                namespace: 1,
+                chainId: params.chainId,
+                intentHashHex: evmIntent.intentHash,
+                destinationHex: params.to,
+                nativeValue: value,
+            },
+            ethTx: {
+                to: params.to,
+                value: value.toString(),
+                nonce,
+                gasLimit: gas.toString(),
+                maxFeePerGas: maxFeePerGas.toString(),
+                maxPriorityFeePerGas: maxPriorityFeePerGas.toString(),
+                chainId: params.chainId,
+                from: wallet.address,
+            },
+        });
+        const sigNoPrefix = stripHexPrefix(signResult.signatureHex);
+        let signedTx = null;
+        // Ika/backend may return either:
+        // - 64-byte compact ECDSA (r||s) without recovery id
+        // - 65-byte recoverable (r||s||v/yParity)
+        if (sigNoPrefix.length === 128) {
+            const r = ensureHexPrefix(sigNoPrefix.slice(0, 64));
+            const s = ensureHexPrefix(sigNoPrefix.slice(64, 128));
+            for (const yParity of [0, 1]) {
+                const candidate = serializeTransaction(unsignedTx, { r, s, yParity });
+                try {
+                    const recovered = await recoverTransactionAddress({
+                        serializedTransaction: candidate,
+                    });
+                    if (recovered.toLowerCase() === wallet.address.toLowerCase()) {
+                        signedTx = candidate;
+                        break;
+                    }
+                }
+                catch {
+                    // Try the other parity.
+                }
+            }
+            if (!signedTx) {
+                throw new Error("Failed to recover correct signer address from 64-byte signature");
+            }
+        }
+        else if (sigNoPrefix.length === 130) {
+            const r = ensureHexPrefix(sigNoPrefix.slice(0, 64));
+            const s = ensureHexPrefix(sigNoPrefix.slice(64, 128));
+            const vByte = Number.parseInt(sigNoPrefix.slice(128, 130), 16);
+            const yParity = (vByte === 27 || vByte === 28 ? vByte - 27 : vByte);
+            if (yParity !== 0 && yParity !== 1) {
+                throw new Error(`Unsupported signature v/yParity byte: ${vByte}`);
+            }
+            signedTx = serializeTransaction(unsignedTx, { r, s, yParity });
+        }
+        else {
+            throw new Error(`Unexpected signature length from sign endpoint: ${sigNoPrefix.length / 2} bytes`);
+        }
+        return signedTx;
+    }
+    async broadcastEvm(signedTx, rpcUrl) {
+        const txHash = await this.evmRpcCall(rpcUrl, "eth_sendRawTransaction", [signedTx]);
+        return ensureHexPrefix(txHash);
+    }
+    async getBalance(address, rpcUrl) {
+        const balanceHex = await this.evmRpcCall(rpcUrl, "eth_getBalance", [address, "latest"]);
+        return BigInt(balanceHex);
+    }
+    async activateWallet(walletId, encryptedShareId, encryptionKeys, userPublicOutput) {
+        // Wait a moment for the dWallet state to propagate
+        await new Promise((r) => setTimeout(r, 2000));
+        const dWallet = await fetchDWallet(this.suiRpcUrl, this.network, walletId);
+        const signature = await computeUserOutputSignature({
+            encryptionKeys,
+            dWallet,
+            userPublicOutput: new Uint8Array(userPublicOutput),
+        });
+        await this.backend.activateDWallet({
+            dWalletId: walletId,
+            encryptedUserSecretKeyShareId: encryptedShareId,
+            userOutputSignature: Array.from(signature),
+        });
+    }
+    async pollDKGStatus(requestId) {
+        const deadline = Date.now() + DKG_POLL_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const status = await this.backend.getDKGStatus(requestId);
+            if (status.status === "completed") {
+                if (!status.dWalletObjectId) {
+                    throw new Error("DKG completed but no dWalletObjectId returned");
+                }
+                return status;
+            }
+            if (status.status === "failed") {
+                throw new Error(`DKG failed: ${status.error ?? "unknown error"}`);
+            }
+            await new Promise((r) => setTimeout(r, DKG_POLL_INTERVAL_MS));
+        }
+        throw new Error(`DKG timed out after ${DKG_POLL_TIMEOUT_MS / 1000}s (requestId: ${requestId})`);
+    }
+    requireWalletRecord(walletId) {
+        const wallet = this.store.load(walletId);
+        if (!wallet) {
+            throw new Error(`Wallet not found in local key store: ${walletId}`);
+        }
+        return wallet;
+    }
+    async pollPresignStatus(requestId) {
+        const deadline = Date.now() + PRESIGN_POLL_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const status = await this.backend.getPresignStatus(requestId);
+            if (status.status === "completed") {
+                if (!status.presignId || !status.presignBytes) {
+                    throw new Error("Presign completed but missing presignId/presignBytes");
+                }
+                return status;
+            }
+            if (status.status === "failed") {
+                throw new Error(`Presign failed: ${status.error ?? "unknown error"}`);
+            }
+            await sleep(PRESIGN_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Presign timed out after ${PRESIGN_POLL_TIMEOUT_MS / 1000}s (requestId: ${requestId})`);
+    }
+    async pollSignStatus(requestId) {
+        const deadline = Date.now() + SIGN_POLL_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const status = await this.backend.getSignStatus(requestId);
+            if (status.status === "completed") {
+                if (!status.signatureHex) {
+                    throw new Error("Sign completed but no signatureHex returned");
+                }
+                return status;
+            }
+            if (status.status === "failed") {
+                throw new Error(`Sign failed: ${status.error ?? "unknown error"}`);
+            }
+            await sleep(SIGN_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Sign timed out after ${SIGN_POLL_TIMEOUT_MS / 1000}s (requestId: ${requestId})`);
+    }
+    async mintPolicyReceipt(wallet, ctx) {
+        if (!wallet.policyObjectId || !wallet.bindingObjectId) {
+            throw new Error("Wallet is missing policy binding metadata. Ensure it is provisioned with policyObjectId and bindingObjectId.");
+        }
+        const response = await this.backend.mintReceipt({
+            policyObjectId: wallet.policyObjectId,
+            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,
+        });
+        if (response.success === false) {
+            throw new Error(String(response.error ?? "Failed to mint policy receipt"));
+        }
+        if (response.allowed === false) {
+            throw new Error("Policy denied this signing intent");
+        }
+        const receiptId = String(response.receiptId ?? response.receiptObjectId ?? "");
+        if (!receiptId.startsWith("0x")) {
+            throw new Error("Policy receipt mint succeeded but no receipt id was returned");
+        }
+        return receiptId;
+    }
+    async computeUserSignMessageWithExtensionFallback(wallet, protocolParams, presignBytes, messageBytes) {
+        try {
+            return await createUserSignMessageWithPublicOutput(protocolParams, new Uint8Array(wallet.userPublicOutput), new Uint8Array(wallet.userSecretKeyShare), presignBytes, messageBytes, Hash.KECCAK256, SignatureAlgorithm.ECDSASecp256k1, Curve.SECP256K1);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            const likelyPresignDecodeIssue = msg.includes("unexpected end of input") ||
+                msg.includes("create_sign_centralized_party_message");
+            if (!likelyPresignDecodeIssue) {
+                throw error;
+            }
+            const fallback = await this.rebuildSigningMaterialFromChain(wallet, protocolParams);
+            return createUserSignMessageWithPublicOutput(protocolParams, fallback.verifiedPublicOutput, fallback.secretShare, presignBytes, messageBytes, Hash.KECCAK256, SignatureAlgorithm.ECDSASecp256k1, Curve.SECP256K1);
+        }
+    }
+    async rebuildSigningMaterialFromChain(wallet, protocolParams) {
+        if (!wallet.seed?.length) {
+            throw new Error("Wallet is missing seed; cannot rebuild signing material from chain");
+        }
+        if (!wallet.encryptedUserSecretKeyShareId?.startsWith("0x")) {
+            throw new Error("Wallet is missing encryptedUserSecretKeyShareId; cannot rebuild signing material from chain");
+        }
+        const encryptionKeys = await deriveEncryptionKeys(new Uint8Array(wallet.seed), "secp256k1");
+        const dWalletResp = await this.backend.getDWalletFull(wallet.walletId);
+        if (!dWalletResp.success || !dWalletResp.dWallet) {
+            throw new Error(dWalletResp.error ?? "Failed to fetch dWallet for fallback signing");
+        }
+        const encObj = await this.backend.getSuiObject(wallet.encryptedUserSecretKeyShareId);
+        if (!encObj.success) {
+            throw new Error(encObj.error ?? "Failed to fetch encrypted share object for fallback signing");
+        }
+        const fields = (encObj.object?.data?.content?.fields ?? {});
+        const normalized = buildNormalizedEncryptedShare(fields);
+        const { secretShare, verifiedPublicOutput } = await encryptionKeys.decryptUserShare(dWalletResp.dWallet, normalized, protocolParams);
+        return { secretShare, verifiedPublicOutput };
+    }
+    resolveEvmRpcUrl(chainId, explicitRpcUrl) {
+        const url = explicitRpcUrl ?? this.evmRpcUrls[chainId];
+        if (!url) {
+            throw new Error(`No EVM RPC URL configured for chainId ${chainId}`);
+        }
+        return url;
+    }
+    async evmRpcCall(rpcUrl, method, params) {
+        const res = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method,
+                params,
+            }),
+        });
+        const json = await res.json();
+        if (!res.ok) {
+            throw new Error(`EVM RPC request failed (${method}): HTTP ${res.status}`);
+        }
+        if (json.error) {
+            throw new Error(`EVM RPC error (${method}): ${json.error.message ?? "unknown error"}`);
+        }
+        if (json.result === undefined) {
+            throw new Error(`EVM RPC response missing result (${method})`);
+        }
+        return json.result;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripHexPrefix(value) {
+    return value.startsWith("0x") ? value.slice(2) : value;
+}
+function ensureHexPrefix(value) {
+    return (value.startsWith("0x") ? value : `0x${value}`);
+}
+function toBigInt(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return BigInt(value);
+    return value.startsWith("0x") ? BigInt(value) : BigInt(value);
+}
+function buildNormalizedEncryptedShare(fields) {
+    const { state } = normalizeMoveEnumState(fields.state);
+    const candidate = {
+        state,
+        encryption_key_address: String(fields.encryption_key_address ?? fields.encryptionKeyAddress ?? ""),
+        encrypted_centralized_secret_share_and_proof: fields.encrypted_centralized_secret_share_and_proof ??
+            fields.encryptedCentralizedSecretShareAndProof ??
+            fields.encrypted_user_share_and_proof ??
+            [],
+    };
+    const rawSig = candidate?.state?.KeyHolderSigned?.user_output_signature ??
+        candidate?.state?.KeyHolderSigned?.fields?.user_output_signature ??
+        candidate?.state?.user_output_signature ??
+        findNestedUserOutputSignature(fields.state) ??
+        null;
+    const sig = normalizeBytesLike(rawSig);
+    if (sig && sig.length > 0) {
+        candidate.state = {
+            KeyHolderSigned: {
+                ...(candidate.state?.KeyHolderSigned ?? {}),
+                user_output_signature: sig,
+            },
+        };
+    }
+    return candidate;
+}
+function normalizeBytesLike(v) {
+    if (Array.isArray(v) && v.every((x) => Number.isInteger(x) && x >= 0 && x <= 255)) {
+        return v;
+    }
+    if (typeof v === "string" && v.length > 0) {
+        try {
+            return Array.from(Buffer.from(v, "base64"));
+        }
+        catch {
+            return null;
+        }
+    }
+    if (v && typeof v === "object") {
+        const o = v;
+        if (Array.isArray(o.bytes))
+            return normalizeBytesLike(o.bytes);
+        if (Array.isArray(o.data))
+            return normalizeBytesLike(o.data);
+        if (Array.isArray(o.value))
+            return normalizeBytesLike(o.value);
+        if (o.fields)
+            return normalizeBytesLike(o.fields);
+    }
+    return null;
+}
+function normalizeMoveEnumState(stateRaw) {
+    if (!stateRaw || typeof stateRaw !== "object")
+        return { kind: "Unknown", state: {} };
+    const stateObj = stateRaw;
+    if (stateObj.fields && typeof stateObj.fields === "object") {
+        return normalizeMoveEnumState(stateObj.fields);
+    }
+    if (typeof stateObj.$kind === "string") {
+        const kind = String(stateObj.$kind);
+        const copy = { ...stateObj };
+        delete copy.$kind;
+        const flat = copy.fields && typeof copy.fields === "object"
+            ? { ...copy.fields }
+            : copy;
+        return { kind, state: { [kind]: flat } };
+    }
+    const keys = Object.keys(stateObj);
+    if (!keys.length)
+        return { kind: "Unknown", state: {} };
+    const kind = String(keys[0]);
+    const inner = stateObj[kind];
+    const flat = inner &&
+        typeof inner === "object" &&
+        inner.fields &&
+        typeof inner.fields === "object"
+        ? { ...inner.fields }
+        : (inner ?? {});
+    return { kind, state: { [kind]: flat } };
+}
+function findNestedUserOutputSignature(v, depth = 0) {
+    if (depth > 6 || v == null || typeof v !== "object")
+        return null;
+    if (Array.isArray(v)) {
+        for (const it of v) {
+            const r = findNestedUserOutputSignature(it, depth + 1);
+            if (r != null)
+                return r;
+        }
+        return null;
+    }
+    const obj = v;
+    if (obj.user_output_signature != null)
+        return obj.user_output_signature;
+    if (obj.fields != null) {
+        const r = findNestedUserOutputSignature(obj.fields, depth + 1);
+        if (r != null)
+            return r;
+    }
+    if (obj.KeyHolderSigned != null) {
+        const r = findNestedUserOutputSignature(obj.KeyHolderSigned, depth + 1);
+        if (r != null)
+            return r;
+    }
+    for (const k of Object.keys(obj)) {
+        const r = findNestedUserOutputSignature(obj[k], depth + 1);
+        if (r != null)
+            return r;
+    }
+    return null;
+}