@1tokenfe/onetoken-tron-provider 2.2.46

package/LICENSE.md

@@ -0,0 +1,51 @@
+# ONETOKEN STANDARD SOURCE LICENSE (O-SSL)
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+## 1. Definitions
+
+The terms "reproduce," "reproduction" and "distribution" have the same meaning
+here as under Hong Kong copyright law.
+
+"You" means the licensee of the software.
+
+"Your company" means the company you worked for when you downloaded the
+software.
+
+"Reference use" means use of the software within your company as a reference,
+in read only form, for the sole purposes of debugging your products,
+maintaining your products, or enhancing the interoperability of your products
+with the software, and specifically excludes the right to distribute the
+software outside of your company.
+
+"Licensed patents" means any Licensor patent claims which read directly on the
+software as distributed by the Licensor under this license.
+
+## 2. Grant of Rights
+
+(A) Copyright Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free copyright
+license to reproduce the software for reference use.
+
+(B) Patent Grant - Subject to the terms of this license, the Licensor grants
+you a non-transferable, non-exclusive, worldwide, royalty-free patent license
+under licensed patents for reference use.
+
+## 3. Limitations
+
+(A) No Trademark License - This license does not grant you any rights to use
+the Licensor's name, logo, or trademarks.
+
+(B) If you begin patent litigation against the Licensor over patents that you
+think may apply to the software (including a cross-claim or counterclaim in
+a lawsuit), your license to the software ends automatically.
+
+(C) The software is licensed "as-is." You bear the risk of using it. The
+Licensor gives no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the Licensor excludes
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.This license agreement is governed by the laws of Hong Kong, 
+and any disputes related to this license agreement shall be resolved in accordance with Hong Kong law.

package/README.md

@@ -0,0 +1 @@
+# cross-inpage-provider

package/dist/ProviderTron.d.ts

@@ -0,0 +1,50 @@
+import { TronWeb } from 'tronweb';
+import type { UnsignedTransaction, SignedTransaction } from 'tronweb';
+import SunWeb from 'sunweb';
+import { IInpageProviderConfig } from '@1tokenfe/cross-inpage-provider-core';
+import { ProviderTronBase } from './ProviderTronBase';
+import { IProviderTron, ProviderEvents, ProviderEventsMap, ConsoleLike, Nodes, Callback, RequestArguments } from './types';
+type OneTokenTronProviderProps = IInpageProviderConfig & {
+    timeout?: number;
+};
+export declare const CONTRACT_ADDRESS: {
+    MAIN: string;
+    SIDE: string;
+};
+export declare const SIDE_CHAIN_ID = "41E209E4DE650F0150788E8EC5CAFA240A23EB8EB7";
+export declare const AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST: string[];
+export declare const TRON_REQUEST_ACCOUNTS_LOCAL_KEY = "onetoken_tron_request_accounts_local_key";
+export declare const TRON_REQUEST_ACCOUNTS_INTERVAL: number;
+declare class ProviderTron extends ProviderTronBase implements IProviderTron {
+    readonly isTronLink = true;
+    tronWeb: TronWeb | null;
+    sunWeb: SunWeb | null;
+    ready: boolean;
+    private _initialized;
+    private _connected;
+    private _requestingAccounts;
+    private _defaultAddress;
+    private _accounts;
+    private _nodes;
+    private readonly _log;
+    constructor(props: OneTokenTronProviderProps);
+    private _registerTronWeb;
+    private _initialize;
+    private _registerEvents;
+    isAccountsChanged(accounts: string[]): boolean;
+    private _handleAccountsChanged;
+    private __handleDisconnected;
+    private _handleConnected;
+    private _postMessage;
+    private _dispatch;
+    isNetworkChanged(nodes: Nodes): boolean;
+    private _handleNodesChanged;
+    private _requestAccounts;
+    request<T>(args: RequestArguments): Promise<T>;
+    sign(transaction: UnsignedTransaction): Promise<SignedTransaction>;
+    signMessage(transaction: UnsignedTransaction): Promise<string>;
+    signMessageV2(message: string | Uint8Array | Array<number>): Promise<string>;
+    getNodeInfo(callback: Callback): Promise<unknown>;
+}
+export { ProviderTron };
+export { IProviderTron, ProviderEvents, ProviderEventsMap, ConsoleLike, Nodes, RequestArguments, TronWeb, };

package/dist/ProviderTron.js

