cosmos-connect-core 0.1.0

package/dist/adapters/utils/QRCodeModal.d.ts

@@ -0,0 +1,20 @@
+export type MobileAppDetails = {
+    name: string;
+    android: string;
+    ios: string;
+    isStation?: boolean;
+    isLuncDash?: boolean;
+    description?: string;
+    url?: string;
+    icons?: string[];
+    projectId?: string;
+};
+export declare class QRCodeModal {
+    private details;
+    constructor(details: MobileAppDetails);
+    open(uri: string): void;
+    close(): void;
+    private getSchemeUri;
+    private generateAndroidIntent;
+    private generateIosIntent;
+}

package/dist/adapters/utils/QRCodeModal.js

@@ -0,0 +1,50 @@
+import { isAndroid, isMobile } from "./os.js";
+export class QRCodeModal {
+    details;
+    // Expose URI for external access (monkey-patch hook)
+    // Static or instance property? WalletConnectV2 creates a NEW instance each time.
+    // So we need a way to extract it.
+    // The official QRCodeModal renders to DOM.
+    // The WalletConnectWallet adapter will PATCH the prototype or instance.
+    constructor(details) {
+        this.details = details;
+    }
+    open(uri) {
+        console.log("QRCodeModalStub open called with:", uri);
+        // Default behavior is to redirect on mobile
+        if (isMobile() && typeof window !== "undefined") {
+            const schemeUri = this.getSchemeUri(uri);
+            if (this.details.isStation) {
+                window.location.href = schemeUri;
+            }
+            else if (isAndroid()) {
+                window.location.href = this.generateAndroidIntent(uri);
+            }
+            else {
+                window.location.href = this.generateIosIntent(uri);
+            }
+        }
+    }
+    close() {
+        console.log("QRCodeModalStub close called");
+    }
+    getSchemeUri(uri) {
+        return this.details.isStation
+            ? this.details.isLuncDash
+                ? `luncdash://wallet_connect?${encodeURIComponent(`payload=${encodeURIComponent(uri)}`)}`
+                : `https://terrastation.page.link/?link=https://terra.money?${encodeURIComponent(`action=wallet_connect&payload=${encodeURIComponent(uri)}`)}&apn=money.terra.station&ibi=money.terra.station&isi=1548434735`
+            : uri;
+    }
+    generateAndroidIntent(uri) {
+        const hashIndex = this.details.android.indexOf("#");
+        if (hashIndex === -1)
+            return this.details.android;
+        return (this.details.android.slice(0, hashIndex) +
+            "?" +
+            encodeURIComponent(uri) +
+            this.details.android.slice(hashIndex));
+    }
+    generateIosIntent(uri) {
+        return this.details.ios + "?" + encodeURIComponent(uri);
+    }
+}

package/dist/adapters/utils/WalletConnectV2.d.ts

@@ -0,0 +1,52 @@
+import { MobileAppDetails } from "./QRCodeModal.js";
+export type GetAccountResponse = {
+    name?: string | undefined;
+    address: string;
+    algo: string;
+    pubkey: string;
+};
+export type WcSignAminoResponse = {
+    signature: {
+        signature: string;
+    };
+    signed?: any | undefined;
+};
+export type SignAminoResponse = Required<WcSignAminoResponse>;
+export type WcSignDirectResponse = {
+    signature: {
+        signature: string;
+    };
+    signed?: any | undefined;
+};
+export type SignDirectResponse = Required<WcSignDirectResponse>;
+export type WalletConnectV2Config = {
+    disableConnectionCheck?: boolean;
+};
+export declare class WalletConnectV2 {
+    private readonly projectId;
+    private readonly mobileAppDetails;
+    private readonly sessionStorageKey;
+    private readonly accountStorageKey;
+    private readonly onDisconnectCbs;
+    private readonly onAccountChangeCbs;
+    private readonly onUriCbs;
+    private signClient;
+    private config?;
+    constructor(projectId: string, mobileAppDetails: MobileAppDetails, config?: WalletConnectV2Config);
+    onUri(cb: (uri: string) => unknown): () => void;
+    addChain(chainId: string, chainInfo: any): Promise<void>;
+    connect(chainIds: string[]): Promise<void>;
+    disconnect(): void;
+    onDisconnect(cb: () => unknown): () => void;
+    onAccountChange(cb: () => unknown): () => void;
+    getAccount(chainId: string): Promise<GetAccountResponse>;
+    signArbitrary(chainId: string, signerAddress: string, data: string): Promise<{
+        signature: string;
+    }>;
+    signAmino(chainId: string, signerAddress: string, stdSignDoc: any): Promise<SignAminoResponse>;
+    signDirect(chainId: string, signerAddress: string, signDoc: any): Promise<SignDirectResponse>;
+    private isConnected;
+    private _disconnect;
+    private request;
+    private toCosmosNamespace;
+}

