cosmos-connect-core 0.1.0

package/dist/adapters/CosmostationWallet.d.ts

@@ -0,0 +1,40 @@
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+interface CosmostationProvider {
+    providers: {
+        keplr: {
+            enable(chainId: string): Promise<void>;
+            getKey(chainId: string): Promise<{
+                name: string;
+                algo: string;
+                bech32Address: string;
+                pubKey: Uint8Array;
+                isNanoLedger: boolean;
+            }>;
+            getOfflineSigner(chainId: string): any;
+            signDirect(chainId: string, signer: string, signDoc: any): Promise<any>;
+            signArbitrary(chainId: string, signer: string, data: string): Promise<any>;
+        };
+    };
+}
+declare global {
+    interface Window {
+        cosmostation?: CosmostationProvider;
+    }
+}
+export declare class CosmostationWallet implements WalletAdapter {
+    id: "cosmostation";
+    name: string;
+    icon: string;
+    private wc?;
+    constructor(options?: {
+        projectId?: string;
+    });
+    installed(): boolean;
+    getUri(): string;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+    signMsg(_msg: string): Promise<Uint8Array>;
+}
+export {};

package/dist/adapters/CosmostationWallet.js

@@ -0,0 +1,68 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+import { WalletName } from "@goblinhunt/cosmes/wallet";
+export class CosmostationWallet {
+    id = WalletName.COSMOSTATION;
+    name = "Cosmostation";
+    icon = "https://raw.githubusercontent.com/cosmostation/cosmostation_token_resource/master/all_chains/cosmos/resource/cosmostation.png";
+    wc;
+    constructor(options) {
+        if (options?.projectId) {
+            this.wc = new WalletConnectWallet({
+                projectId: options.projectId,
+                id: this.id,
+                name: this.name,
+                icon: this.icon,
+                mobileAppDetails: {
+                    name: "Cosmostation",
+                    description: "Cosmostation Wallet",
+                    android: "intent://wc#Intent;package=wannabit.io.cosmostaion;scheme=cosmostation;end;",
+                    ios: "cosmostation://wc",
+                },
+            });
+        }
+    }
+    installed() {
+        return typeof window !== "undefined" && !!window.cosmostation;
+    }
+    getUri() {
+        return this.wc?.getUri() ?? "";
+    }
+    onUpdate(callback) {
+        this.wc?.onUpdate(callback);
+    }
+    async connect(chain) {
+        const cosmostation = window.cosmostation?.providers.keplr;
+        if (!cosmostation) {
+            if (this.wc) {
+                return this.wc.connect(chain);
+            }
+            throw new Error("Cosmostation extension not found");
+        }
+        try {
+            await cosmostation.enable(chain.chainId);
+            const key = await cosmostation.getKey(chain.chainId);
+            return {
+                address: key.bech32Address,
+                pubKey: key.pubKey,
+                algo: key.algo,
+                name: key.name,
+                isNanoLedger: key.isNanoLedger,
+            };
+        }
+        catch (error) {
+            throw new Error(`Cosmostation connection failed: ${error.message}`);
+        }
+    }
+    async disconnect() {
+        if (this.wc) {
+            await this.wc.disconnect();
+        }
+        return Promise.resolve();
+    }
+    async signTx(_bytes) {
+        throw new Error("signTx not fully implemented for raw bytes in Cosmostation yet.");
+    }
+    async signMsg(_msg) {
+        throw new Error("signMsg not implemented yet.");
+    }
+}

package/dist/adapters/GalaxyStationWallet.d.ts

@@ -0,0 +1,34 @@
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+interface GalaxyStation {
+    keplr: {
+        enable(chainId: string | string[]): Promise<void>;
+        getKey(chainId: string): Promise<{
+            name: string;
+            algo: string;
+            bech32Address: string;
+            pubKey: Uint8Array;
+            isNanoLedger: boolean;
+        }>;
+    };
+}
+declare global {
+    interface Window {
+        galaxyStation?: GalaxyStation;
+    }
+}
+export declare class GalaxyStationWallet implements WalletAdapter {
+    id: string;
+    name: string;
+    icon: string;
+    private wc?;
+    constructor(options?: {
+        projectId?: string;
+    });
+    installed(): boolean;
+    getUri(): string;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+}
+export {};

