@btc-vision/walletconnect 1.0.0

package/browser/index.js.LICENSE.txt

@@ -0,0 +1,13 @@
+/*! For license information please see index.js.LICENSE.txt */
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/build/WalletConnection.d.ts

@@ -0,0 +1,17 @@
+import { Network } from '@btc-vision/bitcoin';
+import { Address, Unisat, UnisatSigner } from '@btc-vision/transaction';
+import { JSONRpcProvider } from 'opnet';
+export declare enum SupportedWallets {
+    OP_WALLET = "op_wallet"
+}
+export type Signers = UnisatSigner;
+export type Wallets = Unisat;
+export declare class WalletConnection {
+    signer: Signers | null;
+    connect(walletType: SupportedWallets): Promise<void>;
+    disconnect(): void;
+    getAddress(): Promise<Address>;
+    getNetwork(): Promise<Network>;
+    getProvider(): Promise<JSONRpcProvider>;
+}
+export default WalletConnection;

package/build/WalletConnection.js

@@ -0,0 +1,90 @@
+import { networks } from '@btc-vision/bitcoin';
+import { Address, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { JSONRpcProvider } from 'opnet';
+export var SupportedWallets;
+(function (SupportedWallets) {
+    SupportedWallets["OP_WALLET"] = "op_wallet";
+})(SupportedWallets || (SupportedWallets = {}));
+export class WalletConnection {
+    constructor() {
+        this.signer = null;
+    }
+    async connect(walletType) {
+        switch (walletType) {
+            case SupportedWallets.OP_WALLET:
+                if (this.signer instanceof UnisatSigner)
+                    return;
+                if (window.opnet || window.unisat) {
+                    try {
+                        const signer = new UnisatSigner();
+                        await signer.init();
+                        this.signer = signer;
+                        return;
+                    }
+                    catch (error) {
+                        if (error instanceof Error)
+                            throw new Error(error.message);
+                        throw new Error(`Unknown error: ${error}`);
+                    }
+                }
+                else {
+                    throw new Error('OP Wallet not found');
+                }
+            default:
+                throw new Error('Unsupported wallet');
+        }
+    }
+    disconnect() {
+        if (!this.signer)
+            throw new Error('Wallet not connected');
+        if (this.signer instanceof UnisatSigner)
+            this.signer.unisat.disconnect();
+        this.signer = null;
+    }
+    async getAddress() {
+        if (!this.signer)
+            throw new Error('Wallet not connected');
+        if (this.signer instanceof UnisatSigner) {
+            const publicKey = await this.signer.unisat.getPublicKey();
+            return Address.fromString(publicKey);
+        }
+        throw new Error('Unsupported wallet');
+    }
+    async getNetwork() {
+        if (!this.signer)
+            throw new Error('Wallet not connected');
+        if (this.signer instanceof UnisatSigner) {
+            const chain = await this.signer.unisat.getChain();
+            switch (chain.enum) {
+                case UnisatChainType.BITCOIN_MAINNET:
+                    return networks.bitcoin;
+                case UnisatChainType.BITCOIN_TESTNET:
+                    return networks.testnet;
+                case UnisatChainType.BITCOIN_REGTEST:
+                    return networks.regtest;
+                default:
+                    throw new Error('Unsupported network');
+            }
+        }
+        throw new Error('Unsupported wallet');
+    }
+    async getProvider() {
+        if (!this.signer)
+            throw new Error('Wallet not connected');
+        if (this.signer instanceof UnisatSigner) {
+            const network = await this.getNetwork();
+            switch (network.bech32) {
+                case networks.bitcoin.bech32:
+                    return new JSONRpcProvider('https://api.opnet.org', networks.bitcoin);
+                case networks.testnet.bech32:
+                    return new JSONRpcProvider('https://testnet.opnet.org', networks.testnet);
+                case networks.regtest.bech32:
+                    return new JSONRpcProvider('https://regtest.opnet.org', networks.regtest);
+                default:
+                    throw new Error('Unsupported network');
+            }
+        }
+        throw new Error('Unsupported wallet');
+    }
+}
+export default WalletConnection;

package/build/WalletProvider.d.ts

@@ -0,0 +1,19 @@
+import { Network } from '@btc-vision/bitcoin';
+import { Address } from '@btc-vision/transaction';
+import { JSONRpcProvider } from 'opnet';
+import React from 'react';
+import { Signers, SupportedWallets } from './WalletConnection';
+interface WalletContextType {
+    connect: (walletType: SupportedWallets) => Promise<void>;
+    disconnect: () => void;
+    address: Address | null;
+    signer: Signers | null;
+    network: Network | null;
+    provider: JSONRpcProvider | null;
+    isConnected: boolean;
+}
+export declare const WalletProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useWallet: () => WalletContextType;
+export {};

package/build/WalletProvider.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { UnisatSigner } from '@btc-vision/transaction';
+import { createContext, useCallback, useContext, useEffect, useState } from 'react';
+import WalletConnection from './WalletConnection';
+const WalletContext = createContext(undefined);
+export const WalletProvider = ({ children }) => {
+    const [walletConnection] = useState(new WalletConnection());
+    const [address, setAddress] = useState(null);
+    const [signer, setSigner] = useState(null);
+    const [network, setNetwork] = useState(null);
+    const [provider, setProvider] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    useEffect(() => {
+        const storedWalletType = localStorage.getItem('walletType');
+        if (storedWalletType) {
+            connect(storedWalletType).catch((error) => {
+                console.error('Failed to reconnect wallet:', error);
+                disconnect();
+            });
+        }
+    }, []);
+    const connect = useCallback(async (walletType) => {
+        await walletConnection.connect(walletType);
+        setAddress(await walletConnection.getAddress());
+        setSigner(walletConnection.signer);
+        setNetwork(await walletConnection.getNetwork());
+        setProvider(await walletConnection.getProvider());
+        setIsConnected(true);
+        localStorage.setItem('walletType', walletType);
+        if (walletConnection.signer instanceof UnisatSigner) {
+            walletConnection.signer.unisat.on('disconnect', () => {
+                disconnect();
+            });
+            walletConnection.signer.unisat.on('accountsChanged', async () => {
+                setAddress(await walletConnection.getAddress());
+            });
+            walletConnection.signer.unisat.on('chainChanged', async () => {
+                setNetwork(await walletConnection.getNetwork());
+                setProvider(await walletConnection.getProvider());
+            });
+            walletConnection.signer.unisat.on('networkChanged', async () => {
+                setNetwork(await walletConnection.getNetwork());
+                setProvider(await walletConnection.getProvider());
+            });
+        }
+    }, [walletConnection]);
+    const disconnect = useCallback(() => {
+        walletConnection.disconnect();
+        setAddress(null);
+        setSigner(null);
+        setNetwork(null);
+        setProvider(null);
+        setIsConnected(false);
+        localStorage.removeItem('walletType');
+    }, [walletConnection]);
+    const value = {
+        connect,
+        disconnect,
+        address,
+        signer,
+        network,
+        provider,
+        isConnected,
+    };
+    return _jsx(WalletContext.Provider, { value: value, children: children });
+};
+export const useWallet = () => {
+    const context = useContext(WalletContext);
+    if (!context) {
+        throw new Error('useWallet must be used within a WalletProvider');
+    }
+    return context;
+};

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from './WalletConnection';
+export * from './WalletProvider';

package/build/index.js

@@ -0,0 +1,2 @@
+export * from './WalletConnection';
+export * from './WalletProvider';

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/eslint.config.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+    eslint.configs.recommended,
+    ...tseslint.configs.strictTypeChecked,
+    {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigDirName: import.meta.dirname,
+            },
+        },
+        rules: {
+            'no-undef': 'off',
+            '@typescript-eslint/no-unused-vars': 'off',
+            'no-empty': 'off',
+            '@typescript-eslint/restrict-template-expressions': 'off',
+            '@typescript-eslint/only-throw-error': 'off',
+            '@typescript-eslint/no-unnecessary-condition': 'off',
+            '@typescript-eslint/unbound-method': 'warn',
+            '@typescript-eslint/no-confusing-void-expression': 'off',
+            '@typescript-eslint/no-extraneous-class': 'off',
+            'no-async-promise-executor': 'off',
+            '@typescript-eslint/no-misused-promises': 'off',
+            '@typescript-eslint/no-unnecessary-type-parameters': 'off',
+            '@typescript-eslint/no-duplicate-enum-values': 'off',
+            'prefer-spread': 'off',
+            '@typescript-eslint/no-empty-object-type': 'off',
+        },
+    },
+    {
+        files: ['**/*.js'],
+        ...tseslint.configs.disableTypeChecked,
+    },
+);