package/dist/adapters/utils/WalletConnectV2.js

@@ -0,0 +1,284 @@
+// @ts-nocheck
+import SignClient from "@walletconnect/sign-client";
+import { isAndroid, isMobile } from "./os.js";
+import { debounce } from "lodash-es";
+const Method = {
+    GET_ACCOUNTS: "cosmos_getAccounts",
+    SIGN_AMINO: "cosmos_signAmino",
+    SIGN_DIRECT: "cosmos_signDirect",
+    SIGN_ARBITRARY: "keplr_signArbitrary",
+    ADD_CHAIN: "keplr_experimentalSuggestChain",
+};
+const Event = {
+    CHAIN_CHANGED: "chainChanged",
+    ACCOUNTS_CHANGED: "accountsChanged",
+};
+const DEFAULT_SIGN_OPTIONS = {
+    preferNoSetFee: true,
+    preferNoSetMemo: true,
+};
+export class WalletConnectV2 {
+    projectId;
+    mobileAppDetails;
+    sessionStorageKey;
+    accountStorageKey;
+    onDisconnectCbs;
+    onAccountChangeCbs;
+    onUriCbs;
+    signClient;
+    config;
+    constructor(projectId, mobileAppDetails, config) {
+        this.projectId = projectId;
+        this.mobileAppDetails = mobileAppDetails;
+        this.sessionStorageKey = `cosmes.wallet.${mobileAppDetails.name.toLowerCase()}.wcSession`;
+        this.accountStorageKey = `cosmes.wallet.${mobileAppDetails.name.toLowerCase()}.lastAccount`;
+        this.onDisconnectCbs = new Set();
+        this.onAccountChangeCbs = new Set();
+        this.onUriCbs = new Set();
+        this.signClient = null;
+        this.config = config;
+    }
+    onUri(cb) {
+        this.onUriCbs.add(cb);
+        return () => {
+            this.onUriCbs.delete(cb);
+        };
+    }
+    async addChain(chainId, chainInfo) {
+        if (!this.signClient) {
+            throw new Error("SignClient is not initialized");
+        }
+        await this.request(chainId, Method.ADD_CHAIN, {
+            chainInfo,
+        });
+    }
+    async connect(chainIds) {
+        // Initialise the sign client and event listeners if they don't already exist
+        if (!this.signClient) {
+            console.log("WalletConnectV2: Initializing SignClient...");
+            try {
+                this.signClient = await SignClient.init({
+                    projectId: this.projectId,
+                    relayUrl: "wss://relay.walletconnect.com",
+                    metadata: {
+                        name: this.mobileAppDetails.name,
+                        description: this.mobileAppDetails.description || "Cosmos App",
+                        url: this.mobileAppDetails.url ||
+                            (typeof window !== "undefined" ? window.location.origin : ""),
+                        icons: this.mobileAppDetails.icons || [],
+                    },
+                });
+                console.log("WalletConnectV2: SignClient initialized");
+            }
+            catch (err) {
+                console.error("WalletConnectV2: Failed to initialize SignClient", err);
+                throw err;
+            }
+            // Disconnect if the session is disconnected or expired
+            this.signClient.on("session_delete", ({ topic }) => this._disconnect(topic));
+            this.signClient.on("session_expire", ({ topic }) => this._disconnect(topic));
+            // Handle the `accountsChanged` event
+            const handleAccountChange = debounce(
+            // Handler is debounced as the `accountsChanged` event is fired once for
+            // each connected chain, but we only want to trigger the callback once.
+            () => this.onAccountChangeCbs.forEach((cb) => cb()), 300, { leading: true, trailing: false });
+            this.signClient.on("session_event", ({ params }) => {
+                if (params.event.name === Event.ACCOUNTS_CHANGED) {
+                    handleAccountChange();
+                }
+            });
+        }
+        // Check if a valid session already exists
+        const oldSession = localStorage.getItem(this.sessionStorageKey);
+        const chainIdsSet = new Set(chainIds);
+        if (oldSession) {
+            const { topic, chainIds: storedIds } = JSON.parse(oldSession);
+            const storedIdsSet = new Set(storedIds);
+            if (chainIds.every((id) => storedIdsSet.has(id))) {
+                // Assume we want a fresh session for the UI to show the QR code
+                // unless explicitly disabled.
+                if (this.config?.disableConnectionCheck) {
+                    return;
+                }
+                // Force disconnect old session to ensure a new URI is generated
+                this._disconnect(topic);
+            }
+            else {
+                // Otherwise, we need to merge the stored IDs with the requested IDs
+                for (const id of storedIds) {
+                    chainIdsSet.add(id);
+                }
+            }
+        }
+        // Initialise a new session
+        const { uri, approval } = await this.signClient.connect({
+            optionalNamespaces: {
+                cosmos: {
+                    chains: [...chainIdsSet].map((id) => this.toCosmosNamespace(id)),
+                    methods: Object.values(Method),
+                    events: Object.values(Event),
+                },
+            },
+        });
+        if (uri) {
+            console.log("WalletConnectV2: URI generated", uri);
+            this._uri = uri; // Store it locally too
+            this.onUriCbs.forEach((cb) => cb(uri));
+            console.log("WalletConnectV2: Waiting for approval...");
+            const approvalPromise = approval();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Connection approval timed out")), 60000));
+            const { topic } = await Promise.race([
+                approvalPromise,
+                timeoutPromise,
+            ]);
+            console.log("WalletConnectV2: Approved session topic", topic);
+            // Save this new session to local storage
+            const newSession = {
+                topic,
+                chainIds: [...chainIdsSet],
+            };
+            localStorage.setItem(this.sessionStorageKey, JSON.stringify(newSession));
+        }
+    }
+    disconnect() {
+        const session = localStorage.getItem(this.sessionStorageKey);
+        if (session) {
+            const { topic } = JSON.parse(session);
+            this._disconnect(topic);
+        }
+    }
+    onDisconnect(cb) {
+        this.onDisconnectCbs.add(cb);
+        return () => {
+            this.onDisconnectCbs.delete(cb);
+        };
+    }
+    onAccountChange(cb) {
+        this.onAccountChangeCbs.add(cb);
+        return () => {
+            this.onAccountChangeCbs.delete(cb);
+        };
+    }
+    async getAccount(chainId) {
+        if (!this.config?.disableConnectionCheck) {
+            const res = await this.request(chainId, Method.GET_ACCOUNTS, {});
+            // result might be array or single object depending on wallet impl, usually array
+            return Array.isArray(res) ? res[0] : res;
+        }
+        try {
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Request timed out")), 3000));
+            const resArray = await Promise.race([
+                this.request(chainId, Method.GET_ACCOUNTS, {}),
+                timeout,
+            ]);
+            const res = Array.isArray(resArray) ? resArray[0] : resArray;
+            // Store successful response
+            this.onDisconnect(() => {
+                localStorage.removeItem(this.accountStorageKey);
+            });
+            localStorage.setItem(this.accountStorageKey, JSON.stringify(res));
+            return res;
+        }
+        catch (e) {
+            // Try to get stored account data
+            const stored = localStorage.getItem(this.accountStorageKey);
+            if (stored) {
+                const account = JSON.parse(stored);
+                // Try to refresh in background
+                this.request(chainId, Method.GET_ACCOUNTS, {})
+                    .then((res) => {
+                    const accountData = Array.isArray(res) ? res[0] : res;
+                    localStorage.setItem(this.accountStorageKey, JSON.stringify(accountData));
+                })
+                    .catch(() => { });
+                this.onDisconnect(() => {
+                    localStorage.removeItem(this.accountStorageKey);
+                });
+                return account;
+            }
+            throw e;
+        }
+    }
+    async signArbitrary(chainId, signerAddress, data) {
+        return this.request(chainId, Method.SIGN_ARBITRARY, {
+            chainId,
+            signer: signerAddress,
+            type: "string",
+            data,
+        });
+    }
+    async signAmino(chainId, signerAddress, stdSignDoc) {
+        const { signature, signed } = await this.request(chainId, Method.SIGN_AMINO, {
+            signerAddress,
+            signDoc: stdSignDoc,
+            signOptions: DEFAULT_SIGN_OPTIONS,
+        });
+        return {
+            signature: signature,
+            signed: signed ?? stdSignDoc,
+        };
+    }
+    async signDirect(chainId, signerAddress, signDoc) {
+        const { signature, signed } = await this.request(chainId, Method.SIGN_DIRECT, {
+            signerAddress,
+            signDoc,
+            signOptions: DEFAULT_SIGN_OPTIONS,
+        });
+        return {
+            signature: signature,
+            signed: signed ?? signDoc,
+        };
+    }
+    isConnected(signClient, topic, timeoutSeconds) {
+        const tryPing = async () => signClient
+            .ping({ topic })
+            .then(() => true)
+            .catch(() => false);
+        const waitDisconnect = async () => new Promise((resolve) => {
+            // @ts-ignore
+            signClient.on("session_delete", (res) => {
+                if (topic === res.topic) {
+                    resolve(false);
+                }
+            });
+            // @ts-ignore
+            signClient.on("session_expire", (res) => {
+                if (topic === res.topic) {
+                    resolve(false);
+                }
+            });
+        });
+        const timeout = async () => new Promise((resolve) => setTimeout(() => resolve(false), timeoutSeconds * 1000));
+        return Promise.race([tryPing(), waitDisconnect(), timeout()]);
+    }
+    _disconnect(topic) {
+        const session = localStorage.getItem(this.sessionStorageKey);
+        if (!session || session.includes(topic)) {
+            localStorage.removeItem(this.sessionStorageKey);
+            this.onDisconnectCbs.forEach((cb) => cb());
+        }
+    }
+    async request(chainId, method, params) {
+        const session = localStorage.getItem(this.sessionStorageKey);
+        if (!session || !this.signClient) {
+            throw new Error("Session not found for " + chainId);
+        }
+        const { topic } = JSON.parse(session);
+        if (isMobile() && method !== Method.GET_ACCOUNTS) {
+            window.location.href = isAndroid()
+                ? this.mobileAppDetails.android
+                : this.mobileAppDetails.ios;
+        }
+        return this.signClient.request({
+            topic,
+            chainId: this.toCosmosNamespace(chainId),
+            request: {
+                method,
+                params,
+            },
+        });
+    }
+    toCosmosNamespace(chainId) {
+        return "cosmos:" + chainId;
+    }
+}