@@ -0,0 +1,389 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import dequal from 'fast-deep-equal';
+import { TronWeb } from 'tronweb';
+import SunWeb from 'sunweb';
+import { isEmpty } from 'lodash-es';
+import { checkWalletSwitchEnable, defineWindowProperty, } from '@1tokenfe/cross-inpage-provider-core';
+import { getOrCreateExtInjectedJsBridge } from '@1tokenfe/extension-bridge-injected';
+import { web3Errors } from '@1tokenfe/cross-inpage-provider-errors';
+import { ProviderTronBase } from './ProviderTronBase';
+import { ProviderEvents, } from './types';
+import { isWalletEventMethodMatch } from './utils';
+import BigNumber from 'bignumber.js';
+export const CONTRACT_ADDRESS = {
+    MAIN: 'TL9q7aDAHYbW5KdPCwk8oJR3bCDhRwegFf',
+    SIDE: 'TGKotco6YoULzbYisTBuP6DWXDjEgJSpYz',
+};
+export const SIDE_CHAIN_ID = '41E209E4DE650F0150788E8EC5CAFA240A23EB8EB7';
+export const AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST = [
+    'https://tronscan.org',
+    'https://tronscan.io',
+    'https://app.justlend.org',
+];
+export const TRON_REQUEST_ACCOUNTS_LOCAL_KEY = 'onetoken_tron_request_accounts_local_key';
+export const TRON_REQUEST_ACCOUNTS_INTERVAL = 10 * 60 * 1000; // ten minutes
+const globalWindow = typeof window !== 'undefined' ? window : global;
+class OneTokenTronWeb extends TronWeb {
+    constructor(props, provider) {
+        super(props);
+        this.provider = provider;
+        this.defaultAddress = {
+            hex: false,
+            base58: false,
+        };
+        this.trx.sign = (transaction) => provider.sign(transaction);
+        this.trx.signMessage = (transaction) => provider.signMessage(transaction);
+        this.trx.signMessageV2 = (message, privateKey) => provider.signMessageV2(message, privateKey);
+        this.trx.getNodeInfo = (callback) => provider.getNodeInfo(callback);
+    }
+    request(args) {
+        return this.provider.request(args);
+    }
+}
+class ProviderTron extends ProviderTronBase {
+    constructor(props) {
+        var _a;
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || getOrCreateExtInjectedJsBridge({ timeout: props.timeout }) }));
+        this.isTronLink = true;
+        this.tronWeb = null;
+        this.sunWeb = null;
+        this.ready = false;
+        this._initialized = false;
+        this._connected = false;
+        this._requestingAccounts = false;
+        this._defaultAddress = {
+            hex: false,
+            base58: false,
+        };
+        this._accounts = [];
+        this._nodes = {
+            fullHost: '',
+            fullNode: '',
+            solidityNode: '',
+            eventServer: '',
+        };
+        this._log = (_a = props.logger) !== null && _a !== void 0 ? _a : window.console;
+        if (checkWalletSwitchEnable()) {
+            this._registerEvents();
+            void this._initialize();
+        }
+    }
+    _registerTronWeb(nodes) {
+        if (isEmpty(nodes))
+            return null;
+        const tronWeb = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const tronWeb1 = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const tronWeb2 = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const sunWeb = new SunWeb(tronWeb1, tronWeb2, CONTRACT_ADDRESS.MAIN, CONTRACT_ADDRESS.SIDE, SIDE_CHAIN_ID);
+        return { tronWeb, sunWeb };
+    }
+    _initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { accounts, nodes } = yield this.request({
+                    method: 'tron_getProviderState',
+                });
+                const resp = this._registerTronWeb(nodes);
+                if (!resp)
+                    return;
+                const { sunWeb, tronWeb } = resp;
+                if (window.tronWeb !== undefined) {
+                    this._log.warn('OneToken: TronWeb is already initiated. Onetoken will overwrite the current instance');
+                }
+                if (window.sunWeb !== undefined) {
+                    this._log.warn('OneToken: TronWeb is already initiated. Onetoken will overwrite the current instance');
+                }
+                this.tronWeb = tronWeb;
+                this.sunWeb = sunWeb;
+                defineWindowProperty('tronWeb', tronWeb);
+                defineWindowProperty('sunWeb', sunWeb);
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                const self = this;
+                Object.defineProperty(tronWeb, 'defaultAddress', {
+                    get() {
+                        var _a;
+                        if (!self._connected) {
+                            self._log.warn('OneToken: We recommend that DApp developers use $onetoken.tron.request({method: "tron_requestAccounts"}) to request users’ account information at the earliest time possible in order to get a complete TronWeb injection.');
+                            const origin = ((_a = globalWindow === null || globalWindow === void 0 ? void 0 : globalWindow.location) === null || _a === void 0 ? void 0 : _a.origin) || '';
+                            if (origin && AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST.includes(origin)) {
+                                const requestAccountsLocalStr = localStorage.getItem(TRON_REQUEST_ACCOUNTS_LOCAL_KEY);
+                                const requestAccountsLocal = requestAccountsLocalStr
+                                    ? JSON.parse(requestAccountsLocalStr)
+                                    : null;
+                                if (requestAccountsLocal && requestAccountsLocal[origin]) {
+                                    const requestTimeStamp = requestAccountsLocal[origin];
+                                    if (new BigNumber(Date.now())
+                                        .minus(requestTimeStamp)
+                                        .isGreaterThan(TRON_REQUEST_ACCOUNTS_INTERVAL)) {
+                                        localStorage.setItem(TRON_REQUEST_ACCOUNTS_LOCAL_KEY, JSON.stringify(Object.assign(Object.assign({}, requestAccountsLocal), { [origin]: Date.now() })));
+                                        void self.request({
+                                            method: 'tron_requestAccounts',
+                                        });
+                                    }
+                                }
+                                else {
+                                    localStorage.setItem(TRON_REQUEST_ACCOUNTS_LOCAL_KEY, JSON.stringify(Object.assign(Object.assign({}, requestAccountsLocal), { [origin]: Date.now() })));
+                                    void self.request({
+                                        method: 'tron_requestAccounts',
+                                    });
+                                }
+                            }
+                        }
+                        return self._defaultAddress;
+                    },
+                    set(value) {
+                        self._defaultAddress = value;
+                    },
+                });
+                this._handleAccountsChanged(accounts);
+                this._dispatch('tronLink#initialized');
+                this._initialized = true;
+            }
+            catch (error) {
+                this._log.error('OneToken: Failed to get initial state. Please report this bug.', error);
+            }
+        });
+    }
+    _registerEvents() {
+        window.addEventListener('onetoken_bridge_disconnect', () => {
+            this.__handleDisconnected();
+        });
+        this.on(ProviderEvents.MESSAGE_LOW_LEVEL, (payload) => {
+            const { method } = payload;
+            if (isWalletEventMethodMatch(method, ProviderEvents.ACCOUNTS_CHANGED)) {
+                this._handleAccountsChanged(payload.params);
+            }
+            if (isWalletEventMethodMatch(method, ProviderEvents.NODES_CHANGED)) {
+                if (this._initialized) {
+                    this._handleNodesChanged(payload.params);
+                }
+                else {
+                    void this._initialize();
+                }
+            }
+        });
+    }
+    isAccountsChanged(accounts) {
+        return !dequal(this._accounts, accounts);
+    }
+    _handleAccountsChanged(accounts) {
+        let _accounts = accounts;
+        if (!Array.isArray(accounts)) {
+            this._log.error('Onetoken: Received invalid accounts parameter. Please report this bug.', accounts);
+            _accounts = [];
+        }
+        for (const account of _accounts) {
+            if (typeof account !== 'string') {
+                this._log.error('Onetoken: Received non-string account. Please report this bug.', accounts);
+                _accounts = [];
+                break;
+            }
+        }
+        if (this.isAccountsChanged(_accounts)) {
+            this._accounts = _accounts;
+            const address = _accounts[0];
+            const tronWeb = this.tronWeb;
+            if (!tronWeb) {
+                return;
+            }
+            if (tronWeb.isAddress(address)) {
+                tronWeb.setAddress(address);
+                tronWeb.ready = true;
+                this.ready = true;
+                this._handleConnected();
+            }
+            else {
+                tronWeb.defaultAddress = {
+                    hex: false,
+                    base58: false,
+                };
+                tronWeb.ready = false;
+                this.ready = false;
+                this.__handleDisconnected();
+            }
+            if (this._initialized) {
+                this._postMessage(ProviderEvents.SET_ACCOUNT, {
+                    address,
+                });
+                this._postMessage(ProviderEvents.ACCOUNTS_CHANGED, {
+                    address,
+                });
+                this.emit(ProviderEvents.ACCOUNTS_CHANGED, [address]);
+            }
+        }
+    }
+    __handleDisconnected() {
+        if (this._connected) {
+            this._connected = false;
+            this._postMessage(ProviderEvents.DISCONNECT);
+        }
+    }
+    _handleConnected() {
+        if (!this._connected) {
+            this._connected = true;
+            this._postMessage(ProviderEvents.CONNECT);
+            this._postMessage(ProviderEvents.ACCEPT_WEB);
+        }
+    }
+    _postMessage(action, data) {
+        window.postMessage({
+            message: {
+                action,
+                data,
+            },
+            isTronLink: true,
+        });
+    }
+    _dispatch(event) {
+        window.dispatchEvent(new Event(event));
+    }
+    isNetworkChanged(nodes) {
+        return !dequal(nodes, this._nodes);
+    }
+    _handleNodesChanged({ nodes, chainId }) {
+        var _a, _b, _c, _d, _e, _f;
+        if (isEmpty(nodes))
+            return;
+        if (this.isNetworkChanged(nodes)) {
+            this._nodes = nodes;
+            (_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.setFullNode((_b = nodes.fullNode) !== null && _b !== void 0 ? _b : nodes.fullHost);
+            (_c = this.tronWeb) === null || _c === void 0 ? void 0 : _c.setSolidityNode((_d = nodes.solidityNode) !== null && _d !== void 0 ? _d : nodes.fullHost);
+            (_e = this.tronWeb) === null || _e === void 0 ? void 0 : _e.setEventServer((_f = nodes.eventServer) !== null && _f !== void 0 ? _f : nodes.fullHost);
+            this._postMessage(ProviderEvents.NODES_CHANGED, Object.assign({}, nodes));
+            this._postMessage(ProviderEvents.SET_NODE, Object.assign(Object.assign({}, nodes), { node: {
+                    chainId,
+                    chain: '_',
+                } }));
+            this.emit(ProviderEvents.CHAIN_CHANGED, chainId);
+        }
+    }
+    _requestAccounts(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._requestingAccounts) {
+                return {
+                    code: 4001,
+                    message: 'in the request queue',
+                };
+            }
+            this._requestingAccounts = true;
+            try {
+                const accounts = (yield this.bridgeRequest(args));
+                this._handleAccountsChanged(accounts);
+                this._requestingAccounts = false;
+                if (accounts.length > 0) {
+                    return {
+                        code: 200,
+                        message: 'ok',
+                    };
+                }
+                return {
+                    code: 4000,
+                    message: 'user rejected',
+                };
+            }
+            catch (e) {
+                this._requestingAccounts = false;
+                return {
+                    code: 4000,
+                    message: 'user rejected',
+                };
+            }
+        });
+    }
+    request(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { method, params } = args;
+            if (!method || typeof method !== 'string' || method.length === 0) {
+                throw web3Errors.rpc.methodNotFound();
+            }
+            if (params !== undefined &&
+                !Array.isArray(params) &&
+                (typeof params !== 'object' || params === null)) {
+                throw web3Errors.rpc.invalidParams();
+            }
+            if (method === 'tron_requestAccounts') {
+                const result = yield this._requestAccounts(args);
+                this._postMessage(ProviderEvents.TAB_REPLY, result);
+                return result;
+            }
+            const resp = yield this.bridgeRequest(args);
+            return resp;
+        });
+    }
+    sign(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if ((_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.utils.isString(transaction)) {
+                // @ts-ignore
+                if (!((_b = this.tronWeb) === null || _b === void 0 ? void 0 : _b.utils.isHex(transaction))) {
+                    throw new Error('Expected hex message input');
+                }
+                return this.request({
+                    method: 'signMessageV1',
+                    params: transaction,
+                });
+            }
+            return this.request({
+                method: 'tron_signTransaction',
+                params: transaction,
+            });
+        });
+    }
+    signMessage(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let messageStr;
+            if (typeof transaction === 'string') {
+                messageStr = transaction;
+            }
+            else {
+                throw new Error('Expected hex message input');
+            }
+            return this.request({
+                method: 'signMessageV1',
+                params: [messageStr],
+            });
+        });
+    }
+    signMessageV2(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let messageStr;
+            if (typeof message === 'string') {
+                const bytes = (_c = (_b = (_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.utils) === null || _b === void 0 ? void 0 : _b.ethersUtils) === null || _c === void 0 ? void 0 : _c.toUtf8Bytes(message);
+                if (!bytes) {
+                    throw new Error('Expected message input');
+                }
+                messageStr = Buffer.from(bytes).toString('hex');
+            }
+            else {
+                messageStr = Buffer.from(message).toString('hex');
+            }
+            return this.request({
+                method: 'signMessageV2',
+                params: [messageStr],
+            });
+        });
+    }
+    getNodeInfo(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this.request({
+                method: 'tron_getNodeInfo',
+            });
+            if (!callback)
+                return info;
+            callback(null, info);
+        });
+    }
+}
+export { ProviderTron };
+export { ProviderEvents, TronWeb, };

