@1tokenfe/onetoken-ton-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/OnetokenTonProvider.d.ts

@@ -0,0 +1,63 @@
+import { IInpageProviderConfig, IProviderBaseConnectionStatus } from '@1tokenfe/cross-inpage-provider-core';
+import { ProviderTonBase } from './ProviderTonBase';
+import { AppRequest, ConnectEvent, ConnectRequest, DeviceInfo, RpcMethod, WalletEvent, WalletResponse, WalletResponseError } from '@tonconnect/protocol';
+import { AccountInfo, SignDataRequest, SignDataResult, SignProofRequest, SignProofResult, TransactionRequest, WalletInfo } from './types';
+declare const PROVIDER_EVENTS: {
+    readonly disconnect: "disconnect";
+    readonly accountChanged: "accountChanged";
+    readonly message_low_level: "message_low_level";
+};
+export type TonRequest = {
+    'connect': (protocolVersion?: number, message?: ConnectRequest) => Promise<AccountInfo>;
+    'disconnect': () => Promise<void>;
+    'sendTransaction': (payload: TransactionRequest) => Promise<string>;
+    'signData': (payload: SignDataRequest) => Promise<SignDataResult>;
+    'signProof': (request: SignProofRequest) => Promise<SignProofResult>;
+    'getDeviceInfo': () => Promise<Partial<DeviceInfo>>;
+};
+export type PROVIDER_EVENTS_STRINGS = keyof typeof PROVIDER_EVENTS;
+export interface IProviderTon extends ProviderTonBase {
+    deviceInfo: DeviceInfo;
+    walletInfo?: WalletInfo;
+    protocolVersion: number;
+    isWalletBrowser: boolean;
+    connect(protocolVersion: number, message: ConnectRequest): Promise<ConnectEvent>;
+    restoreConnection(): Promise<ConnectEvent>;
+    send<T extends RpcMethod>(message: AppRequest<T>): Promise<WalletResponse<T>>;
+    listen(callback: (event: WalletEvent) => void): void;
+}
+type OneTokenTonProviderProps = IInpageProviderConfig & {
+    timeout?: number;
+};
+export declare function createTonProviderOpenMask(originalProvider: ProviderTon): ProviderTon;
+export declare function createTonProvider(originalProvider: ProviderTon, customDeviceInfo: Partial<DeviceInfo>, customWalletInfo: Partial<WalletInfo>): ProviderTon;
+export declare class ProviderTon extends ProviderTonBase implements IProviderTon {
+    private _accountInfo;
+    deviceInfo: DeviceInfo;
+    walletInfo?: WalletInfo;
+    protocolVersion: number;
+    isWalletBrowser: boolean;
+    connectionStatus: IProviderBaseConnectionStatus;
+    constructor(props: OneTokenTonProviderProps);
+    private _getPlatform;
+    private _getDeviceInfo;
+    private _registerEvents;
+    private _callBridge;
+    private _handleConnected;
+    private _handleDisconnected;
+    isAccountsChanged(accountInfo: AccountInfo | undefined): boolean;
+    private _handleAccountChange;
+    private _network;
+    isNetworkChanged(network: string): boolean;
+    _connect(protocolVersion?: number, message?: ConnectRequest): Promise<ConnectEvent>;
+    connect(protocolVersion?: number, message?: ConnectRequest): Promise<ConnectEvent>;
+    restoreConnection(): Promise<ConnectEvent>;
+    convertError<T extends RpcMethod>(id: string, error: unknown, method: string): WalletResponseError<T>;
+    send<T extends RpcMethod>(message: AppRequest<T>): Promise<WalletResponse<T>>;
+    private _sendTransaction;
+    private _signData;
+    disconnect(): Promise<void>;
+    private _disconnect;
+    listen(callback: (event: WalletEvent) => void): void;
+}
+export {};

package/dist/OnetokenTonProvider.js

