@onekeyfe/onekey-polkadot-provider 1.1.28 → 1.1.30

package/dist/OnekeyPolkadotProvider.d.ts

@@ -1,8 +1,9 @@
 import type { IInpageProviderConfig } from '@onekeyfe/cross-inpage-provider-core';
 import { ProviderPolkadotBase } from './ProviderPolkadotBase';
 import type { IJsonRpcRequest } from '@onekeyfe/cross-inpage-provider-types';
-import { Unsubcall, InjectedAccount } from '@polkadot/extension-inject/types';
-import { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from './types';
+import type { JsonRpcResponse } from '@polkadot/rpc-provider/types';
+import { Unsubcall, InjectedAccount, ProviderList, ProviderMeta } from '@polkadot/extension-inject/types';
+import { RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, SignerPayloadJSON, SignerPayloadRaw, SignerResult } from './types';
 declare const PROVIDER_EVENTS: {
     readonly connect: "connect";
     readonly disconnect: "disconnect";
@@ -21,6 +22,12 @@ export declare type PolkadotRequest = {
     'web3AccountsSubscribe': (cb: (accounts: InjectedAccount[]) => any) => Promise<Unsubcall>;
     'web3SignPayload': (payload: SignerPayloadJSON) => Promise<SignerResult>;
     'web3SignRaw': (payload: SignerPayloadRaw) => Promise<SignerResult>;
+    'web3RpcSubscribe': (payload: RequestRpcSubscribe, cb: (cb: JsonRpcResponse<unknown>) => void) => Promise<string | number>;
+    'web3RpcUnSubscribe': () => Promise<boolean>;
+    'web3RpcSubscribeConnected': (cb: (connected: boolean) => void) => boolean;
+    'web3RpcSend': (payload: RequestRpcSend) => Promise<JsonRpcResponse<unknown>>;
+    'web3RpcListProviders': () => Promise<ProviderList>;
+    'web3RpcStartProvider': (payload: string) => Promise<ProviderMeta>;
 };
 export declare type PROVIDER_EVENTS_STRINGS = keyof typeof PROVIDER_EVENTS;
 export interface IProviderPolkadot {
@@ -30,6 +37,12 @@ export interface IProviderPolkadot {
     web3AccountsSubscribe: (cb: (accounts: InjectedAccount[]) => any) => Unsubcall;
     web3SignPayload: (payload: SignerPayloadJSON) => Promise<SignerResult>;
     web3SignRaw: (payload: SignerPayloadRaw) => Promise<SignerResult>;
+    web3RpcSubscribe: (payload: RequestRpcSubscribe, cb: (accounts: JsonRpcResponse<unknown>) => void) => Promise<string | number>;
+    web3RpcUnSubscribe: (payload: RequestRpcUnsubscribe) => Promise<boolean>;
+    web3RpcSubscribeConnected: (cb: (connected: boolean) => void) => boolean;
+    web3RpcSend: (payload: RequestRpcSend) => Promise<JsonRpcResponse<unknown>>;
+    web3RpcListProviders: () => Promise<ProviderList>;
+    web3RpcStartProvider: (payload: string) => Promise<ProviderMeta>;
 }
 export declare type OneKeyPolkadotProviderProps = IInpageProviderConfig & {
     timeout?: number;
@@ -48,11 +61,22 @@ declare class ProviderPolkadot extends ProviderPolkadotBase implements IProvider
     isConnected(): boolean;
     on<E extends keyof CosmosProviderEventsMap>(event: E, listener: CosmosProviderEventsMap[E]): this;
     emit<E extends keyof CosmosProviderEventsMap>(event: E, ...args: Parameters<CosmosProviderEventsMap[E]>): boolean;
+    private createMessage;
+    private _postMessage;
+    postRequest(payload: any): void;
+    postResponse(payload: any): void;
+    postError(payload: string): void;
     web3Enable(dappName: string): Promise<boolean>;
     web3Accounts(anyType?: boolean): Promise<InjectedAccount[]>;
     web3AccountsSubscribe(cb: (accounts: InjectedAccount[]) => any): Unsubcall;
     web3SignPayload(payload: SignerPayloadJSON): Promise<SignerResult>;
     web3SignRaw(payload: SignerPayloadRaw): Promise<SignerResult>;
+    web3RpcSubscribe(payload: RequestRpcSubscribe, cb: (accounts: JsonRpcResponse<unknown>) => void): Promise<string | number>;
+    web3RpcUnSubscribe(): Promise<boolean>;
+    web3RpcSubscribeConnected(cb: (connected: boolean) => void): boolean;
+    web3RpcSend(payload: RequestRpcSend): Promise<JsonRpcResponse<unknown>>;
+    web3RpcListProviders(): Promise<ProviderList>;
+    web3RpcStartProvider(payload: string): Promise<ProviderMeta>;
 }
-declare const registerPolkadot: (provider: ProviderPolkadot) => void;
+declare const registerPolkadot: (provider: ProviderPolkadot, name?: string, version?: string) => void;
 export { ProviderPolkadot, registerPolkadot };

package/dist/OnekeyPolkadotProvider.js

@@ -1,6 +1,16 @@
+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 '@onekeyfe/extension-bridge-injected';
 import { ProviderPolkadotBase } from './ProviderPolkadotBase';
 import { injectExtension } from '@polkadot/extension-inject';
+import OneKeyInjected from './inject/Injected';
 const PROVIDER_EVENTS = {
     'connect': 'connect',
     'disconnect': 'disconnect',
@@ -78,6 +88,33 @@ class ProviderPolkadot extends ProviderPolkadotBase {
     emit(event, ...args) {
         return super.emit(event, ...args);
     }
+    createMessage(payload) {
+        return Object.assign({ id: 2, origin: 'OneKey Polkadot Provider' }, payload);
+    }
+    _postMessage(payload) {
+        try {
+            const message = this.createMessage(payload);
+            window.postMessage(message);
+        }
+        catch (error) {
+            // ignore
+        }
+    }
+    postRequest(payload) {
+        this._postMessage({
+            request: payload,
+        });
+    }
+    postResponse(payload) {
+        this._postMessage({
+            response: payload,
+        });
+    }
+    postError(payload) {
+        this._postMessage({
+            error: payload,
+        });
+    }
     web3Enable(dappName) {
         return this._callBridge({
             method: 'web3Enable',
@@ -97,48 +134,92 @@ class ProviderPolkadot extends ProviderPolkadotBase {
         };
     }
     web3SignPayload(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.postRequest(payload);
+                const result = yield this._callBridge({
+                    method: 'web3SignPayload',
+                    params: payload,
+                });
+                this.postResponse({
+                    id: 1,
+                    origin: 'OneKey Polkadot Provider',
+                    signature: result.signature,
+                });
+                return result;
+            }
+            catch (error) {
+                this.postError('Cancelled');
+                return Promise.reject('Cancelled');
+            }
+        });
+    }
+    web3SignRaw(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.postRequest(payload);
+                const result = yield this._callBridge({
+                    method: 'web3SignRaw',
+                    params: payload,
+                });
+                this.postResponse({
+                    id: 1,
+                    origin: 'OneKey Polkadot Provider',
+                    signature: result.signature,
+                });
+                return result;
+            }
+            catch (error) {
+                this.postError('Cancelled');
+                return Promise.reject('Cancelled');
+            }
+        });
+    }
+    web3RpcSubscribe(payload, cb) {
         return this._callBridge({
-            method: 'web3SignPayload',
+            method: 'web3RpcSubscribe',
             params: payload,
         });
     }
-    web3SignRaw(payload) {
+    web3RpcUnSubscribe() {
+        super.removeAllListeners();
         return this._callBridge({
-            method: 'web3SignRaw',
+            method: 'web3RpcUnSubscribe',
+            params: undefined,
+        });
+    }
+    web3RpcSubscribeConnected(cb) {
+        cb(this.isConnected());
+        super.on(PROVIDER_EVENTS.connect, cb);
+        super.on(PROVIDER_EVENTS.disconnect, cb);
+        return true;
+    }
+    web3RpcSend(payload) {
+        return this._callBridge({
+            method: 'web3RpcSend',
+            params: payload,
+        });
+    }
+    web3RpcListProviders() {
+        return this._callBridge({
+            method: 'web3RpcListProviders',
+            params: undefined,
+        });
+    }
+    web3RpcStartProvider(payload) {
+        return this._callBridge({
+            method: 'web3RpcStartProvider',
             params: payload,
         });
     }
 }
-const registerPolkadot = (provider) => {
+const registerPolkadot = (provider, name = 'OneKey', version = '1.0.0') => {
     try {
-        const enableFn = (originName) => {
-            return provider.web3Enable(originName).then((res) => {
-                if (!res) {
-                    throw new Error('not support');
-                }
-                return {
-                    accounts: {
-                        get: (anyType) => {
-                            return provider.web3Accounts(anyType);
-                        },
-                        subscribe: (cb) => {
-                            return provider.web3AccountsSubscribe(cb);
-                        },
-                    },
-                    metadata: undefined,
-                    provider: undefined,
-                    signer: {
-                        signPayload: (message) => {
-                            return provider.web3SignPayload(message);
-                        },
-                        signRaw: (message) => {
-                            return provider.web3SignRaw(message);
-                        },
-                    },
-                };
-            });
-        };
-        injectExtension(enableFn, { name: 'OneKey', version: '1.0.0' });
+        const enableFn = (originName) => __awaiter(void 0, void 0, void 0, function* () {
+            yield provider.web3Enable(originName);
+            return new OneKeyInjected(provider);
+        });
+        injectExtension(enableFn, { name: name !== null && name !== void 0 ? name : 'OneKey', version: version !== null && version !== void 0 ? version : '1.0.0' });
     }
     catch (error) {
         console.error(error);

package/dist/cjs/OnekeyPolkadotProvider.js

@@ -1,9 +1,22 @@
 "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.registerPolkadot = exports.ProviderPolkadot = void 0;
 const extension_bridge_injected_1 = require("@onekeyfe/extension-bridge-injected");
 const ProviderPolkadotBase_1 = require("./ProviderPolkadotBase");
 const extension_inject_1 = require("@polkadot/extension-inject");
+const Injected_1 = __importDefault(require("./inject/Injected"));
 const PROVIDER_EVENTS = {
     'connect': 'connect',
     'disconnect': 'disconnect',
@@ -81,6 +94,33 @@ class ProviderPolkadot extends ProviderPolkadotBase_1.ProviderPolkadotBase {
     emit(event, ...args) {
         return super.emit(event, ...args);
     }
+    createMessage(payload) {
+        return Object.assign({ id: 2, origin: 'OneKey Polkadot Provider' }, payload);
+    }
+    _postMessage(payload) {
+        try {
+            const message = this.createMessage(payload);
+            window.postMessage(message);
+        }
+        catch (error) {
+            // ignore
+        }
+    }
+    postRequest(payload) {
+        this._postMessage({
+            request: payload,
+        });
+    }
+    postResponse(payload) {
+        this._postMessage({
+            response: payload,
+        });
+    }
+    postError(payload) {
+        this._postMessage({
+            error: payload,
+        });
+    }
     web3Enable(dappName) {
         return this._callBridge({
             method: 'web3Enable',
@@ -100,49 +140,93 @@ class ProviderPolkadot extends ProviderPolkadotBase_1.ProviderPolkadotBase {
         };
     }
     web3SignPayload(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.postRequest(payload);
+                const result = yield this._callBridge({
+                    method: 'web3SignPayload',
+                    params: payload,
+                });
+                this.postResponse({
+                    id: 1,
+                    origin: 'OneKey Polkadot Provider',
+                    signature: result.signature,
+                });
+                return result;
+            }
+            catch (error) {
+                this.postError('Cancelled');
+                return Promise.reject('Cancelled');
+            }
+        });
+    }
+    web3SignRaw(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.postRequest(payload);
+                const result = yield this._callBridge({
+                    method: 'web3SignRaw',
+                    params: payload,
+                });
+                this.postResponse({
+                    id: 1,
+                    origin: 'OneKey Polkadot Provider',
+                    signature: result.signature,
+                });
+                return result;
+            }
+            catch (error) {
+                this.postError('Cancelled');
+                return Promise.reject('Cancelled');
+            }
+        });
+    }
+    web3RpcSubscribe(payload, cb) {
         return this._callBridge({
-            method: 'web3SignPayload',
+            method: 'web3RpcSubscribe',
             params: payload,
         });
     }
-    web3SignRaw(payload) {
+    web3RpcUnSubscribe() {
+        super.removeAllListeners();
+        return this._callBridge({
+            method: 'web3RpcUnSubscribe',
+            params: undefined,
+        });
+    }
+    web3RpcSubscribeConnected(cb) {
+        cb(this.isConnected());
+        super.on(PROVIDER_EVENTS.connect, cb);
+        super.on(PROVIDER_EVENTS.disconnect, cb);
+        return true;
+    }
+    web3RpcSend(payload) {
+        return this._callBridge({
+            method: 'web3RpcSend',
+            params: payload,
+        });
+    }
+    web3RpcListProviders() {
         return this._callBridge({
-            method: 'web3SignRaw',
+            method: 'web3RpcListProviders',
+            params: undefined,
+        });
+    }
+    web3RpcStartProvider(payload) {
+        return this._callBridge({
+            method: 'web3RpcStartProvider',
             params: payload,
         });
     }
 }
 exports.ProviderPolkadot = ProviderPolkadot;
-const registerPolkadot = (provider) => {
+const registerPolkadot = (provider, name = 'OneKey', version = '1.0.0') => {
     try {
-        const enableFn = (originName) => {
-            return provider.web3Enable(originName).then((res) => {
-                if (!res) {
-                    throw new Error('not support');
-                }
-                return {
-                    accounts: {
-                        get: (anyType) => {
-                            return provider.web3Accounts(anyType);
-                        },
-                        subscribe: (cb) => {
-                            return provider.web3AccountsSubscribe(cb);
-                        },
-                    },
-                    metadata: undefined,
-                    provider: undefined,
-                    signer: {
-                        signPayload: (message) => {
-                            return provider.web3SignPayload(message);
-                        },
-                        signRaw: (message) => {
-                            return provider.web3SignRaw(message);
-                        },
-                    },
-                };
-            });
-        };
-        (0, extension_inject_1.injectExtension)(enableFn, { name: 'OneKey', version: '1.0.0' });
+        const enableFn = (originName) => __awaiter(void 0, void 0, void 0, function* () {
+            yield provider.web3Enable(originName);
+            return new Injected_1.default(provider);
+        });
+        (0, extension_inject_1.injectExtension)(enableFn, { name: name !== null && name !== void 0 ? name : 'OneKey', version: version !== null && version !== void 0 ? version : '1.0.0' });
     }
     catch (error) {
         console.error(error);

package/dist/cjs/inject/Accounts.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class default_1 {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    get(anyType) {
+        return this.provider.web3Accounts(anyType);
+    }
+    subscribe(cb) {
+        return this.provider.web3AccountsSubscribe(cb);
+    }
+}
+exports.default = default_1;

package/dist/cjs/inject/Injected.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Signer_1 = __importDefault(require("./Signer"));
+const Accounts_1 = __importDefault(require("./Accounts"));
+class default_1 {
+    constructor(provider) {
+        this.accounts = new Accounts_1.default(provider);
+        this.metadata = undefined;
+        this.provider = undefined;
+        this.signer = new Signer_1.default(provider);
+    }
+}
+exports.default = default_1;

package/dist/cjs/inject/MessageProvider.js

@@ -0,0 +1,136 @@
+"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 });
+const eventemitter3_1 = require("eventemitter3");
+function isUndefined(value) {
+    return value === undefined;
+}
+class MessageProvider {
+    constructor(provider) {
+        this.provider = provider;
+        // Whether or not the actual extension background provider is connected
+        this._isConnected = false;
+        // Subscription IDs are (historically) not guaranteed to be globally unique;
+        // only unique for a given subscription method; which is why we identify
+        // the subscriptions based on subscription id + type
+        this._subscriptions = {};
+        this._eventemitter = new eventemitter3_1.EventEmitter();
+    }
+    get isClonable() {
+        return true;
+    }
+    clone() {
+        return new MessageProvider(this.provider);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // FIXME This should see if the extension's state's provider can disconnect
+            console.error('PostMessageProvider.disconnect() is not implemented.');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // FIXME This should see if the extension's state's provider can disconnect
+            console.error('PostMessageProvider.disconnect() is not implemented.');
+        });
+    }
+    get hasSubscriptions() {
+        // FIXME This should see if the extension's state's provider has subscriptions
+        return true;
+    }
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected() {
+        return this._isConnected;
+    }
+    listProviders() {
+        return this.provider.web3RpcListProviders();
+    }
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type, sub) {
+        this._eventemitter.on(type, sub);
+        return () => {
+            this._eventemitter.removeListener(type, sub);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    send(method, params, _, subscription) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (subscription) {
+                const { callback, type } = subscription;
+                const id = yield this.provider.web3RpcSubscribe({ method, params, type }, (res) => {
+                    subscription.callback(null, res);
+                });
+                // const id = await sendRequest('pub(rpc.subscribe)', { method, params, type }, (res): void => {
+                //   subscription.callback(null, res);
+                // });
+                this._subscriptions[`${type}::${id}`] = callback;
+                return id;
+            }
+            return this.provider.web3RpcSend({ method, params });
+        });
+    }
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    startProvider(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Disconnect from the previous provider
+            this._isConnected = false;
+            this._eventemitter.emit('disconnected');
+            // const meta = await sendRequest('pub(rpc.startProvider)', key);
+            const meta = yield this.provider.web3RpcStartProvider(key);
+            this.provider.web3RpcSubscribeConnected((connected) => {
+                this._isConnected = connected;
+                if (connected) {
+                    this._eventemitter.emit('connected');
+                }
+                else {
+                    this._eventemitter.emit('disconnected');
+                }
+                return true;
+            });
+            return meta;
+        });
+    }
+    subscribe(type, method, params, callback) {
+        return this.send(method, params, false, { callback, type });
+    }
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type, method, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscription = `${type}::${id}`;
+            // FIXME This now could happen with re-subscriptions. The issue is that with a re-sub
+            // the assigned id now does not match what the API user originally received. It has
+            // a slight complication in solving - since we cannot rely on the send id, but rather
+            // need to find the actual subscription id to map it
+            if (isUndefined(this._subscriptions[subscription])) {
+                console.debug(`Unable to find active subscription=${subscription}`);
+                return false;
+            }
+            delete this._subscriptions[subscription];
+            yield this.provider.web3RpcUnSubscribe();
+            return this.send(method, [id]);
+        });
+    }
+}
+exports.default = MessageProvider;