package/dist/ProviderTronBase.d.ts

@@ -0,0 +1,8 @@
+import { IInjectedProviderNames } from '@1tokenfe/cross-inpage-provider-types';
+import { ProviderBase, IInpageProviderConfig } from '@1tokenfe/cross-inpage-provider-core';
+declare class ProviderTronBase extends ProviderBase {
+    constructor(props: IInpageProviderConfig);
+    protected readonly providerName = IInjectedProviderNames.tron;
+    request(data: unknown): Promise<unknown>;
+}
+export { ProviderTronBase };

package/dist/ProviderTronBase.js

@@ -0,0 +1,12 @@
+import { IInjectedProviderNames } from '@1tokenfe/cross-inpage-provider-types';
+import { ProviderBase } from '@1tokenfe/cross-inpage-provider-core';
+class ProviderTronBase extends ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = IInjectedProviderNames.tron;
+    }
+    request(data) {
+        return this.bridgeRequest(data);
+    }
+}
+export { ProviderTronBase };

package/dist/cjs/ProviderTron.js

@@ -0,0 +1,396 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronWeb = exports.ProviderEvents = exports.ProviderTron = exports.TRON_REQUEST_ACCOUNTS_INTERVAL = exports.TRON_REQUEST_ACCOUNTS_LOCAL_KEY = exports.AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST = exports.SIDE_CHAIN_ID = exports.CONTRACT_ADDRESS = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const tronweb_1 = require("tronweb");
+Object.defineProperty(exports, "TronWeb", { enumerable: true, get: function () { return tronweb_1.TronWeb; } });
+const sunweb_1 = __importDefault(require("sunweb"));
+const lodash_es_1 = require("lodash-es");
+const cross_inpage_provider_core_1 = require("@1tokenfe/cross-inpage-provider-core");
+const extension_bridge_injected_1 = require("@1tokenfe/extension-bridge-injected");
+const cross_inpage_provider_errors_1 = require("@1tokenfe/cross-inpage-provider-errors");
+const ProviderTronBase_1 = require("./ProviderTronBase");
+const types_1 = require("./types");
+Object.defineProperty(exports, "ProviderEvents", { enumerable: true, get: function () { return types_1.ProviderEvents; } });
+const utils_1 = require("./utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+exports.CONTRACT_ADDRESS = {
+    MAIN: 'TL9q7aDAHYbW5KdPCwk8oJR3bCDhRwegFf',
+    SIDE: 'TGKotco6YoULzbYisTBuP6DWXDjEgJSpYz',
+};
+exports.SIDE_CHAIN_ID = '41E209E4DE650F0150788E8EC5CAFA240A23EB8EB7';
+exports.AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST = [
+    'https://tronscan.org',
+    'https://tronscan.io',
+    'https://app.justlend.org',
+];
+exports.TRON_REQUEST_ACCOUNTS_LOCAL_KEY = 'onetoken_tron_request_accounts_local_key';
+exports.TRON_REQUEST_ACCOUNTS_INTERVAL = 10 * 60 * 1000; // ten minutes
+const globalWindow = typeof window !== 'undefined' ? window : global;
+class OneTokenTronWeb extends tronweb_1.TronWeb {
+    constructor(props, provider) {
+        super(props);
+        this.provider = provider;
+        this.defaultAddress = {
+            hex: false,
+            base58: false,
+        };
+        this.trx.sign = (transaction) => provider.sign(transaction);
+        this.trx.signMessage = (transaction) => provider.signMessage(transaction);
+        this.trx.signMessageV2 = (message, privateKey) => provider.signMessageV2(message, privateKey);
+        this.trx.getNodeInfo = (callback) => provider.getNodeInfo(callback);
+    }
+    request(args) {
+        return this.provider.request(args);
+    }
+}
+class ProviderTron extends ProviderTronBase_1.ProviderTronBase {
+    constructor(props) {
+        var _a;
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || (0, extension_bridge_injected_1.getOrCreateExtInjectedJsBridge)({ timeout: props.timeout }) }));
+        this.isTronLink = true;
+        this.tronWeb = null;
+        this.sunWeb = null;
+        this.ready = false;
+        this._initialized = false;
+        this._connected = false;
+        this._requestingAccounts = false;
+        this._defaultAddress = {
+            hex: false,
+            base58: false,
+        };
+        this._accounts = [];
+        this._nodes = {
+            fullHost: '',
+            fullNode: '',
+            solidityNode: '',
+            eventServer: '',
+        };
+        this._log = (_a = props.logger) !== null && _a !== void 0 ? _a : window.console;
+        if ((0, cross_inpage_provider_core_1.checkWalletSwitchEnable)()) {
+            this._registerEvents();
+            void this._initialize();
+        }
+    }
+    _registerTronWeb(nodes) {
+        if ((0, lodash_es_1.isEmpty)(nodes))
+            return null;
+        const tronWeb = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const tronWeb1 = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const tronWeb2 = new OneTokenTronWeb(Object.assign({}, nodes), this);
+        const sunWeb = new sunweb_1.default(tronWeb1, tronWeb2, exports.CONTRACT_ADDRESS.MAIN, exports.CONTRACT_ADDRESS.SIDE, exports.SIDE_CHAIN_ID);
+        return { tronWeb, sunWeb };
+    }
+    _initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { accounts, nodes } = yield this.request({
+                    method: 'tron_getProviderState',
+                });
+                const resp = this._registerTronWeb(nodes);
+                if (!resp)
+                    return;
+                const { sunWeb, tronWeb } = resp;
+                if (window.tronWeb !== undefined) {
+                    this._log.warn('OneToken: TronWeb is already initiated. Onetoken will overwrite the current instance');
+                }
+                if (window.sunWeb !== undefined) {
+                    this._log.warn('OneToken: TronWeb is already initiated. Onetoken will overwrite the current instance');
+                }
+                this.tronWeb = tronWeb;
+                this.sunWeb = sunWeb;
+                (0, cross_inpage_provider_core_1.defineWindowProperty)('tronWeb', tronWeb);
+                (0, cross_inpage_provider_core_1.defineWindowProperty)('sunWeb', sunWeb);
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                const self = this;
+                Object.defineProperty(tronWeb, 'defaultAddress', {
+                    get() {
+                        var _a;
+                        if (!self._connected) {
+                            self._log.warn('OneToken: We recommend that DApp developers use $onetoken.tron.request({method: "tron_requestAccounts"}) to request users’ account information at the earliest time possible in order to get a complete TronWeb injection.');
+                            const origin = ((_a = globalWindow === null || globalWindow === void 0 ? void 0 : globalWindow.location) === null || _a === void 0 ? void 0 : _a.origin) || '';
+                            if (origin && exports.AUTO_REQUEST_ACCOUNTS_ORIGIN_WHITE_LIST.includes(origin)) {
+                                const requestAccountsLocalStr = localStorage.getItem(exports.TRON_REQUEST_ACCOUNTS_LOCAL_KEY);
+                                const requestAccountsLocal = requestAccountsLocalStr
+                                    ? JSON.parse(requestAccountsLocalStr)
+                                    : null;
+                                if (requestAccountsLocal && requestAccountsLocal[origin]) {
+                                    const requestTimeStamp = requestAccountsLocal[origin];
+                                    if (new bignumber_js_1.default(Date.now())
+                                        .minus(requestTimeStamp)
+                                        .isGreaterThan(exports.TRON_REQUEST_ACCOUNTS_INTERVAL)) {
+                                        localStorage.setItem(exports.TRON_REQUEST_ACCOUNTS_LOCAL_KEY, JSON.stringify(Object.assign(Object.assign({}, requestAccountsLocal), { [origin]: Date.now() })));
+                                        void self.request({
+                                            method: 'tron_requestAccounts',
+                                        });
+                                    }
+                                }
+                                else {
+                                    localStorage.setItem(exports.TRON_REQUEST_ACCOUNTS_LOCAL_KEY, JSON.stringify(Object.assign(Object.assign({}, requestAccountsLocal), { [origin]: Date.now() })));
+                                    void self.request({
+                                        method: 'tron_requestAccounts',
+                                    });
+                                }
+                            }
+                        }
+                        return self._defaultAddress;
+                    },
+                    set(value) {
+                        self._defaultAddress = value;
+                    },
+                });
+                this._handleAccountsChanged(accounts);
+                this._dispatch('tronLink#initialized');
+                this._initialized = true;
+            }
+            catch (error) {
+                this._log.error('OneToken: Failed to get initial state. Please report this bug.', error);
+            }
+        });
+    }
+    _registerEvents() {
+        window.addEventListener('onetoken_bridge_disconnect', () => {
+            this.__handleDisconnected();
+        });
+        this.on(types_1.ProviderEvents.MESSAGE_LOW_LEVEL, (payload) => {
+            const { method } = payload;
+            if ((0, utils_1.isWalletEventMethodMatch)(method, types_1.ProviderEvents.ACCOUNTS_CHANGED)) {
+                this._handleAccountsChanged(payload.params);
+            }
+            if ((0, utils_1.isWalletEventMethodMatch)(method, types_1.ProviderEvents.NODES_CHANGED)) {
+                if (this._initialized) {
+                    this._handleNodesChanged(payload.params);
+                }
+                else {
+                    void this._initialize();
+                }
+            }
+        });
+    }
+    isAccountsChanged(accounts) {
+        return !(0, fast_deep_equal_1.default)(this._accounts, accounts);
+    }
+    _handleAccountsChanged(accounts) {
+        let _accounts = accounts;
+        if (!Array.isArray(accounts)) {
+            this._log.error('Onetoken: Received invalid accounts parameter. Please report this bug.', accounts);
+            _accounts = [];
+        }
+        for (const account of _accounts) {
+            if (typeof account !== 'string') {
+                this._log.error('Onetoken: Received non-string account. Please report this bug.', accounts);
+                _accounts = [];
+                break;
+            }
+        }
+        if (this.isAccountsChanged(_accounts)) {
+            this._accounts = _accounts;
+            const address = _accounts[0];
+            const tronWeb = this.tronWeb;
+            if (!tronWeb) {
+                return;
+            }
+            if (tronWeb.isAddress(address)) {
+                tronWeb.setAddress(address);
+                tronWeb.ready = true;
+                this.ready = true;
+                this._handleConnected();
+            }
+            else {
+                tronWeb.defaultAddress = {
+                    hex: false,
+                    base58: false,
+                };
+                tronWeb.ready = false;
+                this.ready = false;
+                this.__handleDisconnected();
+            }
+            if (this._initialized) {
+                this._postMessage(types_1.ProviderEvents.SET_ACCOUNT, {
+                    address,
+                });
+                this._postMessage(types_1.ProviderEvents.ACCOUNTS_CHANGED, {
+                    address,
+                });
+                this.emit(types_1.ProviderEvents.ACCOUNTS_CHANGED, [address]);
+            }
+        }
+    }
+    __handleDisconnected() {
+        if (this._connected) {
+            this._connected = false;
+            this._postMessage(types_1.ProviderEvents.DISCONNECT);
+        }
+    }
+    _handleConnected() {
+        if (!this._connected) {
+            this._connected = true;
+            this._postMessage(types_1.ProviderEvents.CONNECT);
+            this._postMessage(types_1.ProviderEvents.ACCEPT_WEB);
+        }
+    }
+    _postMessage(action, data) {
+        window.postMessage({
+            message: {
+                action,
+                data,
+            },
+            isTronLink: true,
+        });
+    }
+    _dispatch(event) {
+        window.dispatchEvent(new Event(event));
+    }
+    isNetworkChanged(nodes) {
+        return !(0, fast_deep_equal_1.default)(nodes, this._nodes);
+    }
+    _handleNodesChanged({ nodes, chainId }) {
+        var _a, _b, _c, _d, _e, _f;
+        if ((0, lodash_es_1.isEmpty)(nodes))
+            return;
+        if (this.isNetworkChanged(nodes)) {
+            this._nodes = nodes;
+            (_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.setFullNode((_b = nodes.fullNode) !== null && _b !== void 0 ? _b : nodes.fullHost);
+            (_c = this.tronWeb) === null || _c === void 0 ? void 0 : _c.setSolidityNode((_d = nodes.solidityNode) !== null && _d !== void 0 ? _d : nodes.fullHost);
+            (_e = this.tronWeb) === null || _e === void 0 ? void 0 : _e.setEventServer((_f = nodes.eventServer) !== null && _f !== void 0 ? _f : nodes.fullHost);
+            this._postMessage(types_1.ProviderEvents.NODES_CHANGED, Object.assign({}, nodes));
+            this._postMessage(types_1.ProviderEvents.SET_NODE, Object.assign(Object.assign({}, nodes), { node: {
+                    chainId,
+                    chain: '_',
+                } }));
+            this.emit(types_1.ProviderEvents.CHAIN_CHANGED, chainId);
+        }
+    }
+    _requestAccounts(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._requestingAccounts) {
+                return {
+                    code: 4001,
+                    message: 'in the request queue',
+                };
+            }
+            this._requestingAccounts = true;
+            try {
+                const accounts = (yield this.bridgeRequest(args));
+                this._handleAccountsChanged(accounts);
+                this._requestingAccounts = false;
+                if (accounts.length > 0) {
+                    return {
+                        code: 200,
+                        message: 'ok',
+                    };
+                }
+                return {
+                    code: 4000,
+                    message: 'user rejected',
+                };
+            }
+            catch (e) {
+                this._requestingAccounts = false;
+                return {
+                    code: 4000,
+                    message: 'user rejected',
+                };
+            }
+        });
+    }
+    request(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { method, params } = args;
+            if (!method || typeof method !== 'string' || method.length === 0) {
+                throw cross_inpage_provider_errors_1.web3Errors.rpc.methodNotFound();
+            }
+            if (params !== undefined &&
+                !Array.isArray(params) &&
+                (typeof params !== 'object' || params === null)) {
+                throw cross_inpage_provider_errors_1.web3Errors.rpc.invalidParams();
+            }
+            if (method === 'tron_requestAccounts') {
+                const result = yield this._requestAccounts(args);
+                this._postMessage(types_1.ProviderEvents.TAB_REPLY, result);
+                return result;
+            }
+            const resp = yield this.bridgeRequest(args);
+            return resp;
+        });
+    }
+    sign(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if ((_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.utils.isString(transaction)) {
+                // @ts-ignore
+                if (!((_b = this.tronWeb) === null || _b === void 0 ? void 0 : _b.utils.isHex(transaction))) {
+                    throw new Error('Expected hex message input');
+                }
+                return this.request({
+                    method: 'signMessageV1',
+                    params: transaction,
+                });
+            }
+            return this.request({
+                method: 'tron_signTransaction',
+                params: transaction,
+            });
+        });
+    }
+    signMessage(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let messageStr;
+            if (typeof transaction === 'string') {
+                messageStr = transaction;
+            }
+            else {
+                throw new Error('Expected hex message input');
+            }
+            return this.request({
+                method: 'signMessageV1',
+                params: [messageStr],
+            });
+        });
+    }
+    signMessageV2(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let messageStr;
+            if (typeof message === 'string') {
+                const bytes = (_c = (_b = (_a = this.tronWeb) === null || _a === void 0 ? void 0 : _a.utils) === null || _b === void 0 ? void 0 : _b.ethersUtils) === null || _c === void 0 ? void 0 : _c.toUtf8Bytes(message);
+                if (!bytes) {
+                    throw new Error('Expected message input');
+                }
+                messageStr = Buffer.from(bytes).toString('hex');
+            }
+            else {
+                messageStr = Buffer.from(message).toString('hex');
+            }
+            return this.request({
+                method: 'signMessageV2',
+                params: [messageStr],
+            });
+        });
+    }
+    getNodeInfo(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this.request({
+                method: 'tron_getNodeInfo',
+            });
+            if (!callback)
+                return info;
+            callback(null, info);
+        });
+    }
+}
+exports.ProviderTron = ProviderTron;