package/gulpfile.js

@@ -0,0 +1,47 @@
+import gulp from 'gulp';
+import gulpcache from 'gulp-cached';
+import gulpESLintNew from 'gulp-eslint-new';
+
+import gulpClean from 'gulp-clean';
+import logger from 'gulp-logger-new';
+import ts from 'gulp-typescript';
+
+process.on('uncaughtException', function (err) {
+    console.log('Caught exception: ', err);
+});
+
+const tsProject = ts.createProject('tsconfig.json', {
+    jsx: 'react-jsx',
+});
+
+function buildESM() {
+    return tsProject
+        .src()
+        .pipe(gulpcache('ts-esm'))
+        .pipe(
+            logger({
+                before: 'Starting...',
+                after: 'Project compiled!',
+                extname: '.js',
+                showChange: true,
+            }),
+        )
+        .pipe(gulpESLintNew())
+        .pipe(gulpESLintNew.format())
+        .pipe(tsProject())
+        .pipe(gulp.dest('build'));
+}
+
+export async function clean() {
+    return gulp.src('./build/src', { read: false }).pipe(gulpClean());
+}
+
+export const build = buildESM;
+export default build;
+
+export function watch() {
+    gulp.watch(
+        ['src/**/*.ts', 'src/**/*.tsx', 'src/**/*.js', 'src/**/*.jsx'],
+        gulp.series(buildESM),
+    );
+}