package/dist/cjs/inject/Signer.js

@@ -0,0 +1,27 @@
+"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 });
+class Signer {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    signPayload(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.web3SignPayload(payload);
+        });
+    }
+    signRaw(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.web3SignRaw(payload);
+        });
+    }
+}
+exports.default = Signer;

package/dist/inject/Accounts.d.ts

@@ -0,0 +1,9 @@
+import { Unsubcall, InjectedAccount } from '@polkadot/extension-inject/types';
+import type { InjectedAccounts } from '@polkadot/extension-inject/types';
+import { ProviderPolkadot } from '../OnekeyPolkadotProvider';
+export default class implements InjectedAccounts {
+    private provider;
+    constructor(provider: ProviderPolkadot);
+    get(anyType?: boolean): Promise<InjectedAccount[]>;
+    subscribe(cb: (accounts: InjectedAccount[]) => unknown): Unsubcall;
+}

package/dist/inject/Accounts.js

@@ -0,0 +1,11 @@
+export default class {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    get(anyType) {
+        return this.provider.web3Accounts(anyType);
+    }
+    subscribe(cb) {
+        return this.provider.web3AccountsSubscribe(cb);
+    }
+}

package/dist/inject/Injected.d.ts

@@ -0,0 +1,11 @@
+import { ProviderPolkadot } from '../OnekeyPolkadotProvider';
+import Signer from './Signer';
+import type { Injected, InjectedMetadata, InjectedProvider } from '@polkadot/extension-inject/types';
+import Accounts from './Accounts';
+export default class implements Injected {
+    readonly accounts: Accounts;
+    readonly metadata: InjectedMetadata | undefined;
+    readonly provider: InjectedProvider | undefined;
+    readonly signer: Signer;
+    constructor(provider: ProviderPolkadot);
+}