@@ -0,0 +1,397 @@
+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());
+    });
+};
+import { getOrCreateExtInjectedJsBridge } from '@1tokenfe/extension-bridge-injected';
+import { ProviderTonBase } from './ProviderTonBase';
+import { CONNECT_EVENT_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, } from '@tonconnect/protocol';
+import { ConnectEventErrorMessage, SendTransactionErrorMessage, } from './types';
+const PROVIDER_EVENTS = {
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};
+const TonResponseError = {
+    ParameterError: 1,
+    InvalidManifestUrl: 2,
+    ContentManifest: 3,
+};
+function isWalletEventMethodMatch({ method, name }) {
+    return method === `wallet_events_${name}`;
+}
+export function createTonProviderOpenMask(originalProvider) {
+    return createTonProvider(originalProvider, {
+        appName: 'openmask',
+        appVersion: '0.21.1',
+    }, {
+        name: 'OpenMask',
+        image: 'https://raw.githubusercontent.com/OpenProduct/openmask-extension/main/public/openmask-logo-288.png',
+        about_url: 'https://www.openmask.app/',
+    });
+}
+export function createTonProvider(originalProvider, customDeviceInfo, customWalletInfo) {
+    return new Proxy(originalProvider, {
+        get(target, prop, receiver) {
+            if (prop === 'deviceInfo') {
+                return Object.assign(Object.assign({}, target.deviceInfo), customDeviceInfo);
+            }
+            if (prop === 'walletInfo') {
+                return Object.assign(Object.assign({}, target.walletInfo), customWalletInfo);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+// Doc: https://github.com/ton-blockchain/ton-connect/blob/main/requests-responses.md
+export class ProviderTon extends ProviderTonBase {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || getOrCreateExtInjectedJsBridge({ timeout: props.timeout }) }));
+        this._accountInfo = null;
+        this.deviceInfo = {
+            platform: this._getPlatform(),
+            appName: 'onetoken',
+            appVersion: this.version,
+            maxProtocolVersion: 2,
+            features: ["SendTransaction", { name: 'SendTransaction', maxMessages: 4 }],
+        };
+        this.walletInfo = {
+            name: 'OneToken',
+            image: 'https://common.onetoken-asset.com/logo/onetoken-x288.png',
+            about_url: 'https://onetoken.so',
+        };
+        this.protocolVersion = 2;
+        this.isWalletBrowser = false;
+        this.connectionStatus = 'disconnected';
+        // void this._getDeviceInfo();
+        this._registerEvents();
+    }
+    _getPlatform() {
+        const userAgent = window.navigator.userAgent, platform = window.navigator.platform, macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'], iosPlatforms = ['iPhone', 'iPad'];
+        let os = 'windows';
+        if (macosPlatforms.indexOf(platform) !== -1) {
+            os = 'mac';
+        }
+        else if (iosPlatforms.indexOf(platform) !== -1) {
+            if (platform === 'iPhone') {
+                os = 'iphone';
+            }
+            else {
+                os = 'ipad';
+            }
+        }
+        else if (windowsPlatforms.indexOf(platform) !== -1) {
+            os = 'windows';
+        }
+        else if (/Android/.test(userAgent)) {
+            os = 'android';
+        }
+        else if (!os && /Linux/.test(platform)) {
+            os = 'linux';
+        }
+        return os;
+    }
+    _getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceInfo = yield this._callBridge({
+                method: 'getDeviceInfo',
+                params: [],
+            });
+            Object.assign(this.deviceInfo, deviceInfo);
+        });
+    }
+    _registerEvents() {
+        window.addEventListener('onetoken_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(PROVIDER_EVENTS.message_low_level, (payload) => {
+            if (!payload)
+                return;
+            const { method, params } = payload;
+            if (isWalletEventMethodMatch({ method, name: PROVIDER_EVENTS.accountChanged })) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _callBridge(params) {
+        return this.bridgeRequest(params);
+    }
+    _handleConnected(accountInfo, options = { emit: true }) {
+        var _a;
+        this._accountInfo = accountInfo;
+        if (options.emit && this.isConnectionStatusChanged('connected')) {
+            this.connectionStatus = 'connected';
+            const address = (_a = accountInfo.address) !== null && _a !== void 0 ? _a : null;
+            this.emit('connect', address);
+            this.emit('accountChanged', address);
+        }
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this._accountInfo = null;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.connectionStatus = 'disconnected';
+            this.emit('disconnect');
+            this.emit('accountChanged', null);
+        }
+    }
+    isAccountsChanged(accountInfo) {
+        var _a;
+        return (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.address) !== ((_a = this._accountInfo) === null || _a === void 0 ? void 0 : _a.address);
+    }
+    // trigger by bridge account change event
+    _handleAccountChange(payload) {
+        const accountInfo = payload;
+        if (this.isAccountsChanged(accountInfo)) {
+            this.emit('accountChanged', (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.address) || null);
+        }
+        if (!accountInfo) {
+            this._handleDisconnected();
+            return;
+        }
+        this._handleConnected(accountInfo, { emit: false });
+    }
+    isNetworkChanged(network) {
+        return this._network === undefined || network !== this._network;
+    }
+    _connect(protocolVersion, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = Date.now();
+            const isGetTonAddr = !message || (message && message.items.some((item) => item.name === 'ton_addr'));
+            const proofItem = message &&
+                message.items.find((item) => item.name === 'ton_proof');
+            const items = [];
+            if (isGetTonAddr) {
+                if (this._accountInfo) {
+                    items.push(Object.assign({ name: 'ton_addr' }, this._accountInfo));
+                }
+                else {
+                    let result;
+                    try {
+                        result = yield this._callBridge({
+                            method: 'connect',
+                            params: protocolVersion && message ? [protocolVersion, message] : [],
+                        });
+                    }
+                    catch (error) {
+                        const { code, message } = error;
+                        if (code === 4001) {
+                            return {
+                                event: 'connect_error',
+                                id,
+                                payload: {
+                                    code: CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR,
+                                    message: ConnectEventErrorMessage.USER_DECLINED,
+                                },
+                            };
+                        }
+                        else if (code === TonResponseError.InvalidManifestUrl || code === TonResponseError.ContentManifest) {
+                            return {
+                                event: 'connect_error',
+                                id,
+                                payload: {
+                                    code,
+                                    message: message !== null && message !== void 0 ? message : "",
+                                },
+                            };
+                        }
+                    }
+                    if (!result) {
+                        return {
+                            event: 'connect_error',
+                            id,
+                            payload: {
+                                code: CONNECT_EVENT_ERROR_CODES.UNKNOWN_ERROR,
+                                message: ConnectEventErrorMessage.UNKNOWN_ERROR,
+                            },
+                        };
+                    }
+                    items.push(Object.assign({ name: 'ton_addr' }, result));
+                    this._handleConnected(result, { emit: true });
+                }
+            }
+            if (proofItem) {
+                let result;
+                try {
+                    result = yield this._callBridge({
+                        method: 'signProof',
+                        params: [
+                            {
+                                payload: proofItem.payload,
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    const { code } = error;
+                    if (code === 4001) {
+                        return {
+                            event: 'connect_error',
+                            id,
+                            payload: {
+                                code: CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR,
+                                message: ConnectEventErrorMessage.USER_DECLINED,
+                            },
+                        };
+                    }
+                }
+                if (!result) {
+                    return {
+                        event: 'connect_error',
+                        id,
+                        payload: {
+                            code: CONNECT_EVENT_ERROR_CODES.UNKNOWN_ERROR,
+                            message: ConnectEventErrorMessage.UNKNOWN_ERROR,
+                        },
+                    };
+                }
+                items.push({
+                    name: 'ton_proof',
+                    proof: Object.assign(Object.assign({}, result), { payload: proofItem.payload }),
+                });
+            }
+            return {
+                event: 'connect',
+                id,
+                payload: {
+                    items,
+                    device: this.deviceInfo,
+                },
+            };
+        });
+    }
+    connect(protocolVersion, message) {
+        try {
+            return this._connect(protocolVersion, message);
+        }
+        catch (error) {
+            console.error('=====>>>>> connect error', error);
+            throw error;
+        }
+    }
+    restoreConnection() {
+        return this._connect();
+    }
+    convertError(id, error, method) {
+        const { code, message } = error;
+        if (code === 4001) {
+            let errorMessage = ConnectEventErrorMessage.USER_DECLINED;
+            if (method === 'sendTransaction' || method === 'signData') {
+                errorMessage = SendTransactionErrorMessage.USER_REJECTS_ERROR;
+            }
+            return {
+                id,
+                error: {
+                    code: SEND_TRANSACTION_ERROR_CODES.USER_REJECTS_ERROR,
+                    message: errorMessage,
+                },
+            };
+        }
+        else if (code === TonResponseError.ParameterError) {
+            return {
+                id,
+                error: {
+                    code: SEND_TRANSACTION_ERROR_CODES.BAD_REQUEST_ERROR,
+                    message: message,
+                },
+            };
+        }
+        else {
+            return {
+                id,
+                error: {
+                    code: SEND_TRANSACTION_ERROR_CODES.UNKNOWN_APP_ERROR,
+                    message: message !== null && message !== void 0 ? message : '',
+                },
+            };
+        }
+    }
+    send(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = message.id;
+            let res;
+            try {
+                const params = message.params.map((p) => {
+                    if (typeof p === 'string') {
+                        return JSON.parse(p);
+                    }
+                    return p;
+                });
+                if (message.method === 'sendTransaction') {
+                    res = yield this._sendTransaction(params[0]);
+                }
+                else if (message.method === 'signData') {
+                    res = yield this._signData(params[0]);
+                }
+                else if (message.method === 'disconnect') {
+                    yield this._disconnect();
+                    // @ts-expect-error
+                    return;
+                }
+                else {
+                    return {
+                        id,
+                        error: {
+                            code: SEND_TRANSACTION_ERROR_CODES.METHOD_NOT_SUPPORTED,
+                            message: SendTransactionErrorMessage.METHOD_NOT_SUPPORTED,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                return this.convertError(id, error, message.method);
+            }
+            if (res === undefined) {
+                return {
+                    id,
+                    error: {
+                        code: SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR,
+                        message: SendTransactionErrorMessage.UNKNOWN_ERROR,
+                    },
+                };
+            }
+            return {
+                id,
+                result: res,
+            };
+        });
+    }
+    _sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._callBridge({
+                method: 'sendTransaction',
+                params: [request],
+            });
+        });
+    }
+    _signData(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this._callBridge({
+                method: 'signData',
+                params: [request],
+            });
+            return res;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._disconnect();
+        });
+    }
+    _disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._callBridge({
+                method: 'disconnect',
+                params: [],
+            });
+            this._handleDisconnected({ emit: true });
+        });
+    }
+    listen(callback) {
+        super.on('event', callback);
+    }
+}

