@gardenfi/wallet-connectors 2.5.0 → 3.0.0-beta.10

package/dist/index9.js

@@ -1,110 +1,64 @@
-var g = (n) => {
-  throw TypeError(n);
+var y = (e) => {
+  throw TypeError(e);
 };
-var p = (n, t, r) => t.has(n) || g("Cannot " + r);
-var s = (n, t, r) => (p(n, t, "read from private field"), r ? r.call(n) : t.get(n)), P = (n, t, r) => t.has(n) ? g("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, r), y = (n, t, r, e) => (p(n, t, "write to private field"), e ? e.call(n, r) : t.set(n, r), r);
-import * as m from "bitcoinjs-lib";
-import { initEccLib as N } from "bitcoinjs-lib";
-import * as b from "tiny-secp256k1";
-import { Ok as u, Network as a, Err as i, executeWithTryCatch as l } from "@gardenfi/utils";
-import { WALLET_CONFIG as c } from "./index3.js";
-import { BitcoinProvider as I, BitcoinWallet as B } from "@gardenfi/core";
-import { getBalance as v } from "./index4.js";
-N(b);
-var o;
-class W {
-  constructor(t) {
-    P(this, o);
-    this.address = "", this.id = c.Phantom.id, this.name = c.Phantom.name, this.icon = c.Phantom.icon, this.disconnect = () => (this.address = "", Promise.resolve(u("Disconnected Phantom wallet"))), y(this, o, t);
+var g = (e, t, r) => t.has(e) || y("Cannot " + r);
+var n = (e, t, r) => (g(e, t, "read from private field"), r ? r.call(e) : t.get(e)), d = (e, t, r) => t.has(e) ? y("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), a = (e, t, r, w) => (g(e, t, "write to private field"), w ? w.call(e, r) : t.set(e, r), r);
+import { Ok as c, Err as o, executeWithTryCatch as h, Network as l } from "@gardenfi/utils";
+import { WALLET_CONFIG as u } from "./index3.js";
+var i, s;
+class E {
+  constructor(t, r) {
+    d(this, i);
+    d(this, s);
+    this.address = "", this.id = u.OKX.id, this.name = u.OKX.name, this.icon = u.OKX.icon, this.disconnect = () => (this.address = "", n(this, i).disconnect(), Promise.resolve(c("Disconnected OKX wallet"))), a(this, i, t), a(this, s, r);
   }
-  async connect(t) {
-    if (t || (t = a.MAINNET), t === a.TESTNET)
-      return i("Phantom wallet does not support testnet");
+  async connect() {
     try {
-      const r = await s(this, o).requestAccounts();
-      for (const e of r)
-        e.purpose === "payment" && (this.address = e.address);
-      return this.address === "" ? i("Could not connect to Phantom bitcoin payment account") : u({
+      const t = await n(this, i).connect();
+      return !t || !t.address ? o("Failed to connect to OKX wallet") : (this.address = t.address, c({
         address: this.address,
         provider: this,
-        network: t,
-        id: c.Phantom.id
-      });
-    } catch (r) {
-      return i("Error while connecting to Phantom wallet: " + r);
+        network: n(this, s),
+        id: u.OKX.id
+      }));
+    } catch (t) {
+      return o("Error while connecting to the OKX wallet", t);
     }
   }
+  async getPublicKey() {
+    return await h(async () => await n(this, i).getPublicKey(), "Error while getting public key from OKX wallet");
+  }
   async requestAccounts() {
-    return await l(async () => {
-      const t = await s(this, o).requestAccounts();
-      return t.length > 0 && (this.address = t[0].address), t.map((r) => r.address);
-    }, "Error while requesting accounts from Phantom wallet");
+    const t = await this.connect();
+    return t.ok ? c([t.val.address]) : o(t.error);
   }
   async getAccounts() {
-    return this.requestAccounts();
+    return n(this, s) === l.TESTNET ? await this.requestAccounts() : await h(async () => await n(this, i).getAccounts(), "Error while getting accounts from OKX wallet");
   }
-  // bitcoin testnet is not supported in Phantom wallet
   async getNetwork() {
-    return u(a.MAINNET);
+    return c(n(this, s));
   }
   async switchNetwork() {
-    return i("Phantom wallet does not support testnet");
+    a(this, s, n(this, s) === l.MAINNET ? l.TESTNET : l.MAINNET);
+    const t = await this.connect();
+    return t.error ? o(
+      `Failed to connect to ${n(this, s)}: ${t.error}`
+    ) : c(n(this, s));
   }
   async getBalance() {
-    return await l(async () => {
-      const t = await v(this.address, a.MAINNET);
-      if (t.ok && t.val)
-        return t.val;
-      throw new Error(t.error);
-    }, "Error while getting balance from Phantom wallet");
+    return await h(async () => await n(this, i).getBalance(), "Error while getting balance from OKX wallet");
   }
   async sendBitcoin(t, r) {
-    return await l(async () => {
-      const e = m.networks.bitcoin, f = new I(a.MAINNET);
-      try {
-        const { txHex: d, utxoCount: A } = await B.generateUnsignedPSBT(
-          f,
-          e,
-          this.address,
-          t,
-          r
-        ), E = await s(this, o).signPSBT(
-          this.fromHexString(d),
-          {
-            inputsToSign: [
-              {
-                address: this.address,
-                signingIndexes: Array.from({ length: A }, (S, x) => x),
-                sigHash: m.Transaction.SIGHASH_ALL
-              }
-            ]
-          }
-        ), w = m.Psbt.fromBuffer(
-          Buffer.from(E)
-        );
-        w.finalizeAllInputs();
-        const h = w.extractTransaction();
-        console.log("tx", h);
-        const T = h.getId();
-        return await f.broadcast(h.toHex()), T;
-      } catch (d) {
-        throw new Error(`Failed to send bitcoin: ${d}`);
-      }
-    }, "Error while sending bitcoin from Phantom wallet");
-  }
-  fromHexString(t) {
-    return Uint8Array.from(
-      t.match(/.{1,2}/g).map((r) => parseInt(r, 16))
-    );
+    return await h(async () => await n(this, i).sendBitcoin(t, r), "Error while sending bitcoin from OKX wallet");
   }
   on(t, r) {
-    s(this, o).on(t, r);
+    n(this, i).on(t, r);
   }
   off(t, r) {
-    s(this, o).off(t, r);
+    n(this, i).off(t, r);
   }
 }
-o = new WeakMap();
+i = new WeakMap(), s = new WeakMap();
 export {
-  W as PhantomProvider
+  E as OKXProvider
 };

package/dist/src/index.d.ts

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

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,6 +1,6 @@
 {
   "name": "@gardenfi/wallet-connectors",
-  "version": "2.5.0",
+  "version": "3.0.0-beta.10",
   "type": "module",
   "scripts": {
     "build": "vite build",
@@ -37,12 +37,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@gardenfi/core": "3.1.0",
-    "@gardenfi/utils": "3.1.0",
+    "@gardenfi/core": "3.1.0-beta.1",
+    "@gardenfi/utils": "3.1.0-beta.1",
     "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"
   }
 }