package/dist/inject/Injected.js

@@ -0,0 +1,10 @@
+import Signer from './Signer';
+import Accounts from './Accounts';
+export default class {
+    constructor(provider) {
+        this.accounts = new Accounts(provider);
+        this.metadata = undefined;
+        this.provider = undefined;
+        this.signer = new Signer(provider);
+    }
+}

package/dist/inject/MessageProvider.d.ts

@@ -0,0 +1,46 @@
+import type { InjectedProvider, ProviderList, ProviderMeta } from '@polkadot/extension-inject/types';
+import type { ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import { EventEmitter } from 'eventemitter3';
+import { ProviderPolkadot } from '../OnekeyPolkadotProvider';
+declare type CallbackHandler = (error?: null | Error, value?: unknown) => void;
+declare type AnyFunction = (...args: any[]) => any;
+interface SubscriptionHandler {
+    callback: CallbackHandler;
+    type: string;
+}
+export default class MessageProvider implements InjectedProvider {
+    private provider;
+    readonly _eventemitter: EventEmitter;
+    _isConnected: boolean;
+    readonly _subscriptions: Record<string, AnyFunction>;
+    constructor(provider: ProviderPolkadot);
+    get isClonable(): boolean;
+    clone(): MessageProvider;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get hasSubscriptions(): boolean;
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected(): boolean;
+    listProviders(): Promise<ProviderList>;
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send(method: string, params: unknown[], _?: boolean, subscription?: SubscriptionHandler): Promise<any>;
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    startProvider(key: string): Promise<ProviderMeta>;
+    subscribe(type: string, method: string, params: unknown[], callback: AnyFunction): Promise<number>;
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type: string, method: string, id: number): Promise<boolean>;
+}
+export {};