package/dist/ProviderTonBase.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 ProviderTonBase extends ProviderBase {
+    constructor(props: IInpageProviderConfig);
+    protected providerName: IInjectedProviderNames;
+    request(data: unknown): Promise<unknown>;
+}
+export { ProviderTonBase };

package/dist/ProviderTonBase.js

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

package/dist/cjs/OnetokenTonProvider.js

@@ -0,0 +1,403 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderTon = void 0;
+exports.createTonProviderOpenMask = createTonProviderOpenMask;
+exports.createTonProvider = createTonProvider;
+const extension_bridge_injected_1 = require("@1tokenfe/extension-bridge-injected");
+const ProviderTonBase_1 = require("./ProviderTonBase");
+const protocol_1 = require("@tonconnect/protocol");
+const types_1 = require("./types");
+const PROVIDER_EVENTS = {
+    'disconnect': 'disconnect',
+    'accountChanged': 'accountChanged',
+    'message_low_level': 'message_low_level',
+};
+const TonResponseError = {
+    ParameterError: 1,
+    InvalidManifestUrl: 2,
+    ContentManifest: 3,
+};
+function isWalletEventMethodMatch({ method, name }) {
+    return method === `wallet_events_${name}`;
+}
+function createTonProviderOpenMask(originalProvider) {
+    return createTonProvider(originalProvider, {
+        appName: 'openmask',
+        appVersion: '0.21.1',
+    }, {
+        name: 'OpenMask',
+        image: 'https://raw.githubusercontent.com/OpenProduct/openmask-extension/main/public/openmask-logo-288.png',
+        about_url: 'https://www.openmask.app/',
+    });
+}
+function createTonProvider(originalProvider, customDeviceInfo, customWalletInfo) {
+    return new Proxy(originalProvider, {
+        get(target, prop, receiver) {
+            if (prop === 'deviceInfo') {
+                return Object.assign(Object.assign({}, target.deviceInfo), customDeviceInfo);
+            }
+            if (prop === 'walletInfo') {
+                return Object.assign(Object.assign({}, target.walletInfo), customWalletInfo);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+// Doc: https://github.com/ton-blockchain/ton-connect/blob/main/requests-responses.md
+class ProviderTon extends ProviderTonBase_1.ProviderTonBase {
+    constructor(props) {
+        super(Object.assign(Object.assign({}, props), { bridge: props.bridge || (0, extension_bridge_injected_1.getOrCreateExtInjectedJsBridge)({ timeout: props.timeout }) }));
+        this._accountInfo = null;
+        this.deviceInfo = {
+            platform: this._getPlatform(),
+            appName: 'onetoken',
+            appVersion: this.version,
+            maxProtocolVersion: 2,
+            features: ["SendTransaction", { name: 'SendTransaction', maxMessages: 4 }],
+        };
+        this.walletInfo = {
+            name: 'OneToken',
+            image: 'https://common.onetoken-asset.com/logo/onetoken-x288.png',
+            about_url: 'https://onetoken.so',
+        };
+        this.protocolVersion = 2;
+        this.isWalletBrowser = false;
+        this.connectionStatus = 'disconnected';
+        // void this._getDeviceInfo();
+        this._registerEvents();
+    }
+    _getPlatform() {
+        const userAgent = window.navigator.userAgent, platform = window.navigator.platform, macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'], iosPlatforms = ['iPhone', 'iPad'];
+        let os = 'windows';
+        if (macosPlatforms.indexOf(platform) !== -1) {
+            os = 'mac';
+        }
+        else if (iosPlatforms.indexOf(platform) !== -1) {
+            if (platform === 'iPhone') {
+                os = 'iphone';
+            }
+            else {
+                os = 'ipad';
+            }
+        }
+        else if (windowsPlatforms.indexOf(platform) !== -1) {
+            os = 'windows';
+        }
+        else if (/Android/.test(userAgent)) {
+            os = 'android';
+        }
+        else if (!os && /Linux/.test(platform)) {
+            os = 'linux';
+        }
+        return os;
+    }
+    _getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceInfo = yield this._callBridge({
+                method: 'getDeviceInfo',
+                params: [],
+            });
+            Object.assign(this.deviceInfo, deviceInfo);
+        });
+    }
+    _registerEvents() {
+        window.addEventListener('onetoken_bridge_disconnect', () => {
+            this._handleDisconnected();
+        });
+        this.on(PROVIDER_EVENTS.message_low_level, (payload) => {
+            if (!payload)
+                return;
+            const { method, params } = payload;
+            if (isWalletEventMethodMatch({ method, name: PROVIDER_EVENTS.accountChanged })) {
+                this._handleAccountChange(params);
+            }
+        });
+    }
+    _callBridge(params) {
+        return this.bridgeRequest(params);
+    }
+    _handleConnected(accountInfo, options = { emit: true }) {
+        var _a;
+        this._accountInfo = accountInfo;
+        if (options.emit && this.isConnectionStatusChanged('connected')) {
+            this.connectionStatus = 'connected';
+            const address = (_a = accountInfo.address) !== null && _a !== void 0 ? _a : null;
+            this.emit('connect', address);
+            this.emit('accountChanged', address);
+        }
+    }
+    _handleDisconnected(options = { emit: true }) {
+        this._accountInfo = null;
+        if (options.emit && this.isConnectionStatusChanged('disconnected')) {
+            this.connectionStatus = 'disconnected';
+            this.emit('disconnect');
+            this.emit('accountChanged', null);
+        }
+    }
+    isAccountsChanged(accountInfo) {
+        var _a;
+        return (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.address) !== ((_a = this._accountInfo) === null || _a === void 0 ? void 0 : _a.address);
+    }
+    // trigger by bridge account change event
+    _handleAccountChange(payload) {
+        const accountInfo = payload;
+        if (this.isAccountsChanged(accountInfo)) {
+            this.emit('accountChanged', (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.address) || null);
+        }
+        if (!accountInfo) {
+            this._handleDisconnected();
+            return;
+        }
+        this._handleConnected(accountInfo, { emit: false });
+    }
+    isNetworkChanged(network) {
+        return this._network === undefined || network !== this._network;
+    }
+    _connect(protocolVersion, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = Date.now();
+            const isGetTonAddr = !message || (message && message.items.some((item) => item.name === 'ton_addr'));
+            const proofItem = message &&
+                message.items.find((item) => item.name === 'ton_proof');
+            const items = [];
+            if (isGetTonAddr) {
+                if (this._accountInfo) {
+                    items.push(Object.assign({ name: 'ton_addr' }, this._accountInfo));
+                }
+                else {
+                    let result;
+                    try {
+                        result = yield this._callBridge({
+                            method: 'connect',
+                            params: protocolVersion && message ? [protocolVersion, message] : [],
+                        });
+                    }
+                    catch (error) {
+                        const { code, message } = error;
+                        if (code === 4001) {
+                            return {
+                                event: 'connect_error',
+                                id,
+                                payload: {
+                                    code: protocol_1.CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR,
+                                    message: types_1.ConnectEventErrorMessage.USER_DECLINED,
+                                },
+                            };
+                        }
+                        else if (code === TonResponseError.InvalidManifestUrl || code === TonResponseError.ContentManifest) {
+                            return {
+                                event: 'connect_error',
+                                id,
+                                payload: {
+                                    code,
+                                    message: message !== null && message !== void 0 ? message : "",
+                                },
+                            };
+                        }
+                    }
+                    if (!result) {
+                        return {
+                            event: 'connect_error',
+                            id,
+                            payload: {
+                                code: protocol_1.CONNECT_EVENT_ERROR_CODES.UNKNOWN_ERROR,
+                                message: types_1.ConnectEventErrorMessage.UNKNOWN_ERROR,
+                            },
+                        };
+                    }
+                    items.push(Object.assign({ name: 'ton_addr' }, result));
+                    this._handleConnected(result, { emit: true });
+                }
+            }
+            if (proofItem) {
+                let result;
+                try {
+                    result = yield this._callBridge({
+                        method: 'signProof',
+                        params: [
+                            {
+                                payload: proofItem.payload,
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    const { code } = error;
+                    if (code === 4001) {
+                        return {
+                            event: 'connect_error',
+                            id,
+                            payload: {
+                                code: protocol_1.CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR,
+                                message: types_1.ConnectEventErrorMessage.USER_DECLINED,
+                            },
+                        };
+                    }
+                }
+                if (!result) {
+                    return {
+                        event: 'connect_error',
+                        id,
+                        payload: {
+                            code: protocol_1.CONNECT_EVENT_ERROR_CODES.UNKNOWN_ERROR,
+                            message: types_1.ConnectEventErrorMessage.UNKNOWN_ERROR,
+                        },
+                    };
+                }
+                items.push({
+                    name: 'ton_proof',
+                    proof: Object.assign(Object.assign({}, result), { payload: proofItem.payload }),
+                });
+            }
+            return {
+                event: 'connect',
+                id,
+                payload: {
+                    items,
+                    device: this.deviceInfo,
+                },
+            };
+        });
+    }
+    connect(protocolVersion, message) {
+        try {
+            return this._connect(protocolVersion, message);
+        }
+        catch (error) {
+            console.error('=====>>>>> connect error', error);
+            throw error;
+        }
+    }
+    restoreConnection() {
+        return this._connect();
+    }
+    convertError(id, error, method) {
+        const { code, message } = error;
+        if (code === 4001) {
+            let errorMessage = types_1.ConnectEventErrorMessage.USER_DECLINED;
+            if (method === 'sendTransaction' || method === 'signData') {
+                errorMessage = types_1.SendTransactionErrorMessage.USER_REJECTS_ERROR;
+            }
+            return {
+                id,
+                error: {
+                    code: protocol_1.SEND_TRANSACTION_ERROR_CODES.USER_REJECTS_ERROR,
+                    message: errorMessage,
+                },
+            };
+        }
+        else if (code === TonResponseError.ParameterError) {
+            return {
+                id,
+                error: {
+                    code: protocol_1.SEND_TRANSACTION_ERROR_CODES.BAD_REQUEST_ERROR,
+                    message: message,
+                },
+            };
+        }
+        else {
+            return {
+                id,
+                error: {
+                    code: protocol_1.SEND_TRANSACTION_ERROR_CODES.UNKNOWN_APP_ERROR,
+                    message: message !== null && message !== void 0 ? message : '',
+                },
+            };
+        }
+    }
+    send(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = message.id;
+            let res;
+            try {
+                const params = message.params.map((p) => {
+                    if (typeof p === 'string') {
+                        return JSON.parse(p);
+                    }
+                    return p;
+                });
+                if (message.method === 'sendTransaction') {
+                    res = yield this._sendTransaction(params[0]);
+                }
+                else if (message.method === 'signData') {
+                    res = yield this._signData(params[0]);
+                }
+                else if (message.method === 'disconnect') {
+                    yield this._disconnect();
+                    // @ts-expect-error
+                    return;
+                }
+                else {
+                    return {
+                        id,
+                        error: {
+                            code: protocol_1.SEND_TRANSACTION_ERROR_CODES.METHOD_NOT_SUPPORTED,
+                            message: types_1.SendTransactionErrorMessage.METHOD_NOT_SUPPORTED,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                return this.convertError(id, error, message.method);
+            }
+            if (res === undefined) {
+                return {
+                    id,
+                    error: {
+                        code: protocol_1.SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR,
+                        message: types_1.SendTransactionErrorMessage.UNKNOWN_ERROR,
+                    },
+                };
+            }
+            return {
+                id,
+                result: res,
+            };
+        });
+    }
+    _sendTransaction(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._callBridge({
+                method: 'sendTransaction',
+                params: [request],
+            });
+        });
+    }
+    _signData(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this._callBridge({
+                method: 'signData',
+                params: [request],
+            });
+            return res;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._disconnect();
+        });
+    }
+    _disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._callBridge({
+                method: 'disconnect',
+                params: [],
+            });
+            this._handleDisconnected({ emit: true });
+        });
+    }
+    listen(callback) {
+        super.on('event', callback);
+    }
+}
+exports.ProviderTon = ProviderTon;