package/dist/adapters/utils/os.d.ts

@@ -0,0 +1 @@
+export { isAndroid, isIOS, isMobile } from "@goblinhunt/cosmes/wallet";

package/dist/adapters/utils/os.js

@@ -0,0 +1 @@
+export { isAndroid, isIOS, isMobile } from "@goblinhunt/cosmes/wallet";

package/dist/core/account.d.ts

@@ -0,0 +1 @@
+export declare function formatShortAddress(address: string, prefixLen?: number, suffixLen?: number): string;

package/dist/core/account.js

@@ -0,0 +1,7 @@
+// import { Account } from "./types.js";
+// Currently just a placeholder for potential account-related utilities
+export function formatShortAddress(address, prefixLen = 8, suffixLen = 4) {
+    if (!address)
+        return "";
+    return `${address.slice(0, prefixLen)}...${address.slice(-suffixLen)}`;
+}

package/dist/core/chain.d.ts

@@ -0,0 +1,4 @@
+import { Chain } from "./types.js";
+export declare const TERRA_CLASSIC: Chain;
+export declare const DEFAULT_CHAINS: Chain[];
+export declare function findChain(chains: Chain[], chainId: string): Chain | undefined;

package/dist/core/chain.js

@@ -0,0 +1,11 @@
+export const TERRA_CLASSIC = {
+    chainId: "columbus-5",
+    rpc: "https://rpc-columbus-5.garuda-defi.org/",
+    rest: "https://lcd-columbus-5.garuda-defi.org/",
+    bech32Prefix: "terra",
+    gasPrice: "28.325uluna", // Approximate gas price for LUNC
+};
+export const DEFAULT_CHAINS = [TERRA_CLASSIC];
+export function findChain(chains, chainId) {
+    return chains.find((c) => c.chainId === chainId);
+}