package/dist/adapters/GalaxyStationWallet.js

@@ -0,0 +1,64 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+export class GalaxyStationWallet {
+    id = "galaxy-station";
+    name = "Galaxy Station";
+    icon = "https://raw.githubusercontent.com/terra-money/station-assets/main/img/station.png";
+    wc;
+    constructor(options) {
+        if (options?.projectId) {
+            this.wc = new WalletConnectWallet({
+                projectId: options.projectId,
+                id: this.id,
+                name: this.name,
+                icon: this.icon,
+                mobileAppDetails: {
+                    name: "Galaxy Station",
+                    description: "Galaxy Station Wallet (Terra Classic)",
+                    android: "https://station.hexxagon.io/wcV2#Intent;package=io.hexxagon.station;scheme=galaxystation;end;",
+                    ios: "https://station.hexxagon.io/wcV2",
+                },
+            });
+        }
+    }
+    installed() {
+        return typeof window !== "undefined" && !!window.galaxyStation;
+    }
+    getUri() {
+        return this.wc?.getUri() ?? "";
+    }
+    onUpdate(callback) {
+        this.wc?.onUpdate(callback);
+    }
+    async connect(chain) {
+        const galaxyStation = window.galaxyStation;
+        if (!galaxyStation) {
+            if (this.wc) {
+                return this.wc.connect(chain);
+            }
+            throw new Error("Galaxy Station Wallet extension not found");
+        }
+        try {
+            const provider = galaxyStation.keplr;
+            await provider.enable(chain.chainId);
+            const key = await provider.getKey(chain.chainId);
+            return {
+                address: key.bech32Address,
+                pubKey: key.pubKey,
+                algo: key.algo,
+                name: key.name,
+            };
+        }
+        catch (error) {
+            throw new Error(`Galaxy Station Wallet connection failed: ${error.message}`);
+        }
+    }
+    async disconnect() {
+        if (this.wc) {
+            await this.wc.disconnect();
+        }
+        return Promise.resolve();
+    }
+    async signTx(_bytes) {
+        throw new Error("signTx not implemented for Galaxy Station yet.");
+    }
+}

package/dist/adapters/KeplrWallet.d.ts

@@ -0,0 +1,36 @@
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+interface Keplr {
+    enable(chainId: string): Promise<void>;
+    getKey(chainId: string): Promise<{
+        name: string;
+        algo: string;
+        bech32Address: string;
+        pubKey: Uint8Array;
+        isNanoLedger: boolean;
+    }>;
+    getOfflineSigner(chainId: string): any;
+    signDirect(chainId: string, signer: string, signDoc: any): Promise<any>;
+    signArbitrary(chainId: string, signer: string, data: string): Promise<any>;
+}
+declare global {
+    interface Window {
+        keplr?: Keplr;
+    }
+}
+export declare class KeplrWallet implements WalletAdapter {
+    id: "keplr";
+    name: string;
+    icon: string;
+    private wc?;
+    constructor(options?: {
+        projectId?: string;
+    });
+    installed(): boolean;
+    getUri(): string;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+    signMsg(_msg: string): Promise<Uint8Array>;
+}
+export {};

package/dist/adapters/KeplrWallet.js

