@robincore/flutter-dapp-provider/build/providers/InitProvider.js

a javascript ethereum provider injector used as an interface between wallet and dApps. [for flutter]

'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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const json_rpc_engine_1 = require("json-rpc-engine");
const eth_rpc_errors_1 = require("eth-rpc-errors");
const core_utils_1 = require("../core-utils");
const isUtf8 = __importStar(require("isutf8"));
class InitProvider extends events_1.EventEmitter {
    constructor(setup) {
        super();
        this.rpcEngine = new json_rpc_engine_1.JsonRpcEngine();
        this._initState(setup);
        this._isConnected = true;
    }
    _initState(setup) {
        this.address = setup.currentAddress;
        this.provider = setup.currentProvider;
        this.chainId = setup.chainId;
    }
    isConnected() {
        return this._isConnected;
    }
    // interact with flutter's inAppWebView handler
    _onMessage(listener, data) {
        window.coreDapp.handleThis({ listener, data });
    }
    request(args) {
        if (!args || typeof args !== 'object' || Array.isArray(args)) {
            throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({
                message: "invalid request, method cannot be empty",
                data: args,
            });
        }
        const { method, params } = args;
        if (params !== undefined &&
            !Array.isArray(params) &&
            (typeof params !== 'object' || params === null)) {
            throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({
                message: "invalid parameters passed",
                data: args,
            });
        }
        return new Promise((resolve, reject) => {
            this._rpcRequest({ method, params }, (0, core_utils_1.getRpcPromiseCallback)(resolve, reject));
        });
    }
    _rpcRequest(payload, callback) {
        let _callBack = callback;
        if (!Array.isArray(payload)) {
            if (!payload.jsonrpc) {
                payload.jsonrpc = '2.0';
            }
            if (payload.method === 'eth_accounts' ||
                payload.method === 'eth_requestAccounts') {
                // handle accounts changing
                _callBack = (err, res) => {
                    this._handleAccountsChanged(res.result || []);
                    callback(err, res);
                };
            }
            return this.rpcEngine.handle(payload, _callBack);
        }
        return this.rpcEngine.handle(payload, _callBack);
    }
    _handleAccountsChanged(accounts) {
        this.emit('accountsChanged', accounts);
        this.address = accounts[0];
    }
    // ethereum rpc calls
    eth_Accounts() {
        return this.address ? [this.address] : [];
    }
    eth_chainId() {
        return this.chainId;
    }
    eth_sign(payload) {
        const buffer = core_utils_1.CoreUtils.convertToBytes(payload[1]);
        const hex = core_utils_1.CoreUtils.payloadInHex(buffer);
        if (isUtf8.default(buffer)) {
            this._onMessage('signPersonalMessage', { data: hex });
        }
        else {
            this._onMessage('signMessage', { data: hex });
        }
    }
    handleChainChange(chainId) {
        this.emit('connect', { chainId });
        this._onChainChanged(chainId);
    }
    _onChainChanged(chainId) {
        this.emit('chainChanged', chainId); // chain change event emitter
        this.emit('networkChanged', chainId); // legacy emitter
        this.chainId = chainId;
    }
    _handleOnDisconnect() {
        this.address = undefined;
        this._isConnected = false;
        this.emit("disconnect");
    }
}
exports.default = InitProvider;
//# sourceMappingURL=InitProvider.js.map