@initia/initia.js 1.0.21 → 2.0.0-rc.0

package/dist/entry.signer.mjs

@@ -0,0 +1,674 @@
+import { u as sortObject } from "./amino-CMQN7Frn.mjs";
+import { n as packPubKey } from "./public-key-DV-uGaUC.mjs";
+import { i as sha256, n as keccak256, r as ripemd160 } from "./hash-D40mxOlF.mjs";
+import { c as makeSignBytes } from "./sign-DqagxLcg.mjs";
+import { a as isEvmTxSigner, i as isEvmAddressable, n as isDirectSigner, o as isOfflineSigner, r as isEIP191Signer, t as isAminoSigner } from "./types-CLfdsa48.mjs";
+import { base64, bech32 } from "@scure/base";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { serializeTransaction } from "viem";
+//#region src/signer/keystore.ts
+/**
+* Type guard to check if a KeyStore supports key addition.
+*/
+function canAddKeys(store) {
+	return typeof store.add === "function";
+}
+/**
+* Type guard to check if a KeyStore supports key deletion.
+*/
+function canDeleteKeys(store) {
+	return typeof store.delete === "function";
+}
+/**
+* Type guard to check if a KeyStore supports mnemonic import.
+*/
+function canImportMnemonic(store) {
+	return typeof store.importMnemonic === "function";
+}
+/**
+* Abstract base class for KeyStore implementations.
+*
+* Provides common functionality and a template for implementing
+* custom key stores.
+*/
+var BaseKeyStore = class {
+	/**
+	* Get a key's info by ID.
+	*
+	* @param keyId - The key identifier
+	* @returns Key info or undefined if not found
+	*/
+	async get(keyId) {
+		return (await this.list()).find((k) => k.id === keyId);
+	}
+	/**
+	* Get all key IDs in the store.
+	*
+	* @returns Array of key IDs
+	*/
+	async listIds() {
+		return (await this.list()).map((k) => k.id);
+	}
+	/**
+	* Check if the store is empty.
+	*
+	* @returns True if no keys are stored
+	*/
+	async isEmpty() {
+		return (await this.list()).length === 0;
+	}
+	/**
+	* Get the count of keys in the store.
+	*
+	* @returns Number of keys
+	*/
+	async count() {
+		return (await this.list()).length;
+	}
+};
+//#endregion
+//#region src/signer/bridges/eip-hash.ts
+/**
+* EIP-191 and EIP-712 hashing utilities.
+*
+* Implemented using the SDK's own keccak256 from @noble/hashes,
+* avoiding viem runtime imports for zero additional bundle cost.
+*/
+/**
+* Hash a message according to EIP-191 personal sign.
+* Equivalent to viem's `hashMessage()`.
+*
+* Formula: keccak256("\x19Ethereum Signed Message:\n" + len + msg)
+*/
+function hashEIP191Message(message) {
+	const msgBytes = typeof message === "string" ? new TextEncoder().encode(message) : message.raw;
+	const prefix = `\x19Ethereum Signed Message:\n${msgBytes.length}`;
+	const prefixBytes = new TextEncoder().encode(prefix);
+	const combined = new Uint8Array(prefixBytes.length + msgBytes.length);
+	combined.set(prefixBytes, 0);
+	combined.set(msgBytes, prefixBytes.length);
+	return `0x${bytesToHex(keccak256(combined))}`;
+}
+/**
+* Hash typed structured data according to EIP-712.
+* Equivalent to viem's `hashTypedData()`.
+*
+* Formula: keccak256("\x19\x01" + domainSeparator + hashStruct(primaryType, message))
+*/
+function hashEIP712TypedData(data) {
+	const { domain, types, primaryType, message } = data;
+	const allTypes = {
+		EIP712Domain: buildDomainType(domain),
+		...types
+	};
+	const domainSeparator = hashStruct("EIP712Domain", domain, allTypes);
+	const messageHash = hashStruct(primaryType, message, allTypes);
+	const encoded = new Uint8Array(66);
+	encoded[0] = 25;
+	encoded[1] = 1;
+	encoded.set(domainSeparator, 2);
+	encoded.set(messageHash, 34);
+	return `0x${bytesToHex(keccak256(encoded))}`;
+}
+function buildDomainType(domain) {
+	const fields = [];
+	if (domain.name !== void 0) fields.push({
+		name: "name",
+		type: "string"
+	});
+	if (domain.version !== void 0) fields.push({
+		name: "version",
+		type: "string"
+	});
+	if (domain.chainId !== void 0) fields.push({
+		name: "chainId",
+		type: "uint256"
+	});
+	if (domain.verifyingContract !== void 0) fields.push({
+		name: "verifyingContract",
+		type: "address"
+	});
+	if (domain.salt !== void 0) fields.push({
+		name: "salt",
+		type: "bytes32"
+	});
+	return fields;
+}
+function encodeType(primaryType, types) {
+	const deps = findTypeDeps(primaryType, types, /* @__PURE__ */ new Set());
+	deps.delete(primaryType);
+	return [primaryType, ...Array.from(deps).sort()].map((t) => `${t}(${types[t].map((f) => `${f.type} ${f.name}`).join(",")})`).join("");
+}
+function findTypeDeps(type, types, found) {
+	if (found.has(type)) return found;
+	const fields = types[type];
+	if (!fields) return found;
+	found.add(type);
+	for (const field of fields) {
+		const baseType = field.type.replace(/\[\d*\]$/, "");
+		if (types[baseType]) findTypeDeps(baseType, types, found);
+	}
+	return found;
+}
+function typeHash(primaryType, types) {
+	return keccak256(new TextEncoder().encode(encodeType(primaryType, types)));
+}
+function hashStruct(primaryType, data, types) {
+	return keccak256(encodeData(primaryType, data, types));
+}
+function encodeData(primaryType, data, types) {
+	const fields = types[primaryType];
+	const chunks = [typeHash(primaryType, types)];
+	for (const field of fields) {
+		const value = data[field.name];
+		chunks.push(encodeValue(field.type, value, types));
+	}
+	return concatBytes(chunks);
+}
+function encodeValue(type, value, types) {
+	if (type.endsWith("[]")) {
+		const innerType = type.slice(0, -2);
+		return keccak256(concatBytes(value.map((v) => encodeValue(innerType, v, types))));
+	}
+	if (types[type]) return hashStruct(type, value, types);
+	return encodeAtomicValue(type, value);
+}
+function encodeAtomicValue(type, value) {
+	const word = new Uint8Array(32);
+	if (type === "address") {
+		const bytes = hexToBytes(value.replace(/^0x/, "").toLowerCase().padStart(40, "0"));
+		word.set(bytes, 12);
+		return word;
+	}
+	if (type === "bool") {
+		word[31] = value ? 1 : 0;
+		return word;
+	}
+	if (type === "string") return keccak256(new TextEncoder().encode(value));
+	if (type === "bytes") return keccak256(hexToBytes(value.replace(/^0x/, "")));
+	if (type.startsWith("bytes")) {
+		const bytes = hexToBytes(value.replace(/^0x/, ""));
+		word.set(bytes, 0);
+		return word;
+	}
+	if (type.startsWith("uint")) return hexToBytes(BigInt(value).toString(16).padStart(64, "0"));
+	if (type.startsWith("int")) {
+		let n = BigInt(value);
+		if (n < 0n) n = (1n << 256n) + n;
+		return hexToBytes(n.toString(16).padStart(64, "0"));
+	}
+	throw new Error(`Unsupported EIP-712 type: ${type}`);
+}
+function concatBytes(arrays) {
+	const totalLen = arrays.reduce((sum, a) => sum + a.length, 0);
+	const result = new Uint8Array(totalLen);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+//#endregion
+//#region src/signer/bridges/viem.ts
+/**
+* Viem bridge adapters.
+*
+* Provides bidirectional conversion between SDK key/signer types
+* and viem LocalAccount. Runtime viem dependency is limited to
+* serializeTransaction (shared with src/tx/evm.ts); all other
+* viem imports are type-only.
+*
+* keyToViemAccount: SDK RawKey -> viem LocalAccount (outbound)
+* createViemSigner: viem LocalAccount -> SDK OfflineSigner + EIP191Signer (inbound)
+*/
+/**
+* Convert an SDK RawKey into a viem-compatible LocalAccount.
+*
+* The returned account can be used with viem's `createWalletClient({ account })`,
+* `signMessage`, `signTransaction`, and `signTypedData`.
+*
+* @param key - SDK RawKey instance (must not be destroyed)
+* @returns viem LocalAccount
+* @throws if the key has been destroyed
+*
+* @example
+* ```typescript
+* import { RawKey } from 'initia.js'
+* import { keyToViemAccount } from 'initia.js/signer'
+* import { createWalletClient, http } from 'viem'
+*
+* const key = RawKey.fromHex('0x...')
+* const account = keyToViemAccount(key)
+* const client = createWalletClient({ account, transport: http(rpcUrl) })
+* ```
+*/
+function keyToViemAccount(key) {
+	const pkBytes = hexToBytes(key.getPrivateKeyHex().slice(2));
+	const address = key.evmAddress;
+	const publicKey = `0x${bytesToHex(key.publicKey)}`;
+	function signHash(hash) {
+		const sig = secp256k1.sign(hash, pkBytes, {
+			prehash: false,
+			lowS: true,
+			format: "recovered"
+		});
+		if (sig.length !== 65) throw new Error(`Expected 65-byte recovered signature, got ${sig.length} bytes`);
+		const recovery = sig[0];
+		return `0x${bytesToHex(sig.slice(1, 33))}${bytesToHex(sig.slice(33, 65))}${recovery === 0 ? "1b" : "1c"}`;
+	}
+	return {
+		address,
+		publicKey,
+		type: "local",
+		source: "custom",
+		async signMessage({ message }) {
+			return signHash(hexToBytes(hashEIP191Message(message).slice(2)));
+		},
+		async signTransaction(tx) {
+			const hash = keccak256(hexToBytes(serializeTransaction(tx).slice(2)));
+			const sig = secp256k1.sign(hash, pkBytes, {
+				prehash: false,
+				lowS: true,
+				format: "recovered"
+			});
+			return serializeTransaction(tx, {
+				r: `0x${bytesToHex(sig.slice(1, 33))}`,
+				s: `0x${bytesToHex(sig.slice(33, 65))}`,
+				yParity: sig[0]
+			});
+		},
+		async signTypedData(params) {
+			return signHash(hexToBytes(hashEIP712TypedData(params).slice(2)));
+		}
+	};
+}
+/**
+* Create an OfflineSigner from a viem LocalAccount.
+*
+* Accepts any viem account object (from privateKeyToAccount, mnemonicToAccount,
+* or custom accounts). Delegates signing to the account's methods.
+*
+* Requires an account with the `sign({ hash })` method (e.g., from
+* `privateKeyToAccount` or `mnemonicToAccount`). Generic LocalAccount
+* objects without `sign` are not supported for Direct/Amino signing.
+*
+* @param account - viem LocalAccount instance (must have `sign` method)
+* @param options - Bech32 prefix configuration
+* @returns OfflineSigner & EIP191Signer & EvmAddressable
+*
+* @example
+* ```typescript
+* import { privateKeyToAccount } from 'viem/accounts'
+* import { createViemSigner } from 'initia.js/signer'
+* import { createMinievmContext } from 'initia.js'
+*
+* const account = privateKeyToAccount('0x...')
+* const signer = createViemSigner(account)
+* const ctx = await createMinievmContext({ network: 'testnet', chainId: 'evm-1', signer })
+* ```
+*/
+function createViemSigner(account, options) {
+	const prefix = options?.bech32Prefix ?? "init";
+	if (!account.sign) throw new Error("viem LocalAccount must have a sign({ hash }) method. Use privateKeyToAccount() or mnemonicToAccount() to create a signing-capable account.");
+	const accountSign = account.sign;
+	const rawPubKey = hexToBytes(account.publicKey.slice(2));
+	const point = secp256k1.Point.fromHex(bytesToHex(rawPubKey));
+	const publicKey = point.toBytes(true);
+	const rawAddr = keccak256(point.toBytes(false).slice(1)).slice(12);
+	function getAddress(pfx) {
+		return bech32.encode(pfx ?? prefix, bech32.toWords(rawAddr));
+	}
+	async function viemSign(hash) {
+		const sigBytes = hexToBytes((await accountSign({ hash: `0x${bytesToHex(hash)}` })).slice(2));
+		if (sigBytes.length !== 65) throw new Error(`Expected 65-byte signature from viem account.sign, got ${sigBytes.length} bytes`);
+		return sigBytes.slice(0, 64);
+	}
+	return {
+		algorithm: "eth_secp256k1",
+		evmAddress: account.address,
+		async getPublicKey() {
+			return publicKey;
+		},
+		async getAddress(pfx) {
+			return getAddress(pfx);
+		},
+		async signDirect(_signerAddress, signDoc) {
+			const signature = await viemSign(keccak256(makeSignBytes(signDoc.bodyBytes, signDoc.authInfoBytes, signDoc.chainId, signDoc.accountNumber)));
+			const pubKeyAny = packPubKey(publicKey, "ethsecp256k1");
+			return {
+				signed: signDoc,
+				signature: {
+					pubKey: {
+						typeUrl: pubKeyAny.typeUrl,
+						value: pubKeyAny.value
+					},
+					signature
+				}
+			};
+		},
+		async signAmino(_signerAddress, signDoc) {
+			signDoc = sortObject(signDoc);
+			const signature = await viemSign(keccak256(new TextEncoder().encode(JSON.stringify(signDoc))));
+			return {
+				signed: signDoc,
+				signature: {
+					pub_key: {
+						type: "tendermint/PubKeyEthSecp256k1",
+						value: base64.encode(publicKey)
+					},
+					signature: base64.encode(signature)
+				}
+			};
+		},
+		async signPersonal(data) {
+			const sigBytes = hexToBytes((await account.signMessage({ message: { raw: data } })).slice(2));
+			if (sigBytes.length !== 65) throw new Error(`Expected 65-byte signature from signMessage, got ${sigBytes.length} bytes`);
+			const v = sigBytes[64];
+			if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new Error(`Unexpected recovery byte from signMessage: ${v}`);
+			return sigBytes.slice(0, 64);
+		}
+	};
+}
+//#endregion
+//#region src/signer/bridges/ethers.ts
+/**
+* ethers.js Signer -> SDK OfflineSigner bridge adapter.
+*
+* Uses duck typing (EthersSignerLike interface) to avoid
+* requiring ethers as a dependency. Users must install ethers
+* themselves if they want to use this adapter.
+*/
+/**
+* Create an OfflineSigner from an ethers.js Signer.
+*
+* Requires ethers v6 Wallet (must have signingKey with compressedPublicKey
+* and synchronous sign method). Abstract Signers without local key material
+* are not supported.
+*
+* @param ethersSigner - ethers.js Wallet instance (must have signingKey)
+* @param options - Bech32 prefix configuration
+* @returns OfflineSigner & EIP191Signer & EvmAddressable
+*
+* @example
+* ```typescript
+* import { ethers } from 'ethers'
+* import { createEthersSigner } from 'initia.js/signer'
+* import { createMinievmContext } from 'initia.js'
+*
+* const wallet = new ethers.Wallet('0x...')
+* const signer = createEthersSigner(wallet)
+* const ctx = await createMinievmContext({ network: 'testnet', chainId: 'evm-1', signer })
+* ```
+*/
+function createEthersSigner(ethersSigner, options) {
+	const prefix = options?.bech32Prefix ?? "init";
+	if (!ethersSigner.signingKey) throw new Error("ethers Signer must have a signingKey property. Use ethers.Wallet (not JsonRpcSigner or AbstractSigner) to create a signing-capable signer.");
+	const signingKey = ethersSigner.signingKey;
+	const publicKey = hexToBytes(signingKey.compressedPublicKey.replace(/^0x/, ""));
+	const rawAddr = keccak256(secp256k1.Point.fromHex(bytesToHex(publicKey)).toBytes(false).slice(1)).slice(12);
+	const evmAddr = `0x${bytesToHex(rawAddr)}`;
+	function getAddress(pfx) {
+		return bech32.encode(pfx ?? prefix, bech32.toWords(rawAddr));
+	}
+	function signHash(hash) {
+		const sig = signingKey.sign(hash);
+		if (typeof sig.r !== "string" || typeof sig.s !== "string") throw new Error("ethers signingKey.sign() returned unexpected format. Expected { r: string, s: string, v: number }.");
+		const rHex = sig.r.replace(/^0x/, "").padStart(64, "0");
+		const sHex = sig.s.replace(/^0x/, "").padStart(64, "0");
+		const r = hexToBytes(rHex);
+		const s = hexToBytes(sHex);
+		const result = new Uint8Array(64);
+		result.set(r, 0);
+		result.set(s, 32);
+		return result;
+	}
+	return {
+		algorithm: "eth_secp256k1",
+		evmAddress: evmAddr,
+		async getPublicKey() {
+			return publicKey;
+		},
+		async getAddress(pfx) {
+			return getAddress(pfx);
+		},
+		async signDirect(_signerAddress, signDoc) {
+			const signature = signHash(keccak256(makeSignBytes(signDoc.bodyBytes, signDoc.authInfoBytes, signDoc.chainId, signDoc.accountNumber)));
+			const pubKeyAny = packPubKey(publicKey, "ethsecp256k1");
+			return {
+				signed: signDoc,
+				signature: {
+					pubKey: {
+						typeUrl: pubKeyAny.typeUrl,
+						value: pubKeyAny.value
+					},
+					signature
+				}
+			};
+		},
+		async signAmino(_signerAddress, signDoc) {
+			signDoc = sortObject(signDoc);
+			const signature = signHash(keccak256(new TextEncoder().encode(JSON.stringify(signDoc))));
+			return {
+				signed: signDoc,
+				signature: {
+					pub_key: {
+						type: "tendermint/PubKeyEthSecp256k1",
+						value: base64.encode(publicKey)
+					},
+					signature: base64.encode(signature)
+				}
+			};
+		},
+		async signPersonal(data) {
+			const sigBytes = hexToBytes((await ethersSigner.signMessage(data)).replace(/^0x/, ""));
+			if (sigBytes.length !== 65) throw new Error(`Expected 65-byte signature from signMessage, got ${sigBytes.length} bytes`);
+			const v = sigBytes[64];
+			if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new Error(`Unexpected recovery byte from signMessage: ${v}`);
+			return sigBytes.slice(0, 64);
+		}
+	};
+}
+//#endregion
+//#region src/signer/bridges/walletconnect.ts
+/**
+* WalletConnect -> SDK OfflineSigner bridge adapter.
+*
+* Creates an OfflineSigner from a WalletConnect SignClient session.
+* Supports Cosmos signing (cosmos_signDirect, cosmos_signAmino)
+* and optionally EIP-191 signing (personal_sign) for minievm chains.
+*
+* Uses duck typing (WalletConnectClientLike) to avoid requiring
+* @walletconnect/sign-client as a dependency.
+*/
+/**
+* Recover compressed public key from an EIP-191 personal_sign signature.
+*
+* Signs a fixed identification message, then uses ecrecover to derive
+* the public key. This is a one-time operation per session.
+*
+* @param client - WalletConnect client
+* @param topic - Session topic
+* @param eip155ChainId - EIP-155 chain ID
+* @param address - EVM 0x address of the signer
+* @returns Compressed public key (33 bytes)
+*/
+async function recoverPublicKey(client, topic, eip155ChainId, address) {
+	const message = "Initia SDK: Verify account ownership";
+	const messageHex = `0x${bytesToHex(new TextEncoder().encode(message))}`;
+	const sigHex = await client.request({
+		topic,
+		chainId: `eip155:${eip155ChainId}`,
+		request: {
+			method: "personal_sign",
+			params: [messageHex, address]
+		}
+	});
+	const messageBytes = new TextEncoder().encode(message);
+	const prefix = `\x19Ethereum Signed Message:\n${messageBytes.length}`;
+	const prefixBytes = new TextEncoder().encode(prefix);
+	const fullMessage = new Uint8Array(prefixBytes.length + messageBytes.length);
+	fullMessage.set(prefixBytes, 0);
+	fullMessage.set(messageBytes, prefixBytes.length);
+	const msgHash = keccak256(fullMessage);
+	const sigBytes = hexToBytes(sigHex.replace(/^0x/, ""));
+	if (sigBytes.length !== 65) throw new Error(`Expected 65-byte signature from personal_sign, got ${sigBytes.length} bytes`);
+	const r = sigBytes.slice(0, 32);
+	const s = sigBytes.slice(32, 64);
+	const v = sigBytes[64];
+	const recovery = v >= 27 ? v - 27 : v;
+	if (recovery !== 0 && recovery !== 1) throw new Error(`Invalid recovery bit: ${v} (expected 0, 1, 27, or 28)`);
+	const compact = new Uint8Array(64);
+	compact.set(r, 0);
+	compact.set(s, 32);
+	try {
+		const recoveredPoint = secp256k1.Signature.fromBytes(compact, "compact").addRecoveryBit(recovery).recoverPublicKey(msgHash);
+		const compressed = recoveredPoint.toBytes(true);
+		const recoveredAddr = `0x${bytesToHex(keccak256(recoveredPoint.toBytes(false).slice(1)).slice(12))}`;
+		if (recoveredAddr.toLowerCase() !== address.toLowerCase()) throw new Error(`Recovered address ${recoveredAddr} does not match expected ${address}. The wallet may have signed with a different account.`);
+		return compressed;
+	} catch (err) {
+		if (err instanceof Error && err.message.includes("does not match")) throw err;
+		throw new Error(`Failed to recover public key from personal_sign signature: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+async function createWalletConnectSigner(client, options) {
+	const prefix = options.bech32Prefix ?? "init";
+	const cosmosChainId = `cosmos:${options.chainId}`;
+	const algo = options.algorithm ?? "eth_secp256k1";
+	if (options.eip155ChainId && algo !== "eth_secp256k1") throw new Error(`eip155ChainId requires algorithm 'eth_secp256k1', got '${algo}'. EVM signing uses keccak256-based addresses which are incompatible with secp256k1 (ripemd160) derivation.`);
+	let publicKey;
+	if (options.publicKey) publicKey = options.publicKey;
+	else {
+		let accounts = [];
+		try {
+			accounts = await client.request({
+				topic: options.topic,
+				chainId: cosmosChainId,
+				request: {
+					method: "cosmos_getAccounts",
+					params: []
+				}
+			});
+		} catch {}
+		if (accounts.length > 0 && accounts[0].pubkey) publicKey = base64.decode(accounts[0].pubkey);
+		else if (options.eip155ChainId) {
+			const evmAccounts = await client.request({
+				topic: options.topic,
+				chainId: `eip155:${options.eip155ChainId}`,
+				request: {
+					method: "eth_accounts",
+					params: []
+				}
+			});
+			if (evmAccounts.length === 0) throw new Error("Public key acquisition failed. cosmos_getAccounts returned no pubkey and no EVM accounts available for ecrecover. Provide publicKey option directly.");
+			publicKey = await recoverPublicKey(client, options.topic, options.eip155ChainId, evmAccounts[0]);
+		} else throw new Error("No accounts found in WalletConnect session. Provide publicKey option or ensure the wallet supports cosmos_getAccounts.");
+	}
+	let rawAddr;
+	if (algo === "eth_secp256k1") rawAddr = keccak256(secp256k1.Point.fromHex(bytesToHex(publicKey)).toBytes(false).slice(1)).slice(12);
+	else rawAddr = ripemd160(sha256(publicKey));
+	function getAddress(pfx) {
+		return bech32.encode(pfx ?? prefix, bech32.toWords(rawAddr));
+	}
+	async function signDirect(signerAddress, signDoc) {
+		const response = await client.request({
+			topic: options.topic,
+			chainId: cosmosChainId,
+			request: {
+				method: "cosmos_signDirect",
+				params: [{
+					signerAddress,
+					signDoc: {
+						bodyBytes: base64.encode(signDoc.bodyBytes),
+						authInfoBytes: base64.encode(signDoc.authInfoBytes),
+						chainId: signDoc.chainId,
+						accountNumber: signDoc.accountNumber.toString()
+					}
+				}]
+			}
+		});
+		return {
+			signed: {
+				bodyBytes: base64.decode(response.signed.bodyBytes),
+				authInfoBytes: base64.decode(response.signed.authInfoBytes),
+				chainId: response.signed.chainId,
+				accountNumber: BigInt(response.signed.accountNumber)
+			},
+			signature: {
+				pubKey: (() => {
+					if (response.signature.pub_key.type.startsWith("/")) return {
+						typeUrl: response.signature.pub_key.type,
+						value: base64.decode(response.signature.pub_key.value)
+					};
+					const pk = packPubKey(publicKey, algo === "eth_secp256k1" ? "ethsecp256k1" : "secp256k1");
+					return {
+						typeUrl: pk.typeUrl,
+						value: pk.value
+					};
+				})(),
+				signature: base64.decode(response.signature.signature)
+			}
+		};
+	}
+	async function signAmino(signerAddress, signDoc) {
+		const response = await client.request({
+			topic: options.topic,
+			chainId: cosmosChainId,
+			request: {
+				method: "cosmos_signAmino",
+				params: [{
+					signerAddress,
+					signDoc
+				}]
+			}
+		});
+		return {
+			signed: response.signed,
+			signature: {
+				pub_key: response.signature.pub_key,
+				signature: response.signature.signature
+			}
+		};
+	}
+	const base = {
+		algorithm: algo,
+		async getPublicKey() {
+			return publicKey;
+		},
+		async getAddress(pfx) {
+			return getAddress(pfx);
+		},
+		signDirect,
+		signAmino
+	};
+	if (options.eip155ChainId) {
+		const evmChainId = options.eip155ChainId;
+		const evmAddress = `0x${bytesToHex(rawAddr)}`;
+		return {
+			...base,
+			evmAddress,
+			async signPersonal(data) {
+				const dataHex = `0x${bytesToHex(data)}`;
+				const sigBytes = hexToBytes((await client.request({
+					topic: options.topic,
+					chainId: `eip155:${evmChainId}`,
+					request: {
+						method: "personal_sign",
+						params: [dataHex, evmAddress]
+					}
+				})).replace(/^0x/, ""));
+				if (sigBytes.length !== 65) throw new Error(`Expected 65-byte signature from personal_sign, got ${sigBytes.length} bytes`);
+				const v = sigBytes[64];
+				if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new Error(`Unexpected recovery byte from personal_sign: ${v}`);
+				return sigBytes.slice(0, 64);
+			}
+		};
+	}
+	return base;
+}
+//#endregion
+export { BaseKeyStore, canAddKeys, canDeleteKeys, canImportMnemonic, createEthersSigner, createViemSigner, createWalletConnectSigner, isAminoSigner, isDirectSigner, isEIP191Signer, isEvmAddressable, isEvmTxSigner, isOfflineSigner, keyToViemAccount };
+
+//# sourceMappingURL=entry.signer.mjs.map