package/dist/cjs/ProviderTonBase.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderTonBase = 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 ProviderTonBase extends cross_inpage_provider_core_1.ProviderBase {
+    constructor(props) {
+        super(props);
+        this.providerName = cross_inpage_provider_types_1.IInjectedProviderNames.ton;
+    }
+    request(data) {
+        return this.bridgeRequest(data);
+    }
+}
+exports.ProviderTonBase = ProviderTonBase;

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("./types"), exports);
+__exportStar(require("./OnetokenTonProvider"), exports);
+__exportStar(require("./ProviderTonBase"), exports);

package/dist/cjs/type-utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendTransactionErrorMessage = exports.ConnectEventErrorMessage = void 0;
+var ConnectEventErrorMessage;
+(function (ConnectEventErrorMessage) {
+    ConnectEventErrorMessage["UNKNOWN_ERROR"] = "Unknown error";
+    ConnectEventErrorMessage["BAD_REQUEST"] = "Bad request";
+    ConnectEventErrorMessage["APP_MANIFEST_NOT_FOUND"] = "App manifest not found";
+    ConnectEventErrorMessage["APP_MANIFEST_CONTENT_ERROR"] = "App manifest content error";
+    ConnectEventErrorMessage["UNKNOWN_APP"] = "Unknown app";
+    ConnectEventErrorMessage["USER_DECLINED"] = "User declined the connection";
+})(ConnectEventErrorMessage || (exports.ConnectEventErrorMessage = ConnectEventErrorMessage = {}));
+var SendTransactionErrorMessage;
+(function (SendTransactionErrorMessage) {
+    SendTransactionErrorMessage["UNKNOWN_ERROR"] = "Unknown error";
+    SendTransactionErrorMessage["BAD_REQUEST_ERROR"] = "Bad request";
+    SendTransactionErrorMessage["UNKNOWN_APP_ERROR"] = "Unknown app";
+    SendTransactionErrorMessage["USER_REJECTS_ERROR"] = "User declined the transaction";
+    SendTransactionErrorMessage["METHOD_NOT_SUPPORTED"] = "Method is not supported";
+})(SendTransactionErrorMessage || (exports.SendTransactionErrorMessage = SendTransactionErrorMessage = {}));

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './OnetokenTonProvider';
+export * from './ProviderTonBase';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './OnetokenTonProvider';
+export * from './ProviderTonBase';