package/dist/cjs/ProviderTronBase.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderTronBase = void 0;
+const cross_inpage_provider_types_1 = require("@1tokenfe/cross-inpage-provider-types");
+const cross_inpage_provider_core_1 = require("@1tokenfe/cross-inpage-provider-core");
+class ProviderTronBase extends cross_inpage_provider_core_1.ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = cross_inpage_provider_types_1.IInjectedProviderNames.tron;
+    }
+    request(data) {
+        return this.bridgeRequest(data);
+    }
+}
+exports.ProviderTronBase = ProviderTronBase;

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ProviderTronBase"), exports);
+__exportStar(require("./ProviderTron"), exports);
+__exportStar(require("./registerTIP6963Provider"), exports);

package/dist/cjs/registerTIP6963Provider.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTIP6963Provider = registerTIP6963Provider;
+const uuid_1 = require("uuid");
+function registerTIP6963Provider({ uuid = (0, uuid_1.v4)(), name = 'OneToken', rdns = 'so.onetoken.app.wallet', image, provider, }) {
+    // TIP-6963: https://github.com/tronprotocol/tips/issues/737
+    const info = {
+        uuid,
+        name,
+        icon: image,
+        rdns,
+    };
+    function announceProvider() {
+        window.dispatchEvent(new CustomEvent('TIP6963:announceProvider', {
+            detail: { info, provider: provider },
+        }));
+    }
+    window.addEventListener('TIP6963:requestProvider', announceProvider);
+    announceProvider();
+}

