cosmos-connect-core 0.1.16 → 0.1.18

package/dist/adapters/CosmostationWallet.d.ts

@@ -34,6 +34,7 @@ export declare class CosmostationWallet implements WalletAdapter {
     installed(): boolean;
     getUri(): string;
     onUpdate(callback: () => void): void;
+    connectViaWalletConnect(chain: Chain): Promise<Account>;
     connect(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(_bytes: Uint8Array): Promise<Uint8Array>;

package/dist/adapters/CosmostationWallet.js

@@ -37,6 +37,11 @@ export class CosmostationWallet {
     onUpdate(callback) {
         this.wc?.onUpdate(callback);
     }
+    async connectViaWalletConnect(chain) {
+        if (!this.wc)
+            throw new Error('WalletConnect not initialized for Cosmostation');
+        return this.wc.connect(chain);
+    }
     async connect(chain) {
         const cosmostation = window.cosmostation?.providers.keplr;
         if (!cosmostation) {

package/dist/adapters/GalaxyStationWallet.d.ts

@@ -29,6 +29,7 @@ export declare class GalaxyStationWallet implements WalletAdapter {
     installed(): boolean;
     getUri(): string;
     onUpdate(callback: () => void): void;
+    connectViaWalletConnect(chain: Chain): Promise<Account>;
     connect(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(_bytes: Uint8Array): Promise<Uint8Array>;

package/dist/adapters/GalaxyStationWallet.js

@@ -44,6 +44,11 @@ export class GalaxyStationWallet {
     onUpdate(callback) {
         this.wc?.onUpdate(callback);
     }
+    async connectViaWalletConnect(chain) {
+        if (!this.wc)
+            throw new Error('WalletConnect not initialized for Galaxy Station');
+        return this.wc.connect(chain);
+    }
     async connect(chain) {
         const galaxyStation = window.galaxyStation;
         if (!galaxyStation) {

package/dist/adapters/KeplrWallet.d.ts

@@ -30,6 +30,7 @@ export declare class KeplrWallet implements WalletAdapter {
     installed(): boolean;
     getUri(): string;
     onUpdate(callback: () => void): void;
+    connectViaWalletConnect(chain: Chain): Promise<Account>;
     connect(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(_bytes: Uint8Array): Promise<Uint8Array>;

package/dist/adapters/KeplrWallet.js

@@ -37,6 +37,11 @@ export class KeplrWallet {
     onUpdate(callback) {
         this.wc?.onUpdate(callback);
     }
+    async connectViaWalletConnect(chain) {
+        if (!this.wc)
+            throw new Error('WalletConnect not initialized for Keplr');
+        return this.wc.connect(chain);
+    }
     async connect(chain) {
         const keplr = window.keplr;
         if (!keplr) {

package/dist/adapters/KeystoneWallet.d.ts

@@ -0,0 +1,48 @@
+import { WalletAdapter, Chain, Account } from '../core/types.js';
+export interface KeystoneWalletOptions {
+    /**
+     * Callback to show the QR scanner UI for reading CryptoMultiAccounts
+     * from the Keystone device (account sync).
+     * Must return the decoded UR data from the scanned QR code.
+     */
+    onScanAccountQR?: () => Promise<{
+        xfp: string;
+        keys: KeystoneKey[];
+    }>;
+    /**
+     * Callback to show the animated QR code for the Keystone device to scan,
+     * and then read the signed result QR back via webcam.
+     * @param ur - The UR-encoded sign request to display
+     * @returns The parsed signature from the scanned response QR
+     */
+    onSignQR?: (ur: {
+        type: string;
+        cbor: string;
+    }) => Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+}
+export interface KeystoneKey {
+    hdPath: string;
+    pubKey: Uint8Array;
+    index: number;
+}
+export declare class KeystoneWallet implements WalletAdapter {
+    id: string;
+    name: string;
+    icon: string;
+    private xfp;
+    private keys;
+    private currentAddress;
+    private currentPubKey;
+    private onScanAccountQR?;
+    private onSignQR?;
+    private _updateCallback?;
+    constructor(options?: KeystoneWalletOptions);
+    installed(): boolean;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(bytes: Uint8Array): Promise<Uint8Array>;
+}

package/dist/adapters/KeystoneWallet.js

@@ -0,0 +1,121 @@
+/**
+ * Derive a Cosmos bech32 address from a compressed secp256k1 public key.
+ * Uses ripemd160(sha256(pubkey)) → bech32.encode(prefix, words)
+ */
+async function pubKeyToAddress(compressedPubKey, prefix) {
+    // Use SubtleCrypto for SHA-256
+    const buf = new ArrayBuffer(compressedPubKey.byteLength);
+    new Uint8Array(buf).set(compressedPubKey);
+    const sha256Hash = new Uint8Array(await crypto.subtle.digest('SHA-256', buf));
+    // Manually compute RIPEMD-160 is complex — we'll dynamically import if available
+    // or use a lightweight approach
+    try {
+        const { ripemd160 } = await import('@noble/hashes/ripemd160');
+        const hash = ripemd160(sha256Hash);
+        const { bech32 } = await import('bech32');
+        return bech32.encode(prefix, bech32.toWords(hash));
+    }
+    catch {
+        // Fallback: try @cosmjs/crypto
+        try {
+            const cosmCrypto = await import('@cosmjs/crypto');
+            const cosmEncoding = await import('@cosmjs/encoding');
+            const sha = cosmCrypto.sha256(compressedPubKey);
+            const ripe = cosmCrypto.ripemd160(sha);
+            return cosmEncoding.toBech32(prefix, ripe);
+        }
+        catch {
+            throw new Error('Cannot derive address: install @noble/hashes + bech32, or @cosmjs/crypto + @cosmjs/encoding');
+        }
+    }
+}
+export class KeystoneWallet {
+    id = 'keystone';
+    name = 'Keystone';
+    icon = 'https://keyst.one/favicon.ico';
+    xfp = '';
+    keys = [];
+    currentAddress = '';
+    currentPubKey = new Uint8Array();
+    onScanAccountQR;
+    onSignQR;
+    _updateCallback;
+    constructor(options) {
+        this.onScanAccountQR = options?.onScanAccountQR;
+        this.onSignQR = options?.onSignQR;
+    }
+    installed() {
+        // Keystone is always available — it uses QR codes, no extension needed.
+        // Only requires a camera for scanning.
+        return (typeof navigator !== 'undefined' &&
+            typeof navigator.mediaDevices !== 'undefined');
+    }
+    onUpdate(callback) {
+        this._updateCallback = callback;
+    }
+    async connect(chain) {
+        // If we don't have keys yet, trigger the QR scan flow
+        if (this.keys.length === 0) {
+            if (!this.onScanAccountQR) {
+                throw new Error('Keystone requires onScanAccountQR callback to read account data from the device.');
+            }
+            const result = await this.onScanAccountQR();
+            this.xfp = result.xfp;
+            this.keys = result.keys;
+        }
+        if (this.keys.length === 0) {
+            throw new Error('No keys found from Keystone device.');
+        }
+        // Use the first key to derive the address for this chain's bech32 prefix
+        const key = this.keys[0];
+        this.currentPubKey = key.pubKey;
+        this.currentAddress = await pubKeyToAddress(key.pubKey, chain.bech32Prefix);
+        return {
+            address: this.currentAddress,
+            pubKey: this.currentPubKey,
+            algo: 'secp256k1',
+            name: 'Keystone',
+        };
+    }
+    async disconnect() {
+        this.xfp = '';
+        this.keys = [];
+        this.currentAddress = '';
+        this.currentPubKey = new Uint8Array();
+    }
+    async signTx(bytes) {
+        if (!this.onSignQR) {
+            throw new Error('Keystone requires onSignQR callback for transaction signing.');
+        }
+        if (this.keys.length === 0) {
+            throw new Error('Keystone not connected.');
+        }
+        try {
+            const { KeystoneCosmosSDK } = await import('@keystonehq/keystone-sdk');
+            const sdk = new KeystoneCosmosSDK();
+            // Generate the sign request UR
+            const signDataHex = Buffer.from(bytes).toString('hex');
+            const requestId = crypto.randomUUID();
+            const ur = sdk.generateSignRequest({
+                requestId,
+                signData: signDataHex,
+                dataType: 1,
+                accounts: [
+                    {
+                        path: this.keys[0].hdPath,
+                        xfp: this.xfp,
+                        address: this.currentAddress,
+                    },
+                ],
+            });
+            // Show QR and wait for user to scan back the signed result
+            const result = await this.onSignQR(ur);
+            // Convert hex signature to bytes
+            const sigBytes = new Uint8Array(result.signature.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+            return sigBytes;
+        }
+        catch (error) {
+            throw new Error(`Keystone signing failed: ${error.message}`);
+        }
+    }
+}

package/dist/adapters/LeapWallet.d.ts

@@ -28,6 +28,7 @@ export declare class LeapWallet implements WalletAdapter {
     installed(): boolean;
     getUri(): string;
     onUpdate(callback: () => void): void;
+    connectViaWalletConnect(chain: Chain): Promise<Account>;
     connect(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(_bytes: Uint8Array): Promise<Uint8Array>;

package/dist/adapters/LeapWallet.js

@@ -37,6 +37,11 @@ export class LeapWallet {
     onUpdate(callback) {
         this.wc?.onUpdate(callback);
     }
+    async connectViaWalletConnect(chain) {
+        if (!this.wc)
+            throw new Error('WalletConnect not initialized for Leap');
+        return this.wc.connect(chain);
+    }
     async connect(chain) {
         const leap = window.leap;
         if (!leap) {

package/dist/adapters/LedgerWallet.d.ts

@@ -0,0 +1,30 @@
+import { WalletAdapter, Chain, Account } from '../core/types.js';
+export interface LedgerWalletOptions {
+    /** Override coin type for specific chains */
+    coinTypePaths?: Record<string, number>;
+}
+export declare class LedgerWallet implements WalletAdapter {
+    id: string;
+    name: string;
+    icon: string;
+    private transport;
+    private signer;
+    private coinTypePaths;
+    constructor(options?: LedgerWalletOptions);
+    installed(): boolean;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(bytes: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the CosmJS-compatible offline signer for use with SigningStargateClient.
+     * This is the recommended way to sign transactions with Ledger.
+     *
+     * @example
+     * ```ts
+     * const signer = ledgerWallet.getOfflineSigner();
+     * const client = await SigningStargateClient.connectWithSigner(rpcUrl, signer);
+     * await client.sendTokens(sender, recipient, amount, fee);
+     * ```
+     */
+    getOfflineSigner(): any;
+}

package/dist/adapters/LedgerWallet.js

@@ -0,0 +1,117 @@
+/**
+ * HD derivation paths by coin type.
+ * Most Cosmos chains use coin_type 118; some have their own.
+ */
+const COIN_TYPE_PATHS = {
+    'columbus-5': 330,
+    'phoenix-1': 330,
+    'rebel-2': 330,
+    'secret-4': 529,
+    'injective-1': 60,
+    'evmos_9001-2': 60, // Evmos
+};
+const DEFAULT_COIN_TYPE = 118;
+function makeHdPath(coinType, account = 0) {
+    // BIP44: m/44'/coinType'/account'/0/0
+    return [44, coinType, account, 0, 0];
+}
+export class LedgerWallet {
+    id = 'ledger';
+    name = 'Ledger';
+    icon = 'https://raw.githubusercontent.com/AstroportFinance/astroport-token-lists/main/logos/ledger.svg';
+    transport = null;
+    signer = null;
+    coinTypePaths;
+    constructor(options) {
+        this.coinTypePaths = {
+            ...COIN_TYPE_PATHS,
+            ...options?.coinTypePaths,
+        };
+    }
+    installed() {
+        // Ledger is available if browser supports WebHID
+        return typeof navigator !== 'undefined' && !!navigator?.hid;
+    }
+    async connect(chain) {
+        // Dynamically import Ledger packages to avoid bundling them for non-Ledger users
+        const [{ default: TransportWebHID }, { LedgerSigner }, { stringToPath }] = await Promise.all([
+            import('@ledgerhq/hw-transport-webhid'),
+            import('@cosmjs/ledger-amino'),
+            import('@cosmjs/crypto'),
+        ]);
+        // Check WebHID support
+        if (!(await TransportWebHID.isSupported())) {
+            // Try WebUSB as fallback
+            try {
+                const { default: TransportWebUSB } = await import('@ledgerhq/hw-transport-webusb');
+                if (await TransportWebUSB.isSupported()) {
+                    this.transport = await TransportWebUSB.create();
+                }
+                else {
+                    throw new Error('No Ledger transport available. Use Chrome or a Chromium-based browser.');
+                }
+            }
+            catch {
+                throw new Error('No Ledger transport available. Use Chrome or a Chromium-based browser.');
+            }
+        }
+        else {
+            this.transport = await TransportWebHID.create();
+        }
+        const coinType = this.coinTypePaths[chain.chainId] ?? DEFAULT_COIN_TYPE;
+        const hdPath = stringToPath(`m/44'/${coinType}'/0'/0/0`);
+        this.signer = new LedgerSigner(this.transport, {
+            hdPaths: [hdPath],
+            prefix: chain.bech32Prefix,
+        });
+        const accounts = await this.signer.getAccounts();
+        if (!accounts || accounts.length === 0) {
+            throw new Error('No accounts found on Ledger. Make sure the Cosmos app is open.');
+        }
+        const acc = accounts[0];
+        return {
+            address: acc.address,
+            pubKey: acc.pubkey,
+            algo: acc.algo || 'secp256k1',
+            name: 'Ledger',
+            isNanoLedger: true,
+        };
+    }
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+        }
+        this.transport = null;
+        this.signer = null;
+    }
+    async signTx(bytes) {
+        if (!this.signer) {
+            throw new Error('Ledger not connected');
+        }
+        // Ledger uses Amino signing — the bytes should be an Amino-encoded SignDoc.
+        // For full tx signing, use getOfflineSigner() with SigningStargateClient.
+        throw new Error('Ledger signTx requires Amino signing. Use getOfflineSigner() with SigningStargateClient for full tx support.');
+    }
+    /**
+     * Get the CosmJS-compatible offline signer for use with SigningStargateClient.
+     * This is the recommended way to sign transactions with Ledger.
+     *
+     * @example
+     * ```ts
+     * const signer = ledgerWallet.getOfflineSigner();
+     * const client = await SigningStargateClient.connectWithSigner(rpcUrl, signer);
+     * await client.sendTokens(sender, recipient, amount, fee);
+     * ```
+     */
+    getOfflineSigner() {
+        if (!this.signer) {
+            throw new Error('Ledger not connected. Call connect() first.');
+        }
+        return this.signer;
+    }
+}

package/dist/adapters/StationWallet.d.ts

@@ -29,6 +29,7 @@ export declare class StationWallet implements WalletAdapter {
     installed(): boolean;
     getUri(): string;
     onUpdate(callback: () => void): void;
+    connectViaWalletConnect(chain: Chain): Promise<Account>;
     connect(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(_bytes: Uint8Array): Promise<Uint8Array>;

package/dist/adapters/StationWallet.js

@@ -47,6 +47,11 @@ export class StationWallet {
     onUpdate(callback) {
         this.wc?.onUpdate(callback);
     }
+    async connectViaWalletConnect(chain) {
+        if (!this.wc)
+            throw new Error('WalletConnect not initialized for Station');
+        return this.wc.connect(chain);
+    }
     async connect(chain) {
         const station = window.station;
         if (!station) {

package/dist/adapters/WalletConnectWallet.js

@@ -17,7 +17,7 @@ export class WalletConnectWallet {
             this.icon = icon;
         const details = mobileAppDetails || {
             name: 'Cosmos Connect',
-            android: 'intent://wcV2#Intent;package=com.chainapsis.keplr;scheme=keplrwallet;end;', // Default to Keplr for android
+            android: 'intent://wcV2#Intent;package=com.chainapsis.keplr;scheme=keplrwallet;end;',
             ios: 'keplrwallet://wcV2', // Default to Keplr for ios
         };
         const metadata = signerMetadata || {

package/dist/adapters/utils/WalletConnectV2.js

@@ -127,7 +127,7 @@ export class WalletConnectV2 {
                 console.log(`WalletConnectV2: URI generated (attempt ${attempt + 1}/${maxRetries})`, uri);
                 this._uri = uri;
                 this.onUriCbs.forEach((cb) => cb(uri));
-                console.log('WalletConnectV2: Waiting for approval...');
+                console.log(`WalletConnectV2: Waiting for approval (timeout: ${pairingTimeout}ms)...`);
                 try {
                     const approvalPromise = approval();
                     const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Connection approval timed out')), pairingTimeout));

package/dist/core/createClient.js

@@ -29,7 +29,7 @@ export function createClient(config) {
     function getWallet(walletId) {
         return wallets.find((w) => w.id === walletId);
     }
-    async function connect(walletId, chainId) {
+    async function connect(walletId, chainId, options) {
         try {
             const chain = getChain(chainId);
             if (!chain)
@@ -41,7 +41,9 @@ export function createClient(config) {
             if (!wallet.installed() && !wallet.getUri) {
                 throw new Error(`Wallet ${wallet.name} is not installed`);
             }
-            const account = await wallet.connect(chain);
+            const account = options?.forceWalletConnect && wallet.connectViaWalletConnect
+                ? await wallet.connectViaWalletConnect(chain)
+                : await wallet.connect(chain);
             setState({
                 currentChain: chain,
                 currentWallet: wallet,

package/dist/core/types.d.ts

@@ -19,6 +19,7 @@ export interface WalletAdapter {
     icon?: string;
     installed(): boolean;
     connect(chain: Chain): Promise<Account>;
+    connectViaWalletConnect?(chain: Chain): Promise<Account>;
     disconnect(): Promise<void>;
     signTx(bytes: Uint8Array): Promise<Uint8Array>;
     signMsg?(msg: string): Promise<Uint8Array>;
@@ -47,7 +48,9 @@ export interface StorageAdapter {
 export type Listener<T> = (state: T) => void;
 export interface Client {
     readonly state: ClientState;
-    connect(walletId: string, chainId: string): Promise<void>;
+    connect(walletId: string, chainId: string, options?: {
+        forceWalletConnect?: boolean;
+    }): Promise<void>;
     disconnect(): Promise<void>;
     signAndBroadcast(txBytes: Uint8Array): Promise<string>;
     subscribe(listener: Listener<ClientState>): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cosmos-connect-core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Core SDK for Cosmos Connect",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",