package/dist/inject/MessageProvider.js

@@ -0,0 +1,133 @@
+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 { EventEmitter } from 'eventemitter3';
+function isUndefined(value) {
+    return value === undefined;
+}
+export default class MessageProvider {
+    constructor(provider) {
+        this.provider = provider;
+        // Whether or not the actual extension background provider is connected
+        this._isConnected = false;
+        // Subscription IDs are (historically) not guaranteed to be globally unique;
+        // only unique for a given subscription method; which is why we identify
+        // the subscriptions based on subscription id + type
+        this._subscriptions = {};
+        this._eventemitter = new EventEmitter();
+    }
+    get isClonable() {
+        return true;
+    }
+    clone() {
+        return new MessageProvider(this.provider);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // FIXME This should see if the extension's state's provider can disconnect
+            console.error('PostMessageProvider.disconnect() is not implemented.');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // FIXME This should see if the extension's state's provider can disconnect
+            console.error('PostMessageProvider.disconnect() is not implemented.');
+        });
+    }
+    get hasSubscriptions() {
+        // FIXME This should see if the extension's state's provider has subscriptions
+        return true;
+    }
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected() {
+        return this._isConnected;
+    }
+    listProviders() {
+        return this.provider.web3RpcListProviders();
+    }
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type, sub) {
+        this._eventemitter.on(type, sub);
+        return () => {
+            this._eventemitter.removeListener(type, sub);
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    send(method, params, _, subscription) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (subscription) {
+                const { callback, type } = subscription;
+                const id = yield this.provider.web3RpcSubscribe({ method, params, type }, (res) => {
+                    subscription.callback(null, res);
+                });
+                // const id = await sendRequest('pub(rpc.subscribe)', { method, params, type }, (res): void => {
+                //   subscription.callback(null, res);
+                // });
+                this._subscriptions[`${type}::${id}`] = callback;
+                return id;
+            }
+            return this.provider.web3RpcSend({ method, params });
+        });
+    }
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    startProvider(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Disconnect from the previous provider
+            this._isConnected = false;
+            this._eventemitter.emit('disconnected');
+            // const meta = await sendRequest('pub(rpc.startProvider)', key);
+            const meta = yield this.provider.web3RpcStartProvider(key);
+            this.provider.web3RpcSubscribeConnected((connected) => {
+                this._isConnected = connected;
+                if (connected) {
+                    this._eventemitter.emit('connected');
+                }
+                else {
+                    this._eventemitter.emit('disconnected');
+                }
+                return true;
+            });
+            return meta;
+        });
+    }
+    subscribe(type, method, params, callback) {
+        return this.send(method, params, false, { callback, type });
+    }
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type, method, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscription = `${type}::${id}`;
+            // FIXME This now could happen with re-subscriptions. The issue is that with a re-sub
+            // the assigned id now does not match what the API user originally received. It has
+            // a slight complication in solving - since we cannot rely on the send id, but rather
+            // need to find the actual subscription id to map it
+            if (isUndefined(this._subscriptions[subscription])) {
+                console.debug(`Unable to find active subscription=${subscription}`);
+                return false;
+            }
+            delete this._subscriptions[subscription];
+            yield this.provider.web3RpcUnSubscribe();
+            return this.send(method, [id]);
+        });
+    }
+}

