@signumjs/wallets/out/extension/browserExtensionAdapter.js

Wallets communication package for DApps in the Signum Network

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BrowserExtensionAdapter = void 0;
const uuid_1 = require("uuid");
const messaging_1 = require("./messaging");
const errors_1 = require("./errors");
class BrowserExtensionAdapter {
    static send(msg) {
        window.postMessage(msg, '*');
    }
    static assertResponse(condition) {
        if (!condition) {
            throw new Error('Invalid response received');
        }
    }
    async assertWalletAvailable() {
        return new Promise((resolve, reject) => {
            const handleMessage = (evt) => {
                if (evt.source === window &&
                    evt.data?.type === messaging_1.PageMessageType.Response &&
                    evt.data?.payload === 'PONG') {
                    done(true);
                }
            };
            const done = (result) => {
                window.removeEventListener('message', handleMessage);
                clearTimeout(t);
                if (result) {
                    resolve();
                }
                else {
                    reject((0, errors_1.createError)(messaging_1.ExtensionErrorType.NotFound));
                }
            };
            window.addEventListener('message', handleMessage);
            BrowserExtensionAdapter.send({
                type: messaging_1.PageMessageType.Request,
                payload: 'PING',
            });
            const t = setTimeout(() => done(false), 1_000);
        });
    }
    onNotification(callback) {
        let listener;
        function handleMessage(evt) {
            if (evt.source === window
                && evt.origin === location.origin
                && typeof (evt.data.type) === 'string'
                && evt.data.type.startsWith('XT_DAPP_')) {
                callback(evt.data);
            }
        }
        window.addEventListener('message', handleMessage);
        listener = {
            unlisten: () => { window.removeEventListener('message', handleMessage); }
        };
        return listener;
    }
    async getCurrentPermission() {
        const res = await this.request({
            type: messaging_1.ExtensionMessageType.GetCurrentPermissionRequest,
        });
        BrowserExtensionAdapter.assertResponse(res.type === messaging_1.ExtensionMessageType.GetCurrentPermissionResponse);
        return res.permission;
    }
    request(payload) {
        return new Promise((resolve, reject) => {
            const reqId = (0, uuid_1.v4)();
            const handleMessage = (evt) => {
                const res = evt.data;
                if (evt.source !== window || res?.reqId !== reqId) {
                    return;
                }
                else if (res?.type === messaging_1.PageMessageType.Response) {
                    resolve(res.payload);
                    window.removeEventListener('message', handleMessage);
                }
                else if (res?.type === messaging_1.PageMessageType.ErrorResponse) {
                    reject((0, errors_1.createError)(res.payload));
                    window.removeEventListener('message', handleMessage);
                }
            };
            BrowserExtensionAdapter.send({
                type: messaging_1.PageMessageType.Request,
                payload,
                reqId,
            });
            window.addEventListener('message', handleMessage);
        });
    }
    async requestPermission(args) {
        const res = await this.request({
            type: messaging_1.ExtensionMessageType.PermissionRequest,
            network: args.network,
            appMeta: args.appMeta,
        });
        BrowserExtensionAdapter.assertResponse(res.type === messaging_1.ExtensionMessageType.PermissionResponse);
        return {
            currentNodeHost: res.currentNodeHost,
            availableNodeHosts: res.availableNodeHosts,
            accountId: res.accountId,
            publicKey: res.publicKey,
            watchOnly: res.watchOnly
        };
    }
    async requestSign(args) {
        const res = await this.request({
            type: messaging_1.ExtensionMessageType.SignRequest,
            payload: args.unsignedTransaction,
        });
        BrowserExtensionAdapter.assertResponse(res.type === messaging_1.ExtensionMessageType.SignResponse);
        return {
            transactionId: res.transactionId,
            fullHash: res.fullHash
        };
    }
    async requestSendEncryptedMessage(args) {
        const res = await this.request({
            type: messaging_1.ExtensionMessageType.SendEncryptedMessageRequest,
            ...args
        });
        BrowserExtensionAdapter.assertResponse(res.type === messaging_1.ExtensionMessageType.SendEncryptedMessageResponse);
        return {
            transactionId: res.transactionId,
            fullHash: res.fullHash
        };
    }
}
exports.BrowserExtensionAdapter = BrowserExtensionAdapter;
//# sourceMappingURL=browserExtensionAdapter.js.map