package/dist/core/createClient.d.ts

@@ -0,0 +1,2 @@
+import { Client, ClientConfig } from "./types.js";
+export declare function createClient(config: ClientConfig): Client;

package/dist/core/createClient.js

@@ -0,0 +1,157 @@
+import { defaultStorage } from "./storage.js";
+const STORAGE_KEY_CHAIN = "cosmos-connect.chain";
+const STORAGE_KEY_WALLET = "cosmos-connect.wallet";
+export function createClient(config) {
+    const { chains, wallets } = config;
+    const storage = config.storage || defaultStorage;
+    let state = {
+        currentChain: null,
+        currentWallet: null,
+        account: null,
+        status: "disconnected",
+    };
+    const listeners = new Set();
+    function setState(partial) {
+        state = { ...state, ...partial };
+        listeners.forEach((listener) => listener(state));
+    }
+    function getChain(chainId) {
+        return chains.find((c) => c.chainId === chainId);
+    }
+    function getWallet(walletId) {
+        return wallets.find((w) => w.id === walletId);
+    }
+    async function connect(walletId, chainId) {
+        try {
+            const chain = getChain(chainId);
+            if (!chain)
+                throw new Error(`Chain ${chainId} not found`);
+            const wallet = getWallet(walletId);
+            if (!wallet)
+                throw new Error(`Wallet ${walletId} not found`);
+            setState({ status: "connecting" });
+            if (!wallet.installed() && !wallet.getUri) {
+                throw new Error(`Wallet ${wallet.name} is not installed`);
+            }
+            const account = await wallet.connect(chain);
+            setState({
+                currentChain: chain,
+                currentWallet: wallet,
+                account,
+                status: "connected",
+            });
+            storage.setItem(STORAGE_KEY_CHAIN, chainId);
+            storage.setItem(STORAGE_KEY_WALLET, walletId);
+        }
+        catch (error) {
+            setState({ status: "disconnected", account: null });
+            throw error;
+        }
+    }
+    async function disconnect() {
+        if (state.currentWallet) {
+            try {
+                await state.currentWallet.disconnect();
+            }
+            catch (e) {
+                console.error("Wallet disconnect failed", e);
+            }
+        }
+        setState({
+            currentChain: null,
+            currentWallet: null,
+            account: null,
+            status: "disconnected",
+        });
+        storage.removeItem(STORAGE_KEY_CHAIN);
+        storage.removeItem(STORAGE_KEY_WALLET);
+    }
+    async function signAndBroadcast(txBytes) {
+        if (!state.currentChain || !state.currentWallet || !state.account) {
+            throw new Error("Client not connected");
+        }
+        // 1. Sign
+        const signedTxBytes = await state.currentWallet.signTx(txBytes);
+        // 2. Broadcast
+        const rpc = state.currentChain.rpc;
+        return await broadcastTx(rpc, signedTxBytes);
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        listener(state);
+        return () => {
+            listeners.delete(listener);
+        };
+    }
+    if (storage) {
+        const savedChainId = storage.getItem(STORAGE_KEY_CHAIN);
+        const savedWalletId = storage.getItem(STORAGE_KEY_WALLET);
+        if (savedChainId && savedWalletId) {
+            connect(savedWalletId, savedChainId).catch(console.error);
+        }
+    }
+    const client = {
+        get state() {
+            return state;
+        },
+        connect,
+        disconnect,
+        signAndBroadcast,
+        subscribe,
+        getChain,
+        getWallet,
+        getWallets: () => wallets,
+        getChains: () => chains,
+    };
+    let updateQueued = false;
+    // Subscribe to updates from wallets (e.g. for QR code URIs)
+    wallets.forEach((w) => {
+        if (w.onUpdate) {
+            w.onUpdate(() => {
+                if (!updateQueued) {
+                    updateQueued = true;
+                    queueMicrotask(() => {
+                        listeners.forEach((l) => l({ ...state }));
+                        updateQueued = false;
+                    });
+                }
+            });
+        }
+    });
+    return client;
+}
+// Browser-compatible base64 encoding
+function toBase64(bytes) {
+    let binary = "";
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+async function broadcastTx(rpc, signedTx) {
+    const txBytesBase64 = toBase64(signedTx);
+    const body = {
+        jsonrpc: "2.0",
+        id: "1",
+        method: "broadcast_tx_sync",
+        params: {
+            tx: txBytesBase64,
+        },
+    };
+    if (typeof fetch === "undefined") {
+        throw new Error("Fetch is not defined in this environment");
+    }
+    const res = await fetch(rpc, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        throw new Error(`RPC request failed with status ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+        throw new Error(json.error.message);
+    }
+    return json.result.hash;
+}

package/dist/core/storage.d.ts

@@ -0,0 +1,2 @@
+import { StorageAdapter } from "./types.js";
+export declare const defaultStorage: StorageAdapter;

package/dist/core/storage.js

@@ -0,0 +1,18 @@
+export const defaultStorage = {
+    getItem: (key) => {
+        if (typeof localStorage !== "undefined") {
+            return localStorage.getItem(key);
+        }
+        return null;
+    },
+    setItem: (key, value) => {
+        if (typeof localStorage !== "undefined") {
+            localStorage.setItem(key, value);
+        }
+    },
+    removeItem: (key) => {
+        if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(key);
+        }
+    },
+};

package/dist/core/types.d.ts

@@ -0,0 +1,55 @@
+export interface Chain {
+    chainId: string;
+    rpc: string;
+    rest?: string;
+    bech32Prefix: string;
+    gasPrice?: string;
+}
+export interface Account {
+    address: string;
+    pubKey: Uint8Array;
+    algo?: string;
+    name?: string;
+    isNanoLedger?: boolean;
+}
+export interface WalletAdapter {
+    id: string;
+    name: string;
+    icon?: string;
+    installed(): boolean;
+    connect(chain: Chain): Promise<Account>;
+    disconnect(): Promise<void>;
+    signTx(bytes: Uint8Array): Promise<Uint8Array>;
+    signMsg?(msg: string): Promise<Uint8Array>;
+    getUri?(): string;
+    onUpdate?(callback: () => void): void;
+}
+export type ClientStatus = "disconnected" | "connecting" | "connected";
+export interface ClientState {
+    currentChain: Chain | null;
+    currentWallet: WalletAdapter | null;
+    account: Account | null;
+    status: ClientStatus;
+}
+export interface ClientConfig {
+    chains: Chain[];
+    wallets: WalletAdapter[];
+    storage?: StorageAdapter;
+}
+export interface StorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export type Listener<T> = (state: T) => void;
+export interface Client {
+    readonly state: ClientState;
+    connect(walletId: string, chainId: string): Promise<void>;
+    disconnect(): Promise<void>;
+    signAndBroadcast(txBytes: Uint8Array): Promise<string>;
+    subscribe(listener: Listener<ClientState>): () => void;
+    getChain(chainId: string): Chain | undefined;
+    getWallet(walletId: string): WalletAdapter | undefined;
+    getWallets(): WalletAdapter[];
+    getChains(): Chain[];
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};