@gardenfi/wallet-connectors 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/src/bitcoin/btcWalletsProvider.d.ts

@@ -3,6 +3,7 @@ import { OKXBitcoinProvider } from './providers/okx/okx.types';
 import { UnisatBitcoinProvider } from './providers/unisat/unisat.types';
 import { XVerseBitcoinProvider } from './providers/xverse/xverse.types';
 import { XdefiBitcoinProvider } from './providers/xdefi/xdefi.types';
+import { CtrlLitecoinProvider } from '../litecoin/providers/ctrl/ctrl.types';
 import { PhantomBitcoinProvider } from './providers/phantom/phantom.types';
 import { KeplrBitcoinProvider } from './providers/keplr/keplr.types';
 import { BTCWalletProviderContextType, BTCWalletProviderProps } from './btcWalletsProvider.types';
@@ -19,6 +20,7 @@ declare global {
         unisat?: UnisatBitcoinProvider;
         xfi?: {
             bitcoin: XdefiBitcoinProvider;
+            litecoin?: CtrlLitecoinProvider;
         };
         phantom?: {
             bitcoin: PhantomBitcoinProvider;

package/dist/src/bitcoin/btcWalletsProvider.types.d.ts

@@ -18,8 +18,6 @@ export type BTCWalletProviderContextType = {
 export type CustomWalletConfig = {
     id: string;
     provider: IInjectedBitcoinProvider;
-    registerConnect?: (connect: () => void) => void | (() => void);
-    registerDisconnect?: (disconnect: () => void) => void | (() => void);
 };
 export type BTCWalletProviderProps = {
     network: Network;

package/dist/src/bitcoin/index.d.ts

@@ -1,5 +1,5 @@
 export { BTCWalletProvider, useBitcoinWallet } from './btcWalletsProvider';
-export { SupportedWallets } from './constants';
+export { SupportedWallets as SupportedBTCWallets } from './constants';
 export { getBalance } from './utils';
 export type { IInjectedBitcoinProvider, Balance, Connect, } from './bitcoin.types';
-export type { AvailableWallets, BTCWalletProviderProps, CustomWalletConfig, } from './btcWalletsProvider.types';
+export type { AvailableWallets as AvailableBTCWallets, BTCWalletProviderProps, CustomWalletConfig, } from './btcWalletsProvider.types';

package/dist/src/index.d.ts

@@ -1 +1,3 @@
 export * from './bitcoin';
+export * from './litecoin';
+export * from './spark';

package/dist/src/litecoin/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const SupportedWallets: {
+    Ctrl: {
+        id: string;
+        name: string;
+        icon: string;
+    };
+};
+export declare const WALLET_CONFIG: {
+    readonly Ctrl: {
+        readonly id: "ctrl";
+        readonly name: "CTRL Wallet";
+        readonly icon: "https://garden.imgix.net/wallets/ctrl.svg";
+    };
+};

package/dist/src/litecoin/index.d.ts

@@ -0,0 +1,5 @@
+export { LTCWalletProvider, useLitecoinWallet } from './ltcWalletsProvider';
+export { SupportedWallets as SupportedLTCWallets } from './constants';
+export { getBalance } from '../bitcoin/utils';
+export type { IInjectedLitecoinProvider, LtcBalance } from './litecoin.types';
+export type { AvailableWallets as AvailableLTCWallets, LTCWalletProviderProps, } from './ltcWalletsProvider.types';

package/dist/src/litecoin/litecoin.types.d.ts

@@ -0,0 +1,51 @@
+import { AsyncResult, Network } from '@gardenfi/utils';
+import { WALLET_CONFIG } from './constants';
+
+export type LtcBalance = {
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+};
+export type Connect = {
+    address: string;
+    provider: IInjectedLitecoinProvider;
+    network: Network;
+    id: WalletId;
+};
+export type WalletId = (typeof WALLET_CONFIG)[keyof typeof WALLET_CONFIG]['id'];
+export type ProviderEvents = {
+    accountsChanged: (accounts: string[]) => void;
+};
+export interface IInjectedLitecoinProvider {
+    id: WalletId;
+    address: string;
+    name: string;
+    icon: string;
+    getBalance: () => AsyncResult<LtcBalance, string>;
+    /**
+     * requests accounts from the wallet, if not connected, it will connect first
+     * @returns {AsyncResult<string[], string>}
+     */
+    requestAccounts: () => AsyncResult<string[], string>;
+    /**
+     * silently gets accounts if already connected
+     * @returns {AsyncResult<string[], string>}
+     */
+    getAccounts: () => AsyncResult<string[], string>;
+    sendLitecoin: (toAddress: string, satoshis: number) => AsyncResult<string, string>;
+    getNetwork: () => AsyncResult<Network, string>;
+    switchNetwork: () => AsyncResult<Network, string>;
+    connect: (network?: Network) => AsyncResult<Connect, string>;
+    disconnect: () => AsyncResult<string, string>;
+    on<E extends keyof ProviderEvents>(event: E, cb: ProviderEvents[E]): void;
+    off<E extends keyof ProviderEvents>(event: E, cb: ProviderEvents[E]): void;
+}
+export type SelectedAccount = {
+    address: string;
+    publicKey: string;
+};
+export interface LitecoinWallet {
+    name: string;
+    symbol: string;
+    connect: () => AsyncResult<IInjectedLitecoinProvider, string>;
+}

package/dist/src/litecoin/ltcWalletsProvider.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { LTCWalletProviderContextType, LTCWalletProviderProps } from './ltcWalletsProvider.types';
+
+export declare const LTCWalletProvider: ({ children, network, store, }: LTCWalletProviderProps) => React.JSX.Element;
+export declare const useLitecoinWallet: () => LTCWalletProviderContextType;

package/dist/src/litecoin/ltcWalletsProvider.types.d.ts

@@ -0,0 +1,22 @@
+import { IInjectedLitecoinProvider } from '.';
+import { AsyncResult, IStore, Network, Result } from '@gardenfi/utils';
+
+export type AvailableWallets = {
+    [key: string]: IInjectedLitecoinProvider;
+};
+export type LTCWalletProviderContextType = {
+    availableWallets: AvailableWallets;
+    connect: (LitecoinWallet: IInjectedLitecoinProvider, network?: Network) => AsyncResult<void, string>;
+    updateAccount: () => Promise<void>;
+    provider: IInjectedLitecoinProvider | undefined;
+    account: string | undefined;
+    network: Network | undefined;
+    disconnect: () => Result<void, string>;
+    isConnecting: boolean;
+    isConnected: boolean;
+};
+export type LTCWalletProviderProps = {
+    network: Network;
+    children: React.ReactNode;
+    store: IStore;
+};

package/dist/src/litecoin/providers/ctrl/ctrl.types.d.ts

@@ -0,0 +1,13 @@
+import { Network } from '@gardenfi/utils';
+
+type RequestFunction = ({ method, params }: {
+    method: string;
+    params: any[];
+}, callback: (error: any, result: any) => void) => void;
+export interface CtrlLitecoinProvider {
+    request: RequestFunction;
+    network?: Network;
+    on: (event: string, callback: (data: any) => void) => void;
+    off: (event: string, callback: (data: any) => void) => void;
+}
+export {};

package/dist/src/litecoin/providers/ctrl/provider.d.ts

@@ -0,0 +1,22 @@
+import { CtrlLitecoinProvider } from './ctrl.types';
+import { AsyncResult, Network } from '@gardenfi/utils';
+import { Connect, IInjectedLitecoinProvider, LtcBalance } from '../../litecoin.types';
+
+export declare class CtrlProvider implements IInjectedLitecoinProvider {
+    #private;
+    address: string;
+    id: "ctrl";
+    name: "CTRL Wallet";
+    icon: "https://garden.imgix.net/wallets/ctrl.svg";
+    constructor(ctrlProvider: CtrlLitecoinProvider);
+    connect(network?: Network): AsyncResult<Connect, string>;
+    requestAccounts(): AsyncResult<string[], string>;
+    getAccounts(): AsyncResult<string[], string>;
+    getNetwork(): AsyncResult<Network, string>;
+    switchNetwork(): AsyncResult<Network, string>;
+    getBalance(): AsyncResult<LtcBalance, string>;
+    sendLitecoin: (toAddress: string, satoshis: number) => AsyncResult<string, string>;
+    on: (event: string, callback: (data: any) => void) => void;
+    off: (event: string, callback: (data: any) => void) => void;
+    disconnect: () => AsyncResult<string, string>;
+}

package/dist/src/litecoin/utils.d.ts

@@ -0,0 +1,12 @@
+import { AsyncResult, Network } from '@gardenfi/utils';
+import { LtcBalance } from './litecoin.types';
+import { BitcoinUTXO } from '@gardenfi/core';
+
+import * as bitcoin from 'bitcoinjs-lib';
+export declare const LITECOIN_NETWORK: bitcoin.networks.Network;
+export declare const LITECOIN_TESTNET: bitcoin.networks.Network;
+export declare const getLitecoinNetwork: (network: Network) => bitcoin.networks.Network;
+export declare const getBalance: (address: string, network: Network) => AsyncResult<LtcBalance, string>;
+export declare const broadcastTransaction: (signedPsbtBase64: string, network: Network, pushPsbt?: (psbt: string) => Promise<string>) => AsyncResult<string, string>;
+export declare const getUTXOs: (address: string, network: Network) => AsyncResult<BitcoinUTXO[], string>;
+export declare const getRecommendedFeeRate: (network: Network) => AsyncResult<number, string>;

package/dist/src/spark/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const SupportedWallets: {
+    Xverse: {
+        name: string;
+        icon: string;
+        description: string;
+    };
+};
+export declare const WALLET_CONFIG: {
+    readonly Xverse: {
+        readonly id: "Xverse";
+        readonly name: "Xverse Wallet";
+        readonly icon: "https://garden.imgix.net/wallets/xverse.svg";
+    };
+};

package/dist/src/spark/index.d.ts

@@ -0,0 +1,5 @@
+export { SparkWalletProvider, useSparkWallet } from './providers/sparkWalletsProvider';
+export { XverseSparkProvider } from './providers/xverse/provider';
+export type { XVerseSparkProvider as XVerseSparkProviderType, XverseSparkNetworkType } from './providers/xverse/xverse.types';
+export type { AvailableWallets as AvailableSparkWallets, SparkWalletProviderProps, SparkWalletProviderContextType, } from './providers/sparkWalletsProvider.types';
+export type { IInjectedSparkProvider, SparkConnect, Balance as SparkBalance, WalletId as SparkWalletId, } from './spark.types';

package/dist/src/spark/providers/sparkWalletsProvider.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { XVerseSparkProvider as XVerseSparkProviderType } from './xverse/xverse.types';
+import { SparkWalletProviderContextType, SparkWalletProviderProps } from './sparkWalletsProvider.types';
+
+declare global {
+    interface Window {
+        XverseProviders?: {
+            BitcoinProvider: XVerseSparkProviderType;
+        };
+    }
+}
+export declare const SparkWalletProvider: ({ children, network, store, }: SparkWalletProviderProps) => React.JSX.Element;
+export declare const useSparkWallet: () => SparkWalletProviderContextType;

package/dist/src/spark/providers/sparkWalletsProvider.types.d.ts

@@ -0,0 +1,22 @@
+import { IInjectedSparkProvider } from '../spark.types';
+import { AsyncResult, IStore, Network, Result } from '@gardenfi/utils';
+
+export type AvailableWallets = {
+    [key: string]: IInjectedSparkProvider;
+};
+export type SparkWalletProviderContextType = {
+    availableWallets: AvailableWallets;
+    connect: (SparkWallet: IInjectedSparkProvider, network?: Network) => AsyncResult<void, string>;
+    updateAccount: () => Promise<void>;
+    provider: IInjectedSparkProvider | undefined;
+    account: string | undefined;
+    network: Network | undefined;
+    disconnect: () => Result<void, string>;
+    isConnecting: boolean;
+    isConnected: boolean;
+};
+export type SparkWalletProviderProps = {
+    network: Network;
+    children: React.ReactNode;
+    store: IStore;
+};

package/dist/src/spark/providers/xverse/provider.d.ts

@@ -0,0 +1,28 @@
+import { Balance, SparkConnect, IInjectedSparkProvider } from '../../spark.types';
+import { XVerseSparkProvider } from './xverse.types';
+import { AsyncResult, Network } from '@gardenfi/utils';
+
+export declare class XverseSparkProvider implements IInjectedSparkProvider {
+    #private;
+    address: string;
+    id: "Xverse";
+    name: "Xverse Wallet";
+    icon: "https://garden.imgix.net/wallets/xverse.svg";
+    constructor(provider: XVerseSparkProvider);
+    connect: (network?: Network) => AsyncResult<SparkConnect, string>;
+    getBalance: () => Promise<import('@gardenfi/utils').Result<Balance, string>>;
+    requestAccounts: () => AsyncResult<string[], string>;
+    getAccounts: () => AsyncResult<string[], string>;
+    sendSpark: (toAddress: string, satoshis: number) => AsyncResult<string, string>;
+    getNetwork(): Promise<import('@gardenfi/utils').Result<Network.MAINNET | Network.TESTNET, string>>;
+    switchNetwork(): AsyncResult<Network, string>;
+    /**
+     * not available in XVerse Spark wallet
+     */
+    on: () => void;
+    /**
+     * not available in XVerse Spark wallet
+     */
+    off: () => void;
+    disconnect: () => AsyncResult<string, string>;
+}

package/dist/src/spark/providers/xverse/xverse.types.d.ts

@@ -0,0 +1,11 @@
+export interface XVerseSparkProvider {
+    request: (method: string, params: any) => Promise<{
+        result?: any;
+        error?: any;
+        status: 'success' | 'error';
+    }>;
+}
+export declare enum XverseSparkNetworkType {
+    Mainnet = "mainnet",
+    Regtest = "regtest"
+}

package/dist/src/spark/spark.types.d.ts

@@ -0,0 +1,51 @@
+import { AsyncResult, Network } from '@gardenfi/utils';
+import { WALLET_CONFIG } from './constants';
+
+export type Balance = {
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+};
+export type SparkConnect = {
+    address: string;
+    provider: IInjectedSparkProvider;
+    network: Network;
+    id: WalletId;
+};
+export type WalletId = (typeof WALLET_CONFIG)[keyof typeof WALLET_CONFIG]['id'];
+export type ProviderEvents = {
+    accountsChanged: (accounts: string[]) => void;
+};
+export interface IInjectedSparkProvider {
+    id: WalletId;
+    address: string;
+    name: string;
+    icon: string;
+    getBalance: () => AsyncResult<Balance, string>;
+    /**
+     * requests accounts from the wallet, if not connected, it will connect first
+     * @returns {AsyncResult<string[], string>}
+     */
+    requestAccounts: () => AsyncResult<string[], string>;
+    /**
+     * silently gets accounts if already connected
+     * @returns {AsyncResult<string[], string>}
+     */
+    getAccounts: () => AsyncResult<string[], string>;
+    sendSpark: (toAddress: string, satoshis: number) => AsyncResult<string, string>;
+    getNetwork: () => AsyncResult<Network, string>;
+    switchNetwork: () => AsyncResult<Network, string>;
+    connect: (network?: Network) => AsyncResult<SparkConnect, string>;
+    disconnect: () => AsyncResult<string, string>;
+    on<E extends keyof ProviderEvents>(event: E, cb: ProviderEvents[E]): void;
+    off<E extends keyof ProviderEvents>(event: E, cb: ProviderEvents[E]): void;
+}
+export type SelectedAccount = {
+    address: string;
+    publicKey: string;
+};
+export interface SparkWallet {
+    name: string;
+    symbol: string;
+    connect: () => AsyncResult<IInjectedSparkProvider, string>;
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gardenfi/wallet-connectors",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.21",
   "type": "module",
   "scripts": {
     "build": "vite build",
     "test": "vitest run",
     "dev": "vite build --watch",
-    "link": "yarn link"
+    "link": "bun link"
   },
   "files": [
     "dist"
@@ -37,11 +37,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@gardenfi/core": "3.0.1-beta.1",
-    "@gardenfi/utils": "3.0.0-beta.1",
+    "@gardenfi/core": "3.1.3-beta.9",
+    "@gardenfi/utils": "3.1.1-beta.7",
     "axios": "^1.7.9",
     "bitcoinjs-lib": "^6.1.7",
+    "bitcore-lib-ltc": "^10.10.5",
     "react": "^18.3.1",
+    "sats-connect": "^4.2.1",
     "tiny-secp256k1": "^2.2.3"
   }
-}
+}