package/dist/type-utils.d.ts

@@ -0,0 +1,4 @@
+export type WireStringified<T> = T extends Array<infer P> ? Array<WireStringified<P>> : T extends object ? {
+    [K in keyof T]: WireStringified<T[K]>;
+} : T;
+export type ResolvePromise<T> = T extends Promise<infer P> ? P : T;

package/dist/type-utils.js

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

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+import { CHAIN } from "@tonconnect/protocol";
+export declare enum ConnectEventErrorMessage {
+    UNKNOWN_ERROR = "Unknown error",
+    BAD_REQUEST = "Bad request",
+    APP_MANIFEST_NOT_FOUND = "App manifest not found",
+    APP_MANIFEST_CONTENT_ERROR = "App manifest content error",
+    UNKNOWN_APP = "Unknown app",
+    USER_DECLINED = "User declined the connection"
+}
+export interface WalletInfo {
+    name: string;
+    image: string;
+    tondns?: string;
+    about_url: string;
+}
+export declare enum SendTransactionErrorMessage {
+    UNKNOWN_ERROR = "Unknown error",
+    BAD_REQUEST_ERROR = "Bad request",
+    UNKNOWN_APP_ERROR = "Unknown app",
+    USER_REJECTS_ERROR = "User declined the transaction",
+    METHOD_NOT_SUPPORTED = "Method is not supported"
+}
+export interface AccountInfo {
+    address: string;
+    network: CHAIN;
+    publicKey: string;
+    walletStateInit: string;
+}
+export interface Message {
+    address: string;
+    amount: string;
+    payload?: string;
+    stateInit?: string;
+}
+export interface TransactionRequest {
+    valid_until?: number;
+    network?: CHAIN;
+    from?: string;
+    messages: Message[];
+}
+export interface SignDataRequest {
+    schema_crc: number;
+    cell: string;
+    publicKey?: string;
+}
+export interface SignDataResult {
+    signature: string;
+    timestamp: number;
+}
+export interface SignProofRequest {
+    payload: string;
+}
+export interface SignProofResult {
+    signature: string;
+    timestamp: number;
+    domain: {
+        lengthBytes: number;
+        value: string;
+    };
+}