package/dist/cjs/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderEvents = void 0;
+var ProviderEvents;
+(function (ProviderEvents) {
+    ProviderEvents["TAB_REPLY"] = "tabReply";
+    ProviderEvents["CONNECT"] = "connect";
+    ProviderEvents["DISCONNECT"] = "disconnect";
+    ProviderEvents["ACCOUNTS_CHANGED"] = "accountsChanged";
+    ProviderEvents["SET_ACCOUNT"] = "setAccount";
+    ProviderEvents["SET_NODE"] = "setNode";
+    ProviderEvents["NODES_CHANGED"] = "nodesChanged";
+    ProviderEvents["MESSAGE"] = "message";
+    ProviderEvents["MESSAGE_LOW_LEVEL"] = "message_low_level";
+    ProviderEvents["CHAIN_CHANGED"] = "chainChanged";
+    ProviderEvents["ACCEPT_WEB"] = "acceptWeb";
+})(ProviderEvents || (exports.ProviderEvents = ProviderEvents = {}));

package/dist/cjs/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWalletEventMethodMatch = isWalletEventMethodMatch;
+function isWalletEventMethodMatch(method, name) {
+    return method === `wallet_events_${name}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ProviderTronBase';
+export * from './ProviderTron';
+export * from './registerTIP6963Provider';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './ProviderTronBase';
+export * from './ProviderTron';
+export * from './registerTIP6963Provider';

package/dist/registerTIP6963Provider.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderTron } from './ProviderTron';
+export declare function registerTIP6963Provider({ uuid, name, rdns, image, provider, }: {
+    uuid?: string;
+    name?: string;
+    rdns?: string;
+    image: string;
+    provider: ProviderTron;
+}): void;

package/dist/registerTIP6963Provider.js

@@ -0,0 +1,17 @@
+import { v4 as uuidV4 } from 'uuid';
+export function registerTIP6963Provider({ uuid = uuidV4(), name = 'OneToken', rdns = 'so.onetoken.app.wallet', image, provider, }) {
+    // TIP-6963: https://github.com/tronprotocol/tips/issues/737
+    const info = {
+        uuid,
+        name,
+        icon: image,
+        rdns,
+    };
+    function announceProvider() {
+        window.dispatchEvent(new CustomEvent('TIP6963:announceProvider', {
+            detail: { info, provider: provider },
+        }));
+    }
+    window.addEventListener('TIP6963:requestProvider', announceProvider);
+    announceProvider();
+}

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+import { IJsonRpcRequest } from '@1tokenfe/cross-inpage-provider-types';
+import TronWeb, { UnsignedTransaction, SignedTransaction } from 'tronweb';
+import { ProviderTronBase } from './ProviderTronBase';
+export declare enum ProviderEvents {
+    TAB_REPLY = "tabReply",
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    ACCOUNTS_CHANGED = "accountsChanged",
+    SET_ACCOUNT = "setAccount",
+    SET_NODE = "setNode",
+    NODES_CHANGED = "nodesChanged",
+    MESSAGE = "message",
+    MESSAGE_LOW_LEVEL = "message_low_level",
+    CHAIN_CHANGED = "chainChanged",
+    ACCEPT_WEB = "acceptWeb"
+}
+export interface Nodes {
+    fullHost: string;
+    fullNode: string;
+    solidityNode: string;
+    eventServer: string;
+}
+export interface Network {
+    chainId?: string;
+    networkId?: string;
+}
+export type ConsoleLike = Pick<Console, 'log' | 'warn' | 'error' | 'debug' | 'info' | 'trace'>;
+export interface ProviderEventsMap {
+    [ProviderEvents.CONNECT]: (network: Network) => void;
+    [ProviderEvents.DISCONNECT]: () => void;
+    [ProviderEvents.ACCOUNTS_CHANGED]: (accounts: string[]) => void;
+    [ProviderEvents.NODES_CHANGED]: (nodes: Nodes) => void;
+    [ProviderEvents.MESSAGE_LOW_LEVEL]: (payload: IJsonRpcRequest) => void;
+    [ProviderEvents.MESSAGE]: (message: string) => void;
+}
+export interface RequestArguments {
+    id?: number | string;
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+export type Callback = false | ((err: Error | null, info: any) => any);
+export interface IProviderTron extends ProviderTronBase {
+    readonly isTronLink: true;
+    tronWeb: TronWeb | null;
+    sunWeb: any;
+    ready: boolean;
+    request<T>(args: RequestArguments): Promise<T>;
+    sign(transaction: UnsignedTransaction): Promise<SignedTransaction>;
+    signMessage(transaction: UnsignedTransaction): Promise<string>;
+    signMessageV2(message: string | Uint8Array | Array<number>, privateKey?: string | false): Promise<string>;
+    getNodeInfo(callback?: Callback): Promise<any>;
+}
+export interface requestAccountsResponse {
+    code: 200 | 4000 | 4001;
+    message: string;
+}

package/dist/types.js

@@ -0,0 +1,14 @@
+export var ProviderEvents;
+(function (ProviderEvents) {
+    ProviderEvents["TAB_REPLY"] = "tabReply";
+    ProviderEvents["CONNECT"] = "connect";
+    ProviderEvents["DISCONNECT"] = "disconnect";
+    ProviderEvents["ACCOUNTS_CHANGED"] = "accountsChanged";
+    ProviderEvents["SET_ACCOUNT"] = "setAccount";
+    ProviderEvents["SET_NODE"] = "setNode";
+    ProviderEvents["NODES_CHANGED"] = "nodesChanged";
+    ProviderEvents["MESSAGE"] = "message";
+    ProviderEvents["MESSAGE_LOW_LEVEL"] = "message_low_level";
+    ProviderEvents["CHAIN_CHANGED"] = "chainChanged";
+    ProviderEvents["ACCEPT_WEB"] = "acceptWeb";
+})(ProviderEvents || (ProviderEvents = {}));

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function isWalletEventMethodMatch(method: string, name: string): boolean;

package/dist/utils.js

@@ -0,0 +1,3 @@
+export function isWalletEventMethodMatch(method, name) {
+    return method === `wallet_events_${name}`;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@1tokenfe/onetoken-tron-provider",
+  "version": "2.2.46",
+  "keywords": [
+    "cross-inpage-provider"
+  ],
+  "author": "dev-fe@onetoken.so",
+  "repository": "https://github.com/OneTokenHQ/cross-inpage-provider",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/cjs/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsc && tsc --project tsconfig.cjs.json",
+    "start": "tsc --watch"
+  },
+  "dependencies": {
+    "@1tokenfe/cross-inpage-provider-core": "2.2.46",
+    "@1tokenfe/cross-inpage-provider-errors": "2.2.46",
+    "@1tokenfe/cross-inpage-provider-types": "2.2.46",
+    "@1tokenfe/extension-bridge-injected": "2.2.46",
+    "@noble/secp256k1": "1.7.1",
+    "lodash-es": "^4.17.21",
+    "querystring": "^0.2.1",
+    "sunweb": "^1.0.7",
+    "tronweb": "^6.0.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "@types/uuid": "^8.3.2"
+  },
+  "gitHead": "dadd71e7e07ab7aaf87961aecc01255586848e16"
+}