@@ -0,0 +1,85 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+import { WalletName } from "@goblinhunt/cosmes/wallet";
+export class KeplrWallet {
+    id = WalletName.KEPLR;
+    name = "Keplr";
+    icon = "https://raw.githubusercontent.com/chainapsis/keplr-wallet/master/packages/extension/src/public/assets/img/logo-256.png";
+    wc;
+    constructor(options) {
+        if (options?.projectId) {
+            this.wc = new WalletConnectWallet({
+                projectId: options.projectId,
+                id: this.id,
+                name: this.name,
+                icon: this.icon,
+                mobileAppDetails: {
+                    name: "Keplr",
+                    description: "Keplr Wallet",
+                    android: "intent://wcV2#Intent;package=com.chainapsis.keplr;scheme=keplrwallet;end;",
+                    ios: "keplrwallet://wcV2",
+                },
+            });
+        }
+    }
+    installed() {
+        return typeof window !== "undefined" && !!window.keplr;
+    }
+    getUri() {
+        return this.wc?.getUri() ?? "";
+    }
+    onUpdate(callback) {
+        this.wc?.onUpdate(callback);
+    }
+    async connect(chain) {
+        const keplr = window.keplr;
+        if (!keplr) {
+            if (this.wc) {
+                return this.wc.connect(chain);
+            }
+            throw new Error("Keplr extension not found");
+        }
+        try {
+            await keplr.enable(chain.chainId);
+            const key = await keplr.getKey(chain.chainId);
+            return {
+                address: key.bech32Address,
+                pubKey: key.pubKey,
+                algo: key.algo,
+                name: key.name,
+                isNanoLedger: key.isNanoLedger,
+            };
+        }
+        catch (error) {
+            throw new Error(`Keplr connection failed: ${error.message}`);
+        }
+    }
+    async disconnect() {
+        if (this.wc) {
+            await this.wc.disconnect();
+        }
+        return Promise.resolve();
+    }
+    async signTx(_bytes) {
+        console.debug("Keplr signTx", _bytes.length);
+        // In a real implementation, you'd decode bytes to SignDoc or use signDirect/Amino
+        // Since the core SDK takes raw bytes, we assume the bytes ARE the signDoc or
+        // the user wants to sign these specific bytes.
+        // For Keplr, signDirect is common.
+        // NOTE: This is a simplified implementation. Real-world usage requires
+        // proper tx construction handling.
+        // For now, let's assume we use signDirect if we can decode the bytes
+        // or provide a helper for cosmes integrations.
+        throw new Error("signTx not fully implemented for raw bytes in Keplr yet. Use cosmes-compatible signers.");
+    }
+    async signMsg(_msg) {
+        console.debug("Keplr signMsg", _msg.length);
+        const keplr = window.keplr;
+        if (!keplr)
+            throw new Error("Keplr not found");
+        // Find current address (assumes already connected or we need to connect)
+        // For simplicity, we'll try to get the first address.
+        // This is often used for Siwe etc.
+        // return keplr.signArbitrary(...);
+        throw new Error("signMsg not implemented yet.");
+    }
+}

package/dist/adapters/LUNCDashWallet.d.ts

@@ -0,0 +1,6 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+export declare class LUNCDashWallet extends WalletConnectWallet {
+    constructor({ projectId }: {
+        projectId: string;
+    });
+}

package/dist/adapters/LUNCDashWallet.js

@@ -0,0 +1,19 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+export class LUNCDashWallet extends WalletConnectWallet {
+    constructor({ projectId }) {
+        super({
+            projectId,
+            id: "luncdash",
+            name: "LUNCDash",
+            icon: "https://luncdash.com/assets/logo-dash-r8Nezm76.png",
+            mobileAppDetails: {
+                name: "LUNCDash",
+                description: "Connect to LUNCDash",
+                url: "https://luncdash.com",
+                icons: ["https://luncdash.com/assets/logo-dash-r8Nezm76.png"],
+                android: "luncdash://wc",
+                ios: "luncdash://wc",
+            },
+        });
+    }
+}

package/dist/adapters/LeapWallet.d.ts

@@ -0,0 +1,33 @@
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+interface Leap {
+    enable(chainId: string): Promise<void>;
+    getKey(chainId: string): Promise<{
+        name: string;
+        algo: string;
+        bech32Address: string;
+        pubKey: Uint8Array;
+        isNanoLedger: boolean;
+    }>;
+    getOfflineSigner(chainId: string): any;
+}
+declare global {
+    interface Window {
+        leap?: Leap;
+    }
+}
+export declare class LeapWallet implements WalletAdapter {
+    id: "leap";
+    name: string;
+    icon: string;
+    private wc?;
+    constructor(options?: {
+        projectId?: string;
+    });
+    installed(): boolean;
+    getUri(): string;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+}
+export {};

package/dist/adapters/LeapWallet.js