package/dist/inject/Signer.d.ts

@@ -0,0 +1,8 @@
+import { ProviderPolkadot } from '../OnekeyPolkadotProvider';
+import { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from '../types';
+export default class Signer {
+    private provider;
+    constructor(provider: ProviderPolkadot);
+    signPayload(payload: SignerPayloadJSON): Promise<SignerResult>;
+    signRaw(payload: SignerPayloadRaw): Promise<SignerResult>;
+}

package/dist/inject/Signer.js

@@ -0,0 +1,24 @@
+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());
+    });
+};
+export default class Signer {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    signPayload(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.web3SignPayload(payload);
+        });
+    }
+    signRaw(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.web3SignRaw(payload);
+        });
+    }
+}

package/dist/types.d.ts

@@ -78,3 +78,15 @@ export interface SignerResult {
      */
     signature: `0x${string}`;
 }
+export interface RequestRpcSend {
+    method: string;
+    params: unknown[];
+}
+export interface RequestRpcSubscribe extends RequestRpcSend {
+    type: string;
+}
+export interface RequestRpcUnsubscribe {
+    type: string;
+    method: string;
+    id: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/onekey-polkadot-provider",
-  "version": "1.1.28",
+  "version": "1.1.30",
   "keywords": [
     "cross-inpage-provider"
   ],
@@ -28,15 +28,15 @@
     "start": "tsc --watch"
   },
   "dependencies": {
-    "@noble/hashes": "^1.1.4",
-    "@onekeyfe/cross-inpage-provider-core": "1.1.28",
-    "@onekeyfe/cross-inpage-provider-errors": "1.1.28",
-    "@onekeyfe/cross-inpage-provider-types": "1.1.28",
-    "@onekeyfe/extension-bridge-injected": "1.1.28",
-    "@polkadot/extension-inject": "^0.46.2",
+    "@noble/hashes": "^1.3.0",
+    "@onekeyfe/cross-inpage-provider-core": "1.1.30",
+    "@onekeyfe/cross-inpage-provider-errors": "1.1.30",
+    "@onekeyfe/cross-inpage-provider-types": "1.1.30",
+    "@onekeyfe/extension-bridge-injected": "1.1.30",
+    "@polkadot/extension-inject": "^0.46.3",
     "eth-rpc-errors": "^4.0.3",
     "long": "^5.2.1",
     "mitt": "^3.0.0"
   },
-  "gitHead": "5469ed1680c52acc985f6191bdbe2a102f848071"
+  "gitHead": "9efd9608ab6acf801f61145cc62c964941b2b340"
 }