package/dist/types.js

@@ -0,0 +1,17 @@
+export var ConnectEventErrorMessage;
+(function (ConnectEventErrorMessage) {
+    ConnectEventErrorMessage["UNKNOWN_ERROR"] = "Unknown error";
+    ConnectEventErrorMessage["BAD_REQUEST"] = "Bad request";
+    ConnectEventErrorMessage["APP_MANIFEST_NOT_FOUND"] = "App manifest not found";
+    ConnectEventErrorMessage["APP_MANIFEST_CONTENT_ERROR"] = "App manifest content error";
+    ConnectEventErrorMessage["UNKNOWN_APP"] = "Unknown app";
+    ConnectEventErrorMessage["USER_DECLINED"] = "User declined the connection";
+})(ConnectEventErrorMessage || (ConnectEventErrorMessage = {}));
+export var SendTransactionErrorMessage;
+(function (SendTransactionErrorMessage) {
+    SendTransactionErrorMessage["UNKNOWN_ERROR"] = "Unknown error";
+    SendTransactionErrorMessage["BAD_REQUEST_ERROR"] = "Bad request";
+    SendTransactionErrorMessage["UNKNOWN_APP_ERROR"] = "Unknown app";
+    SendTransactionErrorMessage["USER_REJECTS_ERROR"] = "User declined the transaction";
+    SendTransactionErrorMessage["METHOD_NOT_SUPPORTED"] = "Method is not supported";
+})(SendTransactionErrorMessage || (SendTransactionErrorMessage = {}));

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@1tokenfe/onetoken-ton-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",
+    "@tonconnect/protocol": "^2.3.0"
+  },
+  "gitHead": "dadd71e7e07ab7aaf87961aecc01255586848e16"
+}