@@ -0,0 +1,64 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+import { WalletName } from "@goblinhunt/cosmes/wallet";
+export class LeapWallet {
+    id = WalletName.LEAP;
+    name = "Leap";
+    icon = "https://raw.githubusercontent.com/leapwallet/assets/master/images/leap-cosmos-logo.png";
+    wc;
+    constructor(options) {
+        if (options?.projectId) {
+            this.wc = new WalletConnectWallet({
+                projectId: options.projectId,
+                id: this.id,
+                name: this.name,
+                icon: this.icon,
+                mobileAppDetails: {
+                    name: "Leap",
+                    description: "Leap Wallet",
+                    android: "leapcosmos://wcV2",
+                    ios: "leapcosmos://wcV2",
+                },
+            });
+        }
+    }
+    installed() {
+        return typeof window !== "undefined" && !!window.leap;
+    }
+    getUri() {
+        return this.wc?.getUri() ?? "";
+    }
+    onUpdate(callback) {
+        this.wc?.onUpdate(callback);
+    }
+    async connect(chain) {
+        const leap = window.leap;
+        if (!leap) {
+            if (this.wc) {
+                return this.wc.connect(chain);
+            }
+            throw new Error("Leap extension not found");
+        }
+        try {
+            await leap.enable(chain.chainId);
+            const key = await leap.getKey(chain.chainId);
+            return {
+                address: key.bech32Address,
+                pubKey: key.pubKey,
+                algo: key.algo,
+                name: key.name,
+            };
+        }
+        catch (error) {
+            throw new Error(`Leap connection failed: ${error.message}`);
+        }
+    }
+    async disconnect() {
+        if (this.wc) {
+            await this.wc.disconnect();
+        }
+        return Promise.resolve();
+    }
+    async signTx(_bytes) {
+        throw new Error("signTx not implemented for Leap yet.");
+    }
+}

package/dist/adapters/StationWallet.d.ts

@@ -0,0 +1,34 @@
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+interface Station {
+    keplr: {
+        enable(chainId: string): Promise<void>;
+        getKey(chainId: string): Promise<{
+            name: string;
+            algo: string;
+            bech32Address: string;
+            pubKey: Uint8Array;
+            isNanoLedger: boolean;
+        }>;
+    };
+}
+declare global {
+    interface Window {
+        station?: Station;
+    }
+}
+export declare class StationWallet implements WalletAdapter {
+    id: string;
+    name: string;
+    icon: string;
+    private wc?;
+    constructor(options?: {
+        projectId?: string;
+    });
+    installed(): boolean;
+    getUri(): string;
+    onUpdate(callback: () => void): void;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+}
+export {};

package/dist/adapters/StationWallet.js

@@ -0,0 +1,67 @@
+import { WalletConnectWallet } from "./WalletConnectWallet.js";
+export class StationWallet {
+    id = "station";
+    name = "Station Wallet";
+    icon = "https://raw.githubusercontent.com/terra-money/station-assets/main/img/station.png";
+    wc;
+    constructor(options) {
+        if (options?.projectId) {
+            this.wc = new WalletConnectWallet({
+                projectId: options.projectId,
+                id: this.id,
+                name: this.name,
+                icon: this.icon,
+                mobileAppDetails: {
+                    name: "Station Wallet",
+                    description: "Station Wallet (Interchain)",
+                    android: "terrastation://wc",
+                    ios: "terrastation://wc",
+                    isStation: true,
+                },
+            });
+        }
+    }
+    installed() {
+        // Note: Both Station and Galaxy Station might use window.station.
+        // Usually one is installed at a time.
+        return typeof window !== "undefined" && !!window.station;
+    }
+    getUri() {
+        return this.wc?.getUri() ?? "";
+    }
+    onUpdate(callback) {
+        this.wc?.onUpdate(callback);
+    }
+    async connect(chain) {
+        const station = window.station;
+        if (!station) {
+            if (this.wc) {
+                return this.wc.connect(chain);
+            }
+            throw new Error("Station Wallet extension not found");
+        }
+        try {
+            const provider = station.keplr;
+            await provider.enable(chain.chainId);
+            const key = await provider.getKey(chain.chainId);
+            return {
+                address: key.bech32Address,
+                pubKey: key.pubKey,
+                algo: key.algo,
+                name: key.name,
+            };
+        }
+        catch (error) {
+            throw new Error(`Station Wallet connection failed: ${error.message}`);
+        }
+    }
+    async disconnect() {
+        if (this.wc) {
+            await this.wc.disconnect();
+        }
+        return Promise.resolve();
+    }
+    async signTx(_bytes) {
+        throw new Error("signTx not implemented for Station Wallet yet.");
+    }
+}