package/package.json

@@ -0,0 +1,126 @@
+{
+    "name": "@btc-vision/walletconnect",
+    "type": "module",
+    "version": "1.0.0",
+    "author": "impredmet",
+    "description": "OPNet Wallet Connect library allows you to connect to any WalletConnect compatible wallet.",
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "exports": {
+        ".": {
+            "browser": "./browser/index.js",
+            "import": "./build/index.js",
+            "require": "./build/index.js",
+            "types": "./build/index.d.ts"
+        },
+        "./browser": {
+            "import": "./browser/index.js",
+            "require": "./browser/index.js",
+            "types": "./browser/index.d.ts"
+        }
+    },
+    "browser": {
+        "./build/index.d.ts": "./browser/index.d.ts",
+        "./build/index.js": "./browser/index.js",
+        "Buffer": "buffer",
+        "crypto": "./src/crypto/crypto-browser.js",
+        "stream": "stream-browserify",
+        "zlib": "browserify-zlib"
+    },
+    "homepage": "https://opnet.org",
+    "keywords": [
+        "opnet",
+        "bsi",
+        "bsi-binary",
+        "bsi-bitcoin-rpc",
+        "walletconnect",
+        "wallet",
+        "connect",
+        "bitcoin",
+        "btc",
+        "bitcoin smart contracts",
+        "smart inscriptions",
+        "ordinals"
+    ],
+    "license": "MIT",
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
+    "typings": "build/index.d.ts",
+    "module": "build/index.js",
+    "publishConfig": {
+        "access": "public",
+        "tag": "latest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/btc-vision/walletconnect.git"
+    },
+    "scripts": {
+        "watch": "gulp watch",
+        "build": "gulp build",
+        "setup": "npm i && npm run build",
+        "browserBuild": "webpack --mode production"
+    },
+    "peerDependencies": {
+        "react": "^18",
+        "react-dom": "^18"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.26.0",
+        "@babel/plugin-proposal-class-properties": "^7.18.6",
+        "@babel/plugin-transform-runtime": "^7.25.9",
+        "@babel/preset-env": "^7.26.0",
+        "@babel/preset-flow": "^7.25.9",
+        "@babel/preset-react": "^7.25.9",
+        "@babel/preset-typescript": "^7.26.0",
+        "@types/node": "^22.10.2",
+        "@types/react": "^18",
+        "@types/sha.js": "^2.4.4",
+        "eslint": "^9.14.0",
+        "gulp": "^5.0.0",
+        "gulp-cached": "^1.1.1",
+        "gulp-typescript": "^6.0.0-alpha.1",
+        "https-browserify": "^1.0.0",
+        "os-browserify": "^0.3.0",
+        "prettier": "^3.3.3",
+        "react": "^18",
+        "react-dom": "^18.0.0",
+        "stream-browserify": "^3.0.0",
+        "stream-http": "^3.2.0",
+        "typedoc": "^0.27.6",
+        "typescript-eslint": "^8.19.0",
+        "webpack-cli": "^6.0.1"
+    },
+    "dependencies": {
+        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+        "@bitcoinerlab/secp256k1": "^1.1.1",
+        "@btc-vision/bitcoin": "^6.3.6",
+        "@btc-vision/bitcoin-rpc": "^1.0.0",
+        "@btc-vision/logger": "^1.0.6",
+        "@btc-vision/transaction": "^1.2.10",
+        "@eslint/js": "^9.14.0",
+        "@noble/secp256k1": "^2.1.0",
+        "assert": "^2.1.0",
+        "babel-loader": "^9.2.1",
+        "babel-plugin-transform-import-meta": "^2.2.1",
+        "babel-preset-react": "^6.24.1",
+        "babelify": "^10.0.0",
+        "bech32": "^2.0.0",
+        "bip174": "^2.1.1",
+        "bip32": "^5.0.0-rc.0",
+        "browserify-zlib": "^0.2.0",
+        "buffer": "^6.0.3",
+        "ecpair": "^2.1.0",
+        "gulp-clean": "^0.4.0",
+        "gulp-eslint-new": "^2.4.0",
+        "gulp-logger-new": "^1.0.1",
+        "opnet": "^1.2.23",
+        "process": "^0.11.10",
+        "sha.js": "^2.4.11",
+        "ts-loader": "^9.5.1",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.7.2",
+        "webpack": "^5.97.1"
+    }
+}

