@ksangkuk10/wallet-controller 1.7.14

package/modules/walletconnect/connect.js

@@ -0,0 +1,390 @@
+import { WalletApp } from '@ksangkuk10/wallet-types';
+import Connector from '@walletconnect/core';
+import * as cryptoLib from '@walletconnect/iso-crypto';
+import { uuid } from '@walletconnect/utils';
+import { BehaviorSubject } from 'rxjs';
+import { isMobile } from '../../utils/browser-check';
+import { WalletConnectCreateTxFailed, WalletConnectTimeout, WalletConnectTxFailed, WalletConnectTxUnspecifiedError, WalletConnectUserDenied, WalletConnectSignUnspecifiedError, WalletConnectSignBytesUnspecifiedError } from './errors';
+import SocketTransport from './impl/socket-transport';
+import { XplaWalletconnectQrcodeModal } from './modal';
+import { WalletConnectSessionStatus, } from './types';
+const WALLETCONNECT_STORAGE_KEY = 'walletconnect';
+export function connectIfSessionExists(options = {}) {
+    const storedSession = localStorage.getItem(WALLETCONNECT_STORAGE_KEY);
+    if (typeof storedSession === 'string') {
+        return connect(options, true);
+    }
+    return null;
+}
+export function connect(options = {}, useCachedSession = false, walletApp) {
+    var _a, _b;
+    let connector = null;
+    let sessionSubject = new BehaviorSubject({
+        status: WalletConnectSessionStatus.DISCONNECTED,
+    });
+    const qrcodeModal = (_b = (_a = options.connectorOpts) === null || _a === void 0 ? void 0 : _a.qrcodeModal) !== null && _b !== void 0 ? _b : new XplaWalletconnectQrcodeModal(walletApp);
+    const connectorOpts = {
+        bridge: 'https://walletconnect.xpla.io/',
+        qrcodeModal,
+        ...options.connectorOpts,
+    };
+    const pushServerOpts = options.pushServerOpts;
+    // ---------------------------------------------
+    // event listeners
+    // ---------------------------------------------
+    function initEvents() {
+        if (!connector) {
+            throw new Error(`WalletConnect is not defined!`);
+        }
+        connector.on('session_update', async (error, payload) => {
+            if (error)
+                throw error;
+            sessionSubject.next({
+                status: WalletConnectSessionStatus.CONNECTED,
+                peerMeta: payload.params[0].peerMeta,
+                xplaAddress: payload.params[0].accounts[0],
+                chainId: payload.params[0].chainId,
+            });
+            console.log('WALLETCONNECT SESSION UPDATED:', payload.params[0]);
+        });
+        connector.on('connect', (error, payload) => {
+            if (error)
+                throw error;
+            sessionSubject.next({
+                status: WalletConnectSessionStatus.CONNECTED,
+                peerMeta: payload.params[0].peerMeta,
+                xplaAddress: payload.params[0].accounts[0],
+                chainId: payload.params[0].chainId,
+            });
+        });
+        connector.on('disconnect', (error, payload) => {
+            if (error)
+                throw error;
+            sessionSubject.next({
+                status: WalletConnectSessionStatus.DISCONNECTED,
+            });
+        });
+    }
+    // ---------------------------------------------
+    // initialize
+    // ---------------------------------------------
+    const cachedSession = localStorage.getItem('walletconnect');
+    if (typeof cachedSession === 'string' && useCachedSession) {
+        const cachedSessionObject = JSON.parse(cachedSession);
+        const clientId = cachedSessionObject.clientId;
+        const draftConnector = new Connector({
+            connectorOpts: {
+                ...connectorOpts,
+                session: JSON.parse(cachedSession),
+            },
+            pushServerOpts,
+            cryptoLib,
+            transport: new SocketTransport({
+                protocol: 'wc',
+                version: 1,
+                url: connectorOpts.bridge,
+                subscriptions: [clientId],
+            }),
+        });
+        draftConnector.clientId = clientId;
+        connector = draftConnector;
+        initEvents();
+        sessionSubject.next({
+            status: WalletConnectSessionStatus.CONNECTED,
+            peerMeta: draftConnector.peerMeta,
+            xplaAddress: draftConnector.accounts[0],
+            chainId: draftConnector.chainId,
+        });
+    }
+    else {
+        const clientId = uuid();
+        const draftConnector = new Connector({
+            connectorOpts,
+            pushServerOpts,
+            cryptoLib,
+            transport: new SocketTransport({
+                protocol: 'wc',
+                version: 1,
+                url: connectorOpts.bridge,
+                subscriptions: [clientId],
+            }),
+        });
+        draftConnector.clientId = clientId;
+        connector = draftConnector;
+        if (!draftConnector.connected) {
+            draftConnector.createSession().catch(console.error);
+            if (qrcodeModal instanceof XplaWalletconnectQrcodeModal) {
+                qrcodeModal.setCloseCallback(() => {
+                    sessionSubject.next({
+                        status: WalletConnectSessionStatus.DISCONNECTED,
+                    });
+                });
+            }
+            initEvents();
+            sessionSubject.next({
+                status: WalletConnectSessionStatus.REQUESTED,
+            });
+        }
+    }
+    // ---------------------------------------------
+    // methods
+    // ---------------------------------------------
+    function disconnect() {
+        if (connector && connector.connected) {
+            try {
+                connector.killSession();
+            }
+            catch (_a) { }
+        }
+        sessionSubject.next({
+            status: WalletConnectSessionStatus.DISCONNECTED,
+        });
+    }
+    function session() {
+        return sessionSubject.asObservable();
+    }
+    function getLatestSession() {
+        return sessionSubject.getValue();
+    }
+    /**
+     * post transaction
+     *
+     * @param tx transaction data
+     * @param walletApp wallet type, default is XPLA Vault
+     * @throws { WalletConnectUserDenied }
+     * @throws { WalletConnectCreateTxFailed }
+     * @throws { WalletConnectTxFailed }
+     * @throws { WalletConnectTimeout }
+     * @throws { WalletConnectTxUnspecifiedError }
+     */
+    function post(tx, _walletApp) {
+        var _a, _b, _c;
+        if (!connector || !connector.connected) {
+            throw new Error(`WalletConnect is not connected!`);
+        }
+        const id = Date.now();
+        const serializedTxOptions = {
+            msgs: tx.msgs.map((msg) => msg.toJSON()),
+            fee: (_a = tx.fee) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            memo: tx.memo,
+            gas: tx.gas,
+            gasPrices: (_b = tx.gasPrices) === null || _b === void 0 ? void 0 : _b.toString(),
+            gasAdjustment: (_c = tx.gasAdjustment) === null || _c === void 0 ? void 0 : _c.toString(),
+            //account_number: tx.account_number,
+            //sequence: tx.sequence,
+            feeDenoms: tx.feeDenoms,
+            timeoutHeight: tx.timeoutHeight,
+        };
+        if (isMobile()) {
+            const payload = btoa(JSON.stringify({
+                id,
+                handshakeTopic: connector.handshakeTopic,
+                method: 'post',
+                params: serializedTxOptions,
+            }));
+            confirm(payload, walletApp);
+        }
+        return connector
+            .sendCustomRequest({
+            id,
+            method: 'post',
+            params: [serializedTxOptions],
+        })
+            .catch((error) => {
+            let throwError = error;
+            try {
+                const { code, txhash, message, raw_message } = JSON.parse(error.message);
+                switch (code) {
+                    case 1:
+                        throwError = new WalletConnectUserDenied();
+                        break;
+                    case 2:
+                        throwError = new WalletConnectCreateTxFailed(message);
+                        break;
+                    case 3:
+                        throwError = new WalletConnectTxFailed(txhash, message, raw_message);
+                        break;
+                    case 4:
+                        throwError = new WalletConnectTimeout(message);
+                        break;
+                    case 99:
+                        throwError = new WalletConnectTxUnspecifiedError(message);
+                        break;
+                }
+            }
+            catch (_a) {
+                throwError = new WalletConnectTxUnspecifiedError(error.message);
+            }
+            throw throwError;
+        });
+    }
+    /**
+     * sign transaction
+     *
+     * @param bytes: Buffer
+     * @param walletApp wallet type, default is XPLA Vault
+     * @throws { WalletConnectUserDenied }
+     * @throws { WalletConnectTimeout }
+     * @throws { WalletConnectSignBytesUnspecifiedError }
+     */
+    function sign(tx, _walletApp) {
+        var _a, _b, _c;
+        if (!connector || !connector.connected) {
+            throw new Error(`WalletConnect is not connected!`);
+        }
+        const id = Date.now();
+        const serializedTxOptions = {
+            msgs: tx.msgs.map((msg) => msg.toJSON()),
+            fee: (_a = tx.fee) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            memo: tx.memo,
+            gas: tx.gas,
+            gasPrices: (_b = tx.gasPrices) === null || _b === void 0 ? void 0 : _b.toString(),
+            gasAdjustment: (_c = tx.gasAdjustment) === null || _c === void 0 ? void 0 : _c.toString(),
+            //account_number: tx.account_number,
+            //sequence: tx.sequence,
+            feeDenoms: tx.feeDenoms,
+            timeoutHeight: tx.timeoutHeight,
+            sequence: tx.sequence,
+            accountNumber: tx.accountNumber,
+            signMode: tx.signMode
+        };
+        if (isMobile()) {
+            const payload = btoa(JSON.stringify({
+                id,
+                handshakeTopic: connector.handshakeTopic,
+                method: 'sign',
+                params: serializedTxOptions,
+            }));
+            confirm(payload, _walletApp);
+        }
+        return connector
+            .sendCustomRequest({
+            id,
+            method: 'sign',
+            params: [serializedTxOptions],
+        })
+            .catch((error) => {
+            let throwError = error;
+            try {
+                const { code, txhash, message, raw_message } = JSON.parse(error.message);
+                switch (code) {
+                    case 1:
+                        throwError = new WalletConnectUserDenied();
+                        break;
+                    case 2:
+                        throwError = new WalletConnectCreateTxFailed(message);
+                        break;
+                    case 3:
+                        throwError = new WalletConnectTxFailed(txhash, message, raw_message);
+                        break;
+                    case 4:
+                        throwError = new WalletConnectTimeout(message);
+                        break;
+                    case 99:
+                        throwError = new WalletConnectSignUnspecifiedError(message);
+                        break;
+                }
+            }
+            catch (_a) {
+                throwError = new WalletConnectSignUnspecifiedError(error.message);
+            }
+            throw throwError;
+        });
+    }
+    /**
+     * signBytes transaction
+     *
+     * @param bytes: Buffer
+     * @param bytes: WalletApp | boolean
+     * @throws { WalletConnectUserDenied }
+     * @throws { WalletConnectTimeout }
+     * @throws { WalletConnectSignBytesUnspecifiedError }
+     */
+    function signBytes(bytes, _walletApp) {
+        if (!connector || !connector.connected) {
+            throw new Error(`WalletConnect is not connected!`);
+        }
+        const id = Date.now();
+        if (isMobile()) {
+            const payload = btoa(JSON.stringify({
+                id,
+                handshakeTopic: connector.handshakeTopic,
+                method: 'signBytes',
+                params: bytes,
+            }));
+            confirm(payload, _walletApp);
+        }
+        return connector
+            .sendCustomRequest({
+            id,
+            method: 'signBytes',
+            params: [bytes],
+        })
+            .catch((error) => {
+            let throwError = error;
+            try {
+                const { code, message } = JSON.parse(error.message);
+                switch (code) {
+                    case 1:
+                        throwError = new WalletConnectUserDenied();
+                        break;
+                    case 4:
+                        throwError = new WalletConnectTimeout(message);
+                        break;
+                    case 99:
+                        throwError = new WalletConnectSignBytesUnspecifiedError(message);
+                        break;
+                }
+            }
+            catch (_a) {
+                throwError = new WalletConnectSignBytesUnspecifiedError(error.message);
+            }
+            throw throwError;
+        });
+    }
+    /**
+     * mobile confirm
+     *
+     * @param payload paylaod
+     * @param _walletApp wallet type, default is XPLA Vault
+     */
+    function confirm(payload, _walletApp) {
+        if (!_walletApp || typeof _walletApp === 'boolean') {
+            if (_walletApp) {
+                window.location.href = `c2xvault://walletconnect_confirm/?payload=${payload}`;
+            }
+            else {
+                window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;
+            }
+        }
+        else {
+            if (_walletApp === WalletApp.XPLA_VAULT) {
+                window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;
+            }
+            else if (_walletApp === WalletApp.XPLA_GAMES) {
+                window.location.href = `c2xvault://walletconnect_confirm/?payload=${payload}`;
+            }
+            else if (_walletApp === WalletApp.XPLA_GAMES_NEW) {
+                window.location.href = `xgameswallet://walletconnect_confirm/?payload=${payload}`;
+            }
+            else if (_walletApp === WalletApp.XPLAYZ) {
+                window.location.href = `xplayz://walletconnect_confirm/?payload=${payload}`;
+            }
+            else {
+                window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;
+            }
+        }
+    }
+    // ---------------------------------------------
+    // return
+    // ---------------------------------------------
+    return {
+        session,
+        getLatestSession,
+        post,
+        sign,
+        signBytes,
+        disconnect,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../../../../src/@ksangkuk10/wallet-controller/modules/walletconnect/connect.ts"],"names":[],"mappings":"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","sourcesContent":["import { CreateTxOptions, SignMode } from '@xpla/xpla.js';\nimport { WalletApp } from '@ksangkuk10/wallet-types';\nimport Connector from '@walletconnect/core';\nimport * as cryptoLib from '@walletconnect/iso-crypto';\nimport {\n  IPushServerOptions,\n  IWalletConnectOptions,\n} from '@walletconnect/types';\nimport { uuid } from '@walletconnect/utils';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { isMobile } from '../../utils/browser-check';\nimport {\n  WalletConnectCreateTxFailed,\n  WalletConnectTimeout,\n  WalletConnectTxFailed,\n  WalletConnectTxUnspecifiedError,\n  WalletConnectUserDenied,\n  WalletConnectSignUnspecifiedError,\n  WalletConnectSignBytesUnspecifiedError\n} from './errors';\nimport SocketTransport from './impl/socket-transport';\nimport { XplaWalletconnectQrcodeModal } from './modal';\nimport {\n  WalletConnectSession,\n  WalletConnectSessionStatus,\n  WalletConnectTxResult,\n} from './types';\nimport {\n  WebExtensionSignPayload,\n  WebExtensionSignBytesPayload,\n} from '@ksangkuk10/web-extension-interface';\n\nexport interface WalletConnectControllerOptions {\n  /**\n   * Configuration parameter that `new WalletConnect(connectorOpts)`\n   *\n   * @default\n   * ```js\n   * {\n   *   bridge: 'https://walletconnect.xpla.io/',\n   *   qrcodeModal: new XplaWalletconnectQrcodeModal(),\n   * }\n   * ```\n   */\n  connectorOpts?: IWalletConnectOptions;\n\n  /**\n   * Configuration parameter that `new WalletConnect(_, pushServerOpts)`\n   *\n   * @default undefined\n   */\n  pushServerOpts?: IPushServerOptions;\n}\n\nexport interface WalletConnectController {\n  session: () => Observable<WalletConnectSession>;\n  getLatestSession: () => WalletConnectSession;\n  post: (tx: CreateTxOptions, _walletApp?: WalletApp | boolean) => Promise<WalletConnectTxResult>;\n  sign: (\n    tx: CreateTxOptions & {\n      sequence?: number;\n      accountNumber?: number;\n      signMode?: SignMode;\n    }, \n    _walletApp?: WalletApp | boolean\n  ) => Promise<WebExtensionSignPayload>;\n  signBytes: (bytes: Buffer, _walletApp?: WalletApp | boolean) => Promise<WebExtensionSignBytesPayload>;\n  disconnect: () => void;\n}\n\nconst WALLETCONNECT_STORAGE_KEY = 'walletconnect';\n\nexport function connectIfSessionExists(\n  options: WalletConnectControllerOptions = {},\n): WalletConnectController | null {\n  const storedSession = localStorage.getItem(WALLETCONNECT_STORAGE_KEY);\n\n  if (typeof storedSession === 'string') {\n    return connect(options, true);\n  }\n\n  return null;\n}\n\nexport function connect(\n  options: WalletConnectControllerOptions = {},\n  useCachedSession: boolean = false,\n  walletApp?: WalletApp | boolean\n): WalletConnectController {\n  let connector: Connector | null = null;\n\n  let sessionSubject: BehaviorSubject<WalletConnectSession> =\n    new BehaviorSubject<WalletConnectSession>({\n      status: WalletConnectSessionStatus.DISCONNECTED,\n    });\n\n  const qrcodeModal =\n    options.connectorOpts?.qrcodeModal ?? new XplaWalletconnectQrcodeModal(walletApp);\n\n  const connectorOpts: IWalletConnectOptions = {\n    bridge: 'https://walletconnect.xpla.io/',\n    qrcodeModal,\n    ...options.connectorOpts,\n  };\n\n  const pushServerOpts: IPushServerOptions | undefined = options.pushServerOpts;\n\n  // ---------------------------------------------\n  // event listeners\n  // ---------------------------------------------\n  function initEvents() {\n    if (!connector) {\n      throw new Error(`WalletConnect is not defined!`);\n    }\n\n    connector.on('session_update', async (error, payload) => {\n      if (error) throw error;\n\n      sessionSubject.next({\n        status: WalletConnectSessionStatus.CONNECTED,\n        peerMeta: payload.params[0].peerMeta,\n        xplaAddress: payload.params[0].accounts[0],\n        chainId: payload.params[0].chainId,\n      });\n\n      console.log('WALLETCONNECT SESSION UPDATED:', payload.params[0]);\n    });\n\n    connector.on('connect', (error, payload) => {\n      if (error) throw error;\n\n      sessionSubject.next({\n        status: WalletConnectSessionStatus.CONNECTED,\n        peerMeta: payload.params[0].peerMeta,\n        xplaAddress: payload.params[0].accounts[0],\n        chainId: payload.params[0].chainId,\n      });\n    });\n\n    connector.on('disconnect', (error, payload) => {\n      if (error) throw error;\n\n      sessionSubject.next({\n        status: WalletConnectSessionStatus.DISCONNECTED,\n      });\n    });\n  }\n\n  // ---------------------------------------------\n  // initialize\n  // ---------------------------------------------\n  const cachedSession = localStorage.getItem('walletconnect');\n\n  if (typeof cachedSession === 'string' && useCachedSession) {\n    const cachedSessionObject = JSON.parse(cachedSession);\n    const clientId = cachedSessionObject.clientId;\n    const draftConnector = new Connector({\n      connectorOpts: {\n        ...connectorOpts,\n        session: JSON.parse(cachedSession),\n      },\n      pushServerOpts,\n      cryptoLib,\n      transport: new SocketTransport({\n        protocol: 'wc',\n        version: 1,\n        url: connectorOpts.bridge!,\n        subscriptions: [clientId],\n      }),\n    });\n    draftConnector.clientId = clientId;\n\n    connector = draftConnector;\n\n    initEvents();\n\n    sessionSubject.next({\n      status: WalletConnectSessionStatus.CONNECTED,\n      peerMeta: draftConnector.peerMeta!,\n      xplaAddress: draftConnector.accounts[0],\n      chainId: draftConnector.chainId,\n    });\n  } else {\n    const clientId = uuid();\n    const draftConnector = new Connector({\n      connectorOpts,\n      pushServerOpts,\n      cryptoLib,\n      transport: new SocketTransport({\n        protocol: 'wc',\n        version: 1,\n        url: connectorOpts.bridge!,\n        subscriptions: [clientId],\n      }),\n    });\n    draftConnector.clientId = clientId;\n\n    connector = draftConnector;\n\n    if (!draftConnector.connected) {\n      draftConnector.createSession().catch(console.error);\n\n      if (qrcodeModal instanceof XplaWalletconnectQrcodeModal) {\n        qrcodeModal.setCloseCallback(() => {\n          sessionSubject.next({\n            status: WalletConnectSessionStatus.DISCONNECTED,\n          });\n        });\n      }\n\n      initEvents();\n\n      sessionSubject.next({\n        status: WalletConnectSessionStatus.REQUESTED,\n      });\n    }\n  }\n\n  // ---------------------------------------------\n  // methods\n  // ---------------------------------------------\n  function disconnect() {\n    if (connector && connector.connected) {\n      try {\n        connector.killSession();\n      } catch {}\n    }\n\n    sessionSubject.next({\n      status: WalletConnectSessionStatus.DISCONNECTED,\n    });\n  }\n\n  function session(): Observable<WalletConnectSession> {\n    return sessionSubject.asObservable();\n  }\n\n  function getLatestSession(): WalletConnectSession {\n    return sessionSubject.getValue();\n  }\n\n  /**\n   * post transaction\n   *\n   * @param tx transaction data\n   * @param walletApp wallet type, default is XPLA Vault\n   * @throws { WalletConnectUserDenied }\n   * @throws { WalletConnectCreateTxFailed }\n   * @throws { WalletConnectTxFailed }\n   * @throws { WalletConnectTimeout }\n   * @throws { WalletConnectTxUnspecifiedError }\n   */\n  function post(tx: CreateTxOptions, _walletApp?: WalletApp | boolean): Promise<WalletConnectTxResult> {\n    if (!connector || !connector.connected) {\n      throw new Error(`WalletConnect is not connected!`);\n    }\n\n    const id = Date.now();\n\n    const serializedTxOptions = {\n      msgs: tx.msgs.map((msg) => msg.toJSON()),\n      fee: tx.fee?.toJSON(),\n      memo: tx.memo,\n      gas: tx.gas,\n      gasPrices: tx.gasPrices?.toString(),\n      gasAdjustment: tx.gasAdjustment?.toString(),\n      //account_number: tx.account_number,\n      //sequence: tx.sequence,\n      feeDenoms: tx.feeDenoms,\n      timeoutHeight: tx.timeoutHeight,\n    };\n\n    if (isMobile()) {\n      const payload = btoa(\n        JSON.stringify({\n          id,\n          handshakeTopic: connector.handshakeTopic,\n          method: 'post',\n          params: serializedTxOptions,\n        }),\n      );\n\n      confirm(payload, walletApp);\n    }\n\n    return connector\n      .sendCustomRequest({\n        id,\n        method: 'post',\n        params: [serializedTxOptions],\n      })\n      .catch((error) => {\n        let throwError = error;\n\n        try {\n          const { code, txhash, message, raw_message } = JSON.parse(\n            error.message,\n          );\n          switch (code) {\n            case 1:\n              throwError = new WalletConnectUserDenied();\n              break;\n            case 2:\n              throwError = new WalletConnectCreateTxFailed(message);\n              break;\n            case 3:\n              throwError = new WalletConnectTxFailed(\n                txhash,\n                message,\n                raw_message,\n              );\n              break;\n            case 4:\n              throwError = new WalletConnectTimeout(message);\n              break;\n            case 99:\n              throwError = new WalletConnectTxUnspecifiedError(message);\n              break;\n          }\n        } catch {\n          throwError = new WalletConnectTxUnspecifiedError(error.message);\n        }\n\n        throw throwError;\n      });\n  }\n\n  /**\n   * sign transaction\n   *\n   * @param bytes: Buffer\n   * @param walletApp wallet type, default is XPLA Vault\n   * @throws { WalletConnectUserDenied }\n   * @throws { WalletConnectTimeout }\n   * @throws { WalletConnectSignBytesUnspecifiedError }\n   */\n  function sign(\n    tx: CreateTxOptions  & {\n      sequence?: number;\n      accountNumber?: number;\n      signMode?: SignMode;\n    }, \n    _walletApp?: WalletApp | boolean\n  ): Promise<WebExtensionSignPayload> {\n    if (!connector || !connector.connected) {\n      throw new Error(`WalletConnect is not connected!`);\n    }\n\n    const id = Date.now();\n\n    const serializedTxOptions = {\n      msgs: tx.msgs.map((msg) => msg.toJSON()),\n      fee: tx.fee?.toJSON(),\n      memo: tx.memo,\n      gas: tx.gas,\n      gasPrices: tx.gasPrices?.toString(),\n      gasAdjustment: tx.gasAdjustment?.toString(),\n      //account_number: tx.account_number,\n      //sequence: tx.sequence,\n      feeDenoms: tx.feeDenoms,\n      timeoutHeight: tx.timeoutHeight,\n      sequence: tx.sequence,\n      accountNumber: tx.accountNumber,\n      signMode: tx.signMode\n    };\n\n    if (isMobile()) {\n      const payload = btoa(\n        JSON.stringify({\n          id,\n          handshakeTopic: connector.handshakeTopic,\n          method: 'sign',\n          params: serializedTxOptions,\n        }),\n      );\n      confirm(payload, _walletApp);\n    }\n\n    return connector\n      .sendCustomRequest({\n        id,\n        method: 'sign',\n        params: [serializedTxOptions],\n      })\n      .catch((error) => {\n        let throwError = error;\n\n        try {\n          const { code, txhash, message, raw_message } = JSON.parse(\n            error.message,\n          );\n          switch (code) {\n            case 1:\n              throwError = new WalletConnectUserDenied();\n              break;\n            case 2:\n              throwError = new WalletConnectCreateTxFailed(message);\n              break;\n            case 3:\n              throwError = new WalletConnectTxFailed(\n                txhash,\n                message,\n                raw_message,\n              );\n              break;\n            case 4:\n              throwError = new WalletConnectTimeout(message);\n              break;\n            case 99:\n              throwError = new WalletConnectSignUnspecifiedError(message);\n              break;\n          }\n        } catch {\n          throwError = new WalletConnectSignUnspecifiedError(error.message);\n        }\n\n        throw throwError;\n      });\n  }\n\n  /**\n   * signBytes transaction\n   *\n   * @param bytes: Buffer\n   * @param bytes: WalletApp | boolean\n   * @throws { WalletConnectUserDenied }\n   * @throws { WalletConnectTimeout }\n   * @throws { WalletConnectSignBytesUnspecifiedError }\n   */\n  function signBytes(bytes: Buffer, _walletApp?: WalletApp | boolean): Promise<WebExtensionSignBytesPayload> {\n    if (!connector || !connector.connected) {\n      throw new Error(`WalletConnect is not connected!`);\n    }\n\n    const id = Date.now();\n\n    if (isMobile()) {\n      const payload = btoa(\n        JSON.stringify({\n          id,\n          handshakeTopic: connector.handshakeTopic,\n          method: 'signBytes',\n          params: bytes,\n        }),\n      );\n\n      confirm(payload, _walletApp);\n    }\n\n    return connector\n      .sendCustomRequest({\n        id,\n        method: 'signBytes',\n        params: [bytes],\n      })\n      .catch((error) => {\n        let throwError = error;\n\n        try {\n          const { code, message } = JSON.parse(\n            error.message,\n          );\n\n          switch (code) {\n            case 1:\n              throwError = new WalletConnectUserDenied();\n              break;\n            case 4:\n              throwError = new WalletConnectTimeout(message);\n              break;\n            case 99:\n              throwError = new WalletConnectSignBytesUnspecifiedError(message);\n              break;\n          }\n        } catch {\n          throwError = new WalletConnectSignBytesUnspecifiedError(error.message);\n        }\n\n        throw throwError;\n      });\n  }\n\n  /**\n   * mobile confirm\n   * \n   * @param payload paylaod\n   * @param _walletApp wallet type, default is XPLA Vault\n   */\n  function confirm(payload: string, _walletApp?: WalletApp | boolean) {\n    if (!_walletApp || typeof _walletApp === 'boolean') {\n      if (_walletApp) {\n        window.location.href = `c2xvault://walletconnect_confirm/?payload=${payload}`;  \n      } else {\n        window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;\n      }\n    } else {\n      if (_walletApp === WalletApp.XPLA_VAULT) {\n        window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;\n      } else if (_walletApp === WalletApp.XPLA_GAMES) {\n        window.location.href = `c2xvault://walletconnect_confirm/?payload=${payload}`;  \n      } else if (_walletApp === WalletApp.XPLA_GAMES_NEW) {\n        window.location.href = `xgameswallet://walletconnect_confirm/?payload=${payload}`;\n      } else if (_walletApp === WalletApp.XPLAYZ) {\n        window.location.href = `xplayz://walletconnect_confirm/?payload=${payload}`;  \n      } else {\n        window.location.href = `xplavault://walletconnect_confirm/?payload=${payload}`;\n      }\n    }\n  }\n\n  // ---------------------------------------------\n  // return\n  // ---------------------------------------------\n  return {\n    session,\n    getLatestSession,\n    post,\n    sign,\n    signBytes,\n    disconnect,\n  };\n}\n"]}

package/modules/walletconnect/errors.d.ts

@@ -0,0 +1,22 @@
+export declare class WalletConnectUserDenied extends Error {
+}
+export declare class WalletConnectCreateTxFailed extends Error {
+    constructor(message: string);
+}
+export declare class WalletConnectTxFailed extends Error {
+    readonly txhash: string;
+    readonly raw_message: any;
+    constructor(txhash: string, message: string, raw_message: any);
+}
+export declare class WalletConnectTimeout extends Error {
+    constructor(message: string);
+}
+export declare class WalletConnectTxUnspecifiedError extends Error {
+    constructor(message: string);
+}
+export declare class WalletConnectSignUnspecifiedError extends Error {
+    constructor(message: string);
+}
+export declare class WalletConnectSignBytesUnspecifiedError extends Error {
+    constructor(message: string);
+}

package/modules/walletconnect/errors.js

@@ -0,0 +1,41 @@
+export class WalletConnectUserDenied extends Error {
+}
+export class WalletConnectCreateTxFailed extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WalletConnectCreateTxFailed';
+    }
+}
+export class WalletConnectTxFailed extends Error {
+    constructor(txhash, message, raw_message) {
+        super(message);
+        this.txhash = txhash;
+        this.raw_message = raw_message;
+        this.name = 'WalletConnectTxFailed';
+    }
+}
+export class WalletConnectTimeout extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WalletConnectTimeout';
+    }
+}
+export class WalletConnectTxUnspecifiedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WalletConnectTxUnspecifiedError';
+    }
+}
+export class WalletConnectSignUnspecifiedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WalletConnectSignUnspecifiedError';
+    }
+}
+export class WalletConnectSignBytesUnspecifiedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WalletConnectSignBytesUnspecifiedError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/modules/walletconnect/impl/socket-transport/index.d.ts

@@ -0,0 +1,39 @@
+import { ITransportLib, ISocketTransportOptions } from '@walletconnect/types';
+declare class SocketTransport implements ITransportLib {
+    private opts;
+    private _protocol;
+    private _version;
+    private _url;
+    private _netMonitor;
+    private _socket;
+    private _nextSocket;
+    private _queue;
+    private _events;
+    private _subscriptions;
+    constructor(opts: ISocketTransportOptions);
+    set readyState(value: number);
+    get readyState(): number;
+    set connecting(value: boolean);
+    get connecting(): boolean;
+    set connected(value: boolean);
+    get connected(): boolean;
+    set closing(value: boolean);
+    get closing(): boolean;
+    set closed(value: boolean);
+    get closed(): boolean;
+    open: () => void;
+    close: () => void;
+    send: (message: string, topic?: string, silent?: boolean) => void;
+    subscribe: (topic: string) => void;
+    on: (event: string, callback: (payload: any) => void) => void;
+    private _socketCreate;
+    private _socketOpen;
+    private _socketClose;
+    private _socketSend;
+    private _socketReceive;
+    private _socketError;
+    private _queueSubscriptions;
+    private _setToQueue;
+    private _pushQueue;
+}
+export default SocketTransport;