package/dist/adapters/WalletConnectWallet.d.ts

@@ -0,0 +1,27 @@
+import { WalletConnectV2 } from "./utils/WalletConnectV2.js";
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+import { MobileAppDetails } from "./utils/QRCodeModal.js";
+export declare class WalletConnectWallet implements WalletAdapter {
+    id: string;
+    name: string;
+    icon: string;
+    private wc;
+    private _uri;
+    private _connecting;
+    private _updateCallback?;
+    constructor({ projectId, id, name, icon, mobileAppDetails, }: {
+        projectId: string;
+        id?: string;
+        name?: string;
+        icon?: string;
+        mobileAppDetails?: MobileAppDetails;
+    });
+    installed(): boolean;
+    getUri(): string;
+    private _connectPromise;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(_bytes: Uint8Array): Promise<Uint8Array>;
+    onUpdate(callback: () => void): void;
+    get client(): WalletConnectV2;
+}

package/dist/adapters/WalletConnectWallet.js

@@ -0,0 +1,89 @@
+import { WalletConnectV2 } from "./utils/WalletConnectV2.js";
+import { base64 } from "@goblinhunt/cosmes/codec";
+export class WalletConnectWallet {
+    id = "walletConnect";
+    name = "Other Wallets";
+    icon = "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Logo/Blue%20(Default)/Logo.svg";
+    wc;
+    _uri = "";
+    _connecting = false;
+    _updateCallback;
+    constructor({ projectId, id, name, icon, mobileAppDetails, }) {
+        if (id)
+            this.id = id;
+        if (name)
+            this.name = name;
+        if (icon)
+            this.icon = icon;
+        const details = mobileAppDetails || {
+            name: "Cosmos Connect",
+            description: "Connect to Cosmos app",
+            url: typeof window !== "undefined" ? window.location.origin : "",
+            icons: [
+                "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Logo/Blue%20(Default)/Logo.svg",
+            ],
+            android: "intent://wcV2#Intent;package=com.chainapsis.keplr;scheme=keplrwallet;end;", // Default to Keplr for android
+            ios: "keplrwallet://wcV2", // Default to Keplr for ios
+        };
+        this.wc = new WalletConnectV2(projectId, details);
+        this.wc.onUri((uri) => {
+            this._uri = uri;
+            this._updateCallback?.();
+        });
+    }
+    installed() {
+        return false;
+    }
+    getUri() {
+        return this._uri;
+    }
+    _connectPromise = null;
+    async connect(chain) {
+        if (this._connectPromise) {
+            console.log("WalletConnectWallet: connect already in progress, returning existing promise...");
+            return this._connectPromise;
+        }
+        this._connectPromise = (async () => {
+            console.log("WalletConnectWallet: connect called for chain", chain.chainId);
+            this._connecting = true;
+            try {
+                // This will trigger our onUri callback
+                console.log("WalletConnectWallet: triggering wc.connect...");
+                await this.wc.connect([chain.chainId]);
+                console.log("WalletConnectWallet: wc.connect settled");
+                // After approval, keys are set
+                const accountRes = await this.wc.getAccount(chain.chainId);
+                return {
+                    address: accountRes.address,
+                    pubKey: base64.decode(accountRes.pubkey),
+                    algo: accountRes.algo,
+                    name: accountRes.name,
+                };
+            }
+            catch (e) {
+                console.error("WalletConnectWallet: Connection failed", e);
+                throw e;
+            }
+            finally {
+                this._connecting = false;
+                this._connectPromise = null;
+            }
+        })();
+        return this._connectPromise;
+    }
+    async disconnect() {
+        this.wc.disconnect();
+        this._uri = "";
+        this._connecting = false;
+    }
+    async signTx(_bytes) {
+        throw new Error("signTx not implemented directly on adapter. Use client.signAndBroadcast");
+    }
+    onUpdate(callback) {
+        this._updateCallback = callback;
+    }
+    // Helper for direct access if needed
+    get client() {
+        return this.wc;
+    }
+}