package/src/WalletConnection.ts

@@ -0,0 +1,126 @@
+import { Network, networks } from '@btc-vision/bitcoin';
+import { Address, Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { JSONRpcProvider } from 'opnet';
+
+export enum SupportedWallets {
+    OP_WALLET = 'op_wallet',
+}
+export type Signers = UnisatSigner;
+export type Wallets = Unisat;
+
+export class WalletConnection {
+    public signer: Signers | null = null;
+
+    /**
+     * @description Connect to the wallet
+     * @param {SupportedWallets} walletType
+     * @returns {Promise<void>}
+     */
+    public async connect(walletType: SupportedWallets): Promise<void> {
+        // TODO: When more wallets are supported, make them disconnect before connecting to the new one
+        switch (walletType) {
+            case SupportedWallets.OP_WALLET:
+                if (this.signer instanceof UnisatSigner) return;
+
+                if (window.opnet || window.unisat) {
+                    try {
+                        const signer = new UnisatSigner();
+                        await signer.init();
+
+                        this.signer = signer;
+                        return;
+                    } catch (error: unknown) {
+                        if (error instanceof Error) throw new Error(error.message);
+
+                        throw new Error(`Unknown error: ${error}`);
+                    }
+                } else {
+                    throw new Error('OP Wallet not found');
+                }
+            default:
+                throw new Error('Unsupported wallet');
+        }
+    }
+
+    /**
+     * @description Disconnect from the wallet
+     * @returns {void}
+     */
+    public disconnect(): void {
+        if (!this.signer) throw new Error('Wallet not connected');
+
+        if (this.signer instanceof UnisatSigner) this.signer.unisat.disconnect();
+
+        this.signer = null;
+    }
+
+    /**
+     * @description Get the address of the connected wallet
+     * @returns {Promise<Address>}
+     */
+    public async getAddress(): Promise<Address> {
+        if (!this.signer) throw new Error('Wallet not connected');
+
+        if (this.signer instanceof UnisatSigner) {
+            const publicKey = await this.signer.unisat.getPublicKey();
+
+            return Address.fromString(publicKey);
+        }
+
+        throw new Error('Unsupported wallet');
+    }
+
+    /**
+     * @description Get the network of the connected wallet
+     * @returns {Promise<Network>}
+     */
+    public async getNetwork(): Promise<Network> {
+        if (!this.signer) throw new Error('Wallet not connected');
+
+        if (this.signer instanceof UnisatSigner) {
+            const chain = await this.signer.unisat.getChain();
+
+            // TODO: Add Fractal network
+            switch (chain.enum) {
+                case UnisatChainType.BITCOIN_MAINNET:
+                    return networks.bitcoin;
+                case UnisatChainType.BITCOIN_TESTNET:
+                    return networks.testnet;
+                case UnisatChainType.BITCOIN_REGTEST:
+                    return networks.regtest;
+                default:
+                    throw new Error('Unsupported network');
+            }
+        }
+
+        throw new Error('Unsupported wallet');
+    }
+
+    /**
+     * @description Get the provider of the connected wallet
+     * @returns {Promise<JSONRpcProvider>}
+     */
+    public async getProvider(): Promise<JSONRpcProvider> {
+        if (!this.signer) throw new Error('Wallet not connected');
+
+        if (this.signer instanceof UnisatSigner) {
+            const network = await this.getNetwork();
+
+            // TODO: Add Fractal network
+            switch (network.bech32) {
+                case networks.bitcoin.bech32:
+                    return new JSONRpcProvider('https://api.opnet.org', networks.bitcoin);
+                case networks.testnet.bech32:
+                    return new JSONRpcProvider('https://testnet.opnet.org', networks.testnet);
+                case networks.regtest.bech32:
+                    return new JSONRpcProvider('https://regtest.opnet.org', networks.regtest);
+                default:
+                    throw new Error('Unsupported network');
+            }
+        }
+
+        throw new Error('Unsupported wallet');
+    }
+}
+
+export default WalletConnection;

package/src/WalletProvider.tsx

@@ -0,0 +1,101 @@
+import { Network } from '@btc-vision/bitcoin';
+import { Address, UnisatSigner } from '@btc-vision/transaction';
+import { JSONRpcProvider } from 'opnet';
+import React, { createContext, useCallback, useContext, useEffect, useState } from 'react';
+import WalletConnection, { Signers, SupportedWallets } from './WalletConnection';
+
+interface WalletContextType {
+    connect: (walletType: SupportedWallets) => Promise<void>;
+    disconnect: () => void;
+    address: Address | null;
+    signer: Signers | null;
+    network: Network | null;
+    provider: JSONRpcProvider | null;
+    isConnected: boolean;
+}
+
+const WalletContext = createContext<WalletContextType | undefined>(undefined);
+
+export const WalletProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+    const [walletConnection] = useState(new WalletConnection());
+    const [address, setAddress] = useState<Address | null>(null);
+    const [signer, setSigner] = useState<Signers | null>(null);
+    const [network, setNetwork] = useState<Network | null>(null);
+    const [provider, setProvider] = useState<JSONRpcProvider | null>(null);
+    const [isConnected, setIsConnected] = useState(false);
+
+    useEffect(() => {
+        const storedWalletType = localStorage.getItem('walletType') as SupportedWallets | null;
+
+        if (storedWalletType) {
+            connect(storedWalletType).catch((error: unknown) => {
+                console.error('Failed to reconnect wallet:', error);
+                disconnect();
+            });
+        }
+    }, []);
+
+    const connect = useCallback(
+        async (walletType: SupportedWallets) => {
+            await walletConnection.connect(walletType);
+
+            setAddress(await walletConnection.getAddress());
+            setSigner(walletConnection.signer);
+            setNetwork(await walletConnection.getNetwork());
+            setProvider(await walletConnection.getProvider());
+            setIsConnected(true);
+            localStorage.setItem('walletType', walletType);
+
+            if (walletConnection.signer instanceof UnisatSigner) {
+                walletConnection.signer.unisat.on('disconnect', () => {
+                    disconnect();
+                });
+
+                walletConnection.signer.unisat.on('accountsChanged', async () => {
+                    setAddress(await walletConnection.getAddress());
+                });
+
+                walletConnection.signer.unisat.on('chainChanged', async () => {
+                    setNetwork(await walletConnection.getNetwork());
+                    setProvider(await walletConnection.getProvider());
+                });
+
+                walletConnection.signer.unisat.on('networkChanged', async () => {
+                    setNetwork(await walletConnection.getNetwork());
+                    setProvider(await walletConnection.getProvider());
+                });
+            }
+        },
+        [walletConnection],
+    );
+
+    const disconnect = useCallback(() => {
+        walletConnection.disconnect();
+        setAddress(null);
+        setSigner(null);
+        setNetwork(null);
+        setProvider(null);
+        setIsConnected(false);
+        localStorage.removeItem('walletType');
+    }, [walletConnection]);
+
+    const value = {
+        connect,
+        disconnect,
+        address,
+        signer,
+        network,
+        provider,
+        isConnected,
+    };
+
+    return <WalletContext.Provider value={value}>{children}</WalletContext.Provider>;
+};
+
+export const useWallet = (): WalletContextType => {
+    const context = useContext(WalletContext);
+    if (!context) {
+        throw new Error('useWallet must be used within a WalletProvider');
+    }
+    return context;
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './WalletConnection';
+export * from './WalletProvider';