@btc-vision/walletconnect 1.4.1 → 1.5.1

package/browser/index.js.LICENSE.txt

@@ -1,5 +1,3 @@
-/*! For license information please see index.js.LICENSE.txt */
-
 /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
 
 /**

package/browser/provider/WalletConnectProvider.d.ts

@@ -0,0 +1,9 @@
+import React, { type ReactNode } from 'react';
+import '../utils/style.css';
+import '../utils/theme.css';
+interface WalletConnectProviderProps {
+    theme?: 'light' | 'dark' | 'moto';
+    children: ReactNode;
+}
+declare const WalletConnectProvider: React.FC<WalletConnectProviderProps>;
+export default WalletConnectProvider;

package/browser/types.d.ts

@@ -0,0 +1,11 @@
+import { Network } from '@btc-vision/bitcoin';
+import { UnisatChainType } from '@btc-vision/transaction';
+export interface WalletConnectNetwork extends Network {
+    chainType: UnisatChainType;
+}
+export interface WalletInformation {
+    name: string;
+    icon: string;
+    isInstalled: boolean;
+    isConnected: boolean;
+}

package/browser/utils/accessibility/definitions.d.ts

@@ -0,0 +1,2 @@
+export declare const genericErrors: Record<string, string>;
+export declare const errorDefinitions: Record<string, string>;

package/browser/utils/accessibility/errorDecoder.d.ts

@@ -0,0 +1,2 @@
+export declare const _e: (err: string | Error, locales?: string[]) => string;
+export declare const _match_e: (err: string, locales?: string[]) => string[];

package/browser/utils/accessibility/patterns.d.ts

@@ -0,0 +1,13 @@
+import { errorDefinitions } from './definitions';
+export type ErrorTranslations = {
+    en: ErrorMessage;
+    'en-US'?: ErrorMessage;
+    fr?: ErrorMessage;
+    'fr-CA'?: ErrorMessage;
+};
+type ErrorMessage = (typeof errorDefinitions)[keyof typeof errorDefinitions];
+type ErrorMessages = ErrorMessage | ErrorTranslations;
+export declare const patternMap: Array<[string, string, ErrorMessages]>;
+export declare const escapeKey: (key: string) => string;
+export declare const patternRegExp: Array<[string, RegExp, ErrorMessages]>;
+export {};

package/browser/wallets/controller.d.ts

@@ -0,0 +1,29 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { WalletConnectNetwork } from '../types';
+import { SupportedWallets } from './index';
+import type { ControllerConnectAccounts, ControllerErrorResponse, ControllerResponse, WalletConnectWallet } from './types.ts';
+declare class WalletController {
+    private static wallets;
+    private static currentWallet;
+    static getWallets: () => WalletConnectWallet[];
+    static isWalletInstalled(wallet: string): boolean;
+    static getWalletType(): SupportedWallets | null;
+    static getProvider(): Unisat | null;
+    static getSigner(): Promise<UnisatSigner | null>;
+    static convertChainTypeToNetwork(chainType: UnisatChainType): WalletConnectNetwork;
+    static getNetwork(): Promise<WalletConnectNetwork>;
+    static getPublicKey(): Promise<string | null>;
+    static canAutoConnect(walletName: string): Promise<boolean>;
+    static connect(walletName: string): Promise<ControllerResponse<ControllerConnectAccounts | ControllerErrorResponse>>;
+    static disconnectIfWalletChanged(newWallet: WalletConnectWallet): Promise<void>;
+    static disconnect(): Promise<void>;
+    static setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    static setDisconnectHook(fn: () => void): void;
+    static setChainChangedHook(fn: (network: WalletConnectNetwork) => void): void;
+    static removeAccountsChangedHook(): void;
+    static removeDisconnectHook(): void;
+    static removeChainChangedHook(): void;
+    static registerWallet: (wallet: WalletConnectWallet) => void;
+    static unbindHooks(): void;
+}
+export { WalletController };

package/browser/wallets/index.d.ts

@@ -0,0 +1,4 @@
+import { WalletController } from './controller';
+type SupportedWallets = 'OP_WALLET' | 'UNISAT';
+export { WalletController };
+export type { SupportedWallets };

package/browser/wallets/opwallet/controller.d.ts

@@ -0,0 +1,26 @@
+import { Unisat, UnisatChainType } from '@btc-vision/transaction';
+import type { WalletBase } from '../types.ts';
+declare class OPWallet implements WalletBase {
+    private walletBase;
+    private accountsChangedHookWrapper?;
+    private chainChangedHookWrapper?;
+    private disconnectHookWrapper?;
+    private _isConnected;
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getChainId(): void;
+    connect(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<null>;
+    getPublicKey(): Promise<string>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (chainType: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+}
+export default OPWallet;

package/browser/wallets/opwallet/interface.d.ts

@@ -0,0 +1,5 @@
+import type { Unisat } from '@btc-vision/transaction';
+export interface OPWalletInterface extends Unisat {
+    disconnect: () => Promise<void>;
+}
+export declare const logo: string;

package/browser/wallets/types.d.ts

@@ -0,0 +1,34 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import { SupportedWallets } from './index';
+export type { AbstractRpcProvider } from 'opnet';
+export interface WalletBase {
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<UnisatSigner | null>;
+    connect(): Promise<string[] | undefined>;
+    disconnect(): Promise<void>;
+    getPublicKey(): Promise<string | null>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (network: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+    getChainId(): void;
+}
+export interface WalletConnectWallet {
+    name: SupportedWallets;
+    icon: string;
+    controller: WalletBase;
+}
+export interface ControllerResponse<T> {
+    code: number;
+    data?: T;
+}
+export interface ControllerErrorResponse {
+    message: string;
+}
+export type ControllerConnectAccounts = string[];

package/browser/wallets/unisat/controller.d.ts

@@ -0,0 +1,26 @@
+import { Unisat, UnisatChainType, UnisatSigner } from '@btc-vision/transaction';
+import type { WalletBase } from '../types.ts';
+declare class UnisatWallet implements WalletBase {
+    private walletBase;
+    private accountsChangedHookWrapper?;
+    private chainChangedHookWrapper?;
+    private disconnectHookWrapper?;
+    private _isConnected;
+    isInstalled(): boolean;
+    isConnected(): boolean;
+    canAutoConnect(): Promise<boolean>;
+    getProvider(): Unisat | null;
+    getSigner(): Promise<UnisatSigner>;
+    getChainId(): void;
+    connect(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getPublicKey(): Promise<string>;
+    getNetwork(): Promise<UnisatChainType>;
+    setAccountsChangedHook(fn: (accounts: string[]) => void): void;
+    removeAccountsChangedHook(): void;
+    setDisconnectHook(fn: () => void): void;
+    removeDisconnectHook(): void;
+    setChainChangedHook(fn: (chainType: UnisatChainType) => void): void;
+    removeChainChangedHook(): void;
+}
+export default UnisatWallet;

package/browser/wallets/unisat/interface.d.ts

@@ -0,0 +1,5 @@
+import type { Unisat } from '@btc-vision/transaction';
+export interface UnisatWalletInterface extends Unisat {
+    disconnect: () => Promise<void>;
+}
+export declare const logo: string;

package/build/consts.d.ts

@@ -0,0 +1,2 @@
+import { WalletConnectNetwork } from './types';
+export declare const DefaultWalletConnectNetwork: WalletConnectNetwork;

package/build/consts.js

@@ -0,0 +1,6 @@
+import { networks } from '@btc-vision/bitcoin';
+import { UnisatChainType } from '@btc-vision/transaction';
+export const DefaultWalletConnectNetwork = {
+    ...networks.regtest,
+    chainType: UnisatChainType.BITCOIN_REGTEST,
+};

package/build/context/WalletConnectContext.d.ts

@@ -0,0 +1,18 @@
+import { Address, Unisat, UnisatSigner } from '@btc-vision/transaction';
+import type { WalletConnectNetwork, WalletInformation } from '../types.ts';
+import { SupportedWallets } from '../wallets';
+export type WalletConnectContextType = {
+    allWallets: WalletInformation[];
+    walletType: string | null;
+    walletAddress: string | null;
+    network: WalletConnectNetwork;
+    publicKey: string | null;
+    address: Address | null;
+    openConnectModal: () => void;
+    connectToWallet: (wallet: SupportedWallets) => void;
+    connecting: boolean;
+    disconnect: () => void;
+    provider: Unisat | null;
+    signer: UnisatSigner | null;
+};
+export declare const WalletConnectContext: import("react").Context<WalletConnectContextType | undefined>;

package/build/context/WalletConnectContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const WalletConnectContext = createContext(undefined);

package/build/hooks/WalletConnectHook.d.ts

@@ -0,0 +1,2 @@
+import { type WalletConnectContextType } from '../context/WalletConnectContext';
+export declare const useWalletConnect: () => WalletConnectContextType;

package/build/hooks/WalletConnectHook.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { WalletConnectContext, } from '../context/WalletConnectContext';
+export const useWalletConnect = () => {
+    const context = useContext(WalletConnectContext);
+    if (!context) {
+        throw new Error('useCore must be used within a UserProvider');
+    }
+    return context;
+};

package/build/index.d.ts

@@ -1,2 +1,4 @@
-export * from './WalletConnection';
-export * from './WalletProvider';
+export { WalletConnectContext } from './context/WalletConnectContext';
+export { useWalletConnect } from './hooks/WalletConnectHook';
+export * from './types';
+export { default as WalletConnectProvider } from './provider/WalletConnectProvider';

package/build/index.js

@@ -1,2 +1,4 @@
-export * from './WalletConnection';
-export * from './WalletProvider';
+export { WalletConnectContext } from './context/WalletConnectContext';
+export { useWalletConnect } from './hooks/WalletConnectHook';
+export * from './types';
+export { default as WalletConnectProvider } from './provider/WalletConnectProvider';

package/build/provider/WalletConnectProvider.d.ts

@@ -0,0 +1,9 @@
+import React, { type ReactNode } from 'react';
+import '../utils/style.css';
+import '../utils/theme.css';
+interface WalletConnectProviderProps {
+    theme?: 'light' | 'dark' | 'moto';
+    children: ReactNode;
+}
+declare const WalletConnectProvider: React.FC<WalletConnectProviderProps>;
+export default WalletConnectProvider;

package/build/provider/WalletConnectProvider.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Address } from '@btc-vision/transaction';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { DefaultWalletConnectNetwork } from '../consts';
+import { WalletConnectContext } from '../context/WalletConnectContext';
+import '../utils/style.css';
+import '../utils/theme.css';
+import { WalletController } from '../wallets';
+const AUTO_RECONNECT_RETRIES = 5;
+const WalletConnectProvider = ({ theme, children }) => {
+    const [connectError, setConnectError] = useState(undefined);
+    const timeoutRef = useRef(null);
+    const [network, setNetwork] = useState(DefaultWalletConnectNetwork);
+    const [supportedWallets] = useState(WalletController.getWallets);
+    const [selectedWallet, setSelectedWallet] = useState(() => localStorage.getItem('WC_SelectedWallet') || null);
+    const [connecting, setConnecting] = useState(false);
+    const [modalOpen, setModalOpen] = useState(false);
+    const [walletAddress, setWalletAddress] = useState(null);
+    const [publicKey, setPublicKey] = useState(null);
+    const [walletType, setWalletType] = useState(null);
+    const [provider, setProvider] = useState(null);
+    const [signer, setSigner] = useState(null);
+    const clearConnectError = useCallback(() => {
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(() => setConnectError(undefined), 5000);
+    }, []);
+    useEffect(() => {
+        if (connectError) {
+            clearConnectError();
+        }
+    }, [connectError, clearConnectError]);
+    const openConnectModal = () => {
+        setConnectError(undefined);
+        setModalOpen(true);
+    };
+    const closeConnectModal = () => {
+        setModalOpen(false);
+        setConnectError(undefined);
+    };
+    const disconnect = useCallback(async () => {
+        console.log('DISCONNECTING FROM WALLET');
+        localStorage.removeItem('WC_SelectedWallet');
+        setSelectedWallet(null);
+        setPublicKey(null);
+        setWalletAddress(null);
+        setConnecting(false);
+        WalletController.removeDisconnectHook();
+        WalletController.removeChainChangedHook();
+        WalletController.removeAccountsChangedHook();
+        await WalletController.disconnect();
+        setNetwork(DefaultWalletConnectNetwork);
+    }, []);
+    const connectToWallet = useCallback(async (wallet) => {
+        setConnecting(true);
+        try {
+            const response = await WalletController.connect(wallet);
+            if (response.code === 200 && Array.isArray(response.data)) {
+                if (!response.data || response.data.length === 0) {
+                    return;
+                }
+                setWalletAddress(response.data[0]);
+                const publicKey = await WalletController.getPublicKey();
+                setPublicKey(publicKey);
+                const network = await WalletController.getNetwork();
+                setNetwork(network);
+                WalletController.setAccountsChangedHook(accountsChanged);
+                WalletController.setChainChangedHook(chainChanged);
+                WalletController.setDisconnectHook(disconnect);
+                closeConnectModal();
+                setSelectedWallet(wallet);
+                localStorage.setItem('WC_SelectedWallet', wallet);
+            }
+            else if (response.data && 'message' in response.data) {
+                setConnectError(response.data.message);
+            }
+            else {
+                setConnectError('Unknown error');
+            }
+        }
+        catch (err) {
+            setConnectError(err.message || 'Unexpected error');
+        }
+        finally {
+            setConnecting(false);
+        }
+    }, [disconnect]);
+    const attemptReconnect = useCallback(async () => {
+        console.warn('Trying to reconnect...', selectedWallet, connecting);
+        if (!selectedWallet || connecting)
+            return;
+        const canAutoConnect = await WalletController.canAutoConnect(selectedWallet);
+        console.log('CanAutoConnect', canAutoConnect);
+        if (!canAutoConnect)
+            return;
+        let attempts = 0;
+        const reconnect = async () => {
+            attempts++;
+            const walletAvailable = WalletController.isWalletInstalled(selectedWallet);
+            if (walletAvailable) {
+                console.log(`Attempting to reconnect to ${selectedWallet} (Attempt ${attempts})`);
+                await connectToWallet(selectedWallet);
+                return;
+            }
+            if (attempts < AUTO_RECONNECT_RETRIES) {
+                setTimeout(reconnect, 1000 * attempts);
+            }
+        };
+        await reconnect();
+    }, [selectedWallet, connectToWallet]);
+    useEffect(() => {
+        void attemptReconnect();
+    }, [attemptReconnect]);
+    const accountsChanged = useCallback(async (accounts) => {
+        console.log('Accounts', accounts);
+        if (selectedWallet) {
+            const account = accounts.length > 0 ? accounts[0] : null;
+            setWalletAddress(account);
+            const publicKey = account ? await WalletController.getPublicKey() : null;
+            setPublicKey(publicKey);
+        }
+    }, [selectedWallet, setWalletAddress, setPublicKey]);
+    const chainChanged = useCallback((network) => {
+        if (selectedWallet) {
+            setNetwork(network);
+        }
+    }, [selectedWallet, setNetwork]);
+    const allWallets = useMemo(() => {
+        return supportedWallets.map((wallet) => {
+            return {
+                name: wallet.name,
+                icon: wallet.icon,
+                isInstalled: wallet.controller.isInstalled(),
+                isConnected: wallet.controller.isConnected(),
+            };
+        });
+    }, [supportedWallets, network]);
+    const availableWallets = useMemo(() => {
+        return supportedWallets.filter((wallet) => wallet.controller.isInstalled());
+    }, [supportedWallets, network]);
+    useEffect(() => {
+        const walletType = walletAddress ? WalletController.getWalletType() : null;
+        setWalletType(walletType);
+        const provider = walletAddress ? WalletController.getProvider() : null;
+        setProvider(provider);
+    }, [walletAddress]);
+    useEffect(() => {
+        const updateSigner = async () => {
+            const signer = publicKey ? await WalletController.getSigner() : null;
+            setSigner(signer);
+        };
+        void updateSigner();
+    }, [network, publicKey]);
+    const currentTheme = useMemo(() => {
+        const currentTheme = theme || 'light';
+        return `wallet-connect-${currentTheme}-theme`;
+    }, [theme]);
+    const address = useMemo(() => {
+        return publicKey ? Address.fromString(publicKey) : null;
+    }, [publicKey]);
+    return (_jsxs(WalletConnectContext.Provider, { value: {
+            walletAddress,
+            publicKey,
+            address,
+            connecting,
+            connectToWallet,
+            disconnect,
+            openConnectModal,
+            network,
+            allWallets,
+            provider,
+            signer,
+            walletType,
+        }, children: [children, modalOpen && (_jsx("div", { className: `wallet-connect-modal-backdrop ${currentTheme}`, children: _jsxs("div", { className: "wallet-connect-modal", role: "dialog", "aria-modal": "true", "aria-labelledby": "wallet-connect-modal-title", children: [_jsxs("div", { className: "wallet-connect-header", children: [_jsx("span", { children: "Connect Wallet" }), _jsx("button", { className: "close", onClick: () => closeConnectModal(), children: _jsx("span", { className: "close-icon", children: _jsx("svg", { width: "30px", height: "30px", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { className: "close-x-path", d: "M16 8L8 16M8.00001 8L16 16", stroke: "#fff", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }) }) })] }), connectError && (_jsx("div", { className: "wallet-connect-error", children: _jsx("p", { className: "error-message", children: connectError }) })), availableWallets.length > 0 ? (_jsx("div", { className: "wallet-list", children: availableWallets.map((wallet) => (_jsxs("button", { onClick: () => connectToWallet(wallet.name), disabled: connecting || !wallet.controller.isInstalled(), className: `wallet-button ${wallet.controller.isInstalled()
+                                    ? 'wallet-installed'
+                                    : 'wallet-not-installed'}`, children: [wallet.icon ? (_jsx("div", { className: "wallet-icon", title: wallet.name, children: _jsx("img", { src: wallet.icon, alt: wallet.name }) })) : (_jsx("div", { className: "wallet-name", children: wallet.name })), wallet.controller.isConnected() ? (_jsx("div", { className: "wallet-connected", children: "(Connected)" })) : (_jsx(_Fragment, {})), wallet.controller.isInstalled() ? (_jsx(_Fragment, {})) : (_jsx("div", { className: "wallet-not-installed", children: "(Not Installed)" }))] }, wallet.name))) })) : (_jsxs("div", { children: [_jsx("p", { children: "No wallets available" }), _jsx("p", { children: "Supporting the following wallets" }), _jsx("div", { className: "wallet-list", children: supportedWallets.map((wallet) => (_jsx("a", { href: `https://chromewebstore.google.com/search/${wallet.name}`, children: wallet.icon ? (_jsx("div", { className: "wallet-icon", title: wallet.name, children: _jsx("img", { src: wallet.icon, alt: wallet.name }) })) : (_jsx("div", { className: "wallet-name", children: wallet.name })) }))) })] }))] }) }))] }));
+};
+export default WalletConnectProvider;

package/build/types.d.ts

@@ -0,0 +1,11 @@
+import { Network } from '@btc-vision/bitcoin';
+import { UnisatChainType } from '@btc-vision/transaction';
+export interface WalletConnectNetwork extends Network {
+    chainType: UnisatChainType;
+}
+export interface WalletInformation {
+    name: string;
+    icon: string;
+    isInstalled: boolean;
+    isConnected: boolean;
+}

package/build/types.js

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

package/build/utils/accessibility/definitions.d.ts

@@ -0,0 +1,2 @@
+export declare const genericErrors: Record<string, string>;
+export declare const errorDefinitions: Record<string, string>;

package/build/utils/accessibility/definitions.js

@@ -0,0 +1,8 @@
+export const genericErrors = {
+    UserRejected: 'Wallet Dialog was closed by the user',
+    UnknownError: 'Unknown error occurred',
+    IndexingInProgress: 'Node is still indexing. Please try again shortly',
+};
+export const errorDefinitions = {
+    ...genericErrors,
+};

package/build/utils/accessibility/errorDecoder.d.ts

@@ -0,0 +1,2 @@
+export declare const _e: (err: string | Error, locales?: string[]) => string;
+export declare const _match_e: (err: string, locales?: string[]) => string[];

package/build/utils/accessibility/errorDecoder.js

@@ -0,0 +1,73 @@
+import { patternMap, patternRegExp } from './patterns';
+const RE_EXTRACT_ERROR = new RegExp('^(.*?):\\s*(?:([^:]+):)?\\s*(.*?)\\s+at\\s(\\S+\\s\\()?\\S+\\d+:\\d+\\)?', 'm');
+const _translation = (err, locale) => {
+    switch (locale) {
+        case 'en':
+            return err['en'] || '';
+        case 'en-us':
+            return err['en-US'] || '';
+        case 'fr':
+            return err['fr'] || '';
+        case 'fr-ca':
+            return err['fr-CA'] || '';
+        default:
+            return '';
+    }
+};
+const _errors = (err, locales) => {
+    if (typeof err === 'string') {
+        return err;
+    }
+    else {
+        for (const locale of locales) {
+            const translation = _translation(err, locale);
+            if (translation)
+                return translation;
+        }
+        return err['en'];
+    }
+};
+const _normalizeLocales = (locales) => {
+    const _locales = locales.map((l) => l.toLowerCase().trim());
+    for (const locale of _locales) {
+        const language = locale.split('-')[0];
+        if (!_locales.includes(language)) {
+            _locales.push(language);
+        }
+    }
+    return _locales;
+};
+export const _e = (err, locales = ['en']) => {
+    const [, , error] = _match_e(err.toString(), locales);
+    return error;
+};
+export const _match_e = (err, locales = ['en']) => {
+    const normalizedLocales = _normalizeLocales(locales);
+    const matches = RE_EXTRACT_ERROR.exec(err);
+    const packageName = matches ? matches[2] : '';
+    let msg = matches ? matches[3] : err;
+    const lookup = `${packageName}: ${msg}`.trim();
+    const lookupLower = lookup.toLowerCase();
+    for (const [orig, pattern, translation] of patternRegExp) {
+        const placeHolders = pattern.exec(lookup);
+        if (placeHolders) {
+            msg = _errors(translation, normalizedLocales) || msg;
+            for (let i = 0; i < placeHolders.length; i++) {
+                const regex = new RegExp(`\\$${i}`, 'g');
+                msg = msg.replace(regex, placeHolders[i] ?? '');
+            }
+            return [orig, pattern.source, msg];
+        }
+    }
+    for (const [orig, pattern, translation] of patternMap) {
+        if (lookupLower == pattern) {
+            return [orig, pattern, _errors(translation, normalizedLocales) || msg];
+        }
+    }
+    for (const [orig, pattern, translation] of patternMap) {
+        if (lookupLower.includes(pattern)) {
+            return [orig, pattern, _errors(translation, normalizedLocales) || msg];
+        }
+    }
+    return ['', '', msg];
+};

package/build/utils/accessibility/patterns.d.ts

@@ -0,0 +1,13 @@
+import { errorDefinitions } from './definitions';
+export type ErrorTranslations = {
+    en: ErrorMessage;
+    'en-US'?: ErrorMessage;
+    fr?: ErrorMessage;
+    'fr-CA'?: ErrorMessage;
+};
+type ErrorMessage = (typeof errorDefinitions)[keyof typeof errorDefinitions];
+type ErrorMessages = ErrorMessage | ErrorTranslations;
+export declare const patternMap: Array<[string, string, ErrorMessages]>;
+export declare const escapeKey: (key: string) => string;
+export declare const patternRegExp: Array<[string, RegExp, ErrorMessages]>;
+export {};

package/build/utils/accessibility/patterns.js

@@ -0,0 +1,51 @@
+import { errorDefinitions } from './definitions';
+const rawPatternGeneric = {
+    'User rejected the request.': errorDefinitions.UserRejected,
+    "TypeError: Cannot read properties of undefined (reading 'addresses')": errorDefinitions.UserRejected,
+};
+const rawPatternUnitTest = {
+    'TEST_CASE: empty': '',
+    'TEST_CASE: simple': 'simple',
+    'TEST_CASE: regex1 ${value}': 'regex1',
+    'TEST_CASE: regex2 ${value}': 'regex2 $1',
+    'Test case empty': '',
+    'Test case simple': 'simple',
+    'Test case regex1 ${value}': 'regex1',
+    'Test case regex2 ${value.get()}': 'regex2 $1',
+    'TEST_MULTI: multi1': {
+        en: 'Test English',
+        'en-US': 'Test American English',
+        fr: 'Test French',
+        'fr-CA': 'Test Canadian French',
+    },
+    'TEST_MULTI: multi2 ${value}': {
+        en: 'Test English: $1',
+        'en-US': 'Test American English: $1',
+        fr: 'Test French: $1',
+        'fr-CA': 'Test Canadian French: $1',
+    },
+};
+const rawPatternMap = {
+    'NATIVE_SWAP: Liquidity value is too low in satoshis.': errorDefinitions.NativeSwapLiquidityValueTooLow,
+    'Unknown Error': errorDefinitions.UnknownError,
+    'Invalid Address': errorDefinitions.IndexingInProgress,
+    'Error Indexing at Block': errorDefinitions.IndexingInProgress,
+    'Valid Reservation for this Address': errorDefinitions.NoValidReservation,
+    ...rawPatternGeneric,
+    ...rawPatternUnitTest,
+};
+export const patternMap = Object.entries(rawPatternMap)
+    .filter(([key, value]) => !!value && !key.includes('${'))
+    .sort((a, b) => b[0].length - a[0].length)
+    .map(([key, value]) => [key, key.toLowerCase(), value]);
+export const escapeKey = (key) => {
+    return key
+        .replace(/\(/g, '\\(')
+        .replace(/\)/g, '\\)')
+        .replace(/\./g, '\\.')
+        .replace(/\$\{.*?}/g, '(.+)');
+};
+export const patternRegExp = Object.entries(rawPatternMap)
+    .filter(([key, value]) => !!value && key.includes('${'))
+    .sort((a, b) => b[0].length - a[0].length)
+    .map(([key, value]) => [key, new RegExp(escapeKey(key), 'i'), value]);