@subwallet/extension-base 0.3.6-0

package/build/page/index.js

@@ -0,0 +1,64 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MESSAGE_ORIGIN_PAGE } from "../defaults.js";
+import { getId } from "../utils/getId.js";
+import Injected from "./Injected.js"; // when sending a message from the injector to the extension, we
+//  - create an event - this we send to the loader
+//  - the loader takes this event and uses port.postMessage to background
+//  - on response, the loader creates a reponse event
+//  - this injector, listens on the events, maps it to the original
+//  - resolves/rejects the promise with the result (or sub data)
+
+const handlers = {}; // a generic message sender that creates an event, returning a promise that will
+// resolve once the event is resolved (by the response listener just below this)
+
+export function sendMessage(message, request, subscriber) {
+  return new Promise((resolve, reject) => {
+    const id = getId();
+    handlers[id] = {
+      reject,
+      resolve,
+      subscriber
+    };
+    const transportRequestMessage = {
+      id,
+      message,
+      origin: MESSAGE_ORIGIN_PAGE,
+      request: request || null
+    };
+    window.postMessage(transportRequestMessage, '*');
+  });
+} // the enable function, called by the dapp to allow access
+
+export async function enable(origin) {
+  await sendMessage('pub(authorize.tabV2)', {
+    origin
+  });
+  return new Injected(sendMessage);
+} // redirect users if this page is considered as phishing, otherwise return false
+
+export async function redirectIfPhishing() {
+  const res = await sendMessage('pub(phishing.redirectIfDenied)');
+  return res;
+}
+export function handleResponse(data) {
+  const handler = handlers[data.id];
+
+  if (!handler) {
+    console.error(`Unknown response: ${JSON.stringify(data)}`);
+    return;
+  }
+
+  if (!handler.subscriber) {
+    delete handlers[data.id];
+  }
+
+  if (data.subscription) {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    handler.subscriber(data.subscription);
+  } else if (data.error) {
+    handler.reject(new Error(data.error));
+  } else {
+    handler.resolve(data.response);
+  }
+}

package/build/page/types.d.ts

@@ -0,0 +1,6 @@
+import type { MessageTypesWithNoSubscriptions, MessageTypesWithNullRequest, MessageTypesWithSubscriptions, RequestTypes, ResponseTypes, SubscriptionMessageTypes } from '../background/types';
+export interface SendRequest {
+    <TMessageType extends MessageTypesWithNullRequest>(message: TMessageType): Promise<ResponseTypes[TMessageType]>;
+    <TMessageType extends MessageTypesWithNoSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType]): Promise<ResponseTypes[TMessageType]>;
+    <TMessageType extends MessageTypesWithSubscriptions>(message: TMessageType, request: RequestTypes[TMessageType], subscriber: (data: SubscriptionMessageTypes[TMessageType]) => void): Promise<ResponseTypes[TMessageType]>;
+}

package/build/page/types.js

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

package/build/stores/Accounts.d.ts

@@ -0,0 +1,6 @@
+import type { KeyringJson, KeyringStore } from '@polkadot/ui-keyring/types';
+import BaseStore from './Base';
+export default class AccountsStore extends BaseStore<KeyringJson> implements KeyringStore {
+    constructor();
+    set(key: string, value: KeyringJson, update?: () => void): void;
+}

package/build/stores/Accounts.js

@@ -0,0 +1,20 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { EXTENSION_PREFIX } from "../defaults.js";
+import BaseStore from "./Base.js";
+export default class AccountsStore extends BaseStore {
+  constructor() {
+    super(EXTENSION_PREFIX ? `${EXTENSION_PREFIX}accounts` : null);
+  }
+
+  set(key, value, update) {
+    // shortcut, don't save testing accounts in extension storage
+    if (key.startsWith('account:') && value.meta && value.meta.isTesting) {
+      update && update();
+      return;
+    }
+
+    super.set(key, value, update);
+  }
+
+}

package/build/stores/Base.d.ts

@@ -0,0 +1,10 @@
+export default abstract class BaseStore<T> {
+    #private;
+    constructor(prefix: string | null);
+    getPrefix(): string;
+    all(update: (key: string, value: T) => void): void;
+    allMap(update: (value: Record<string, T>) => void): void;
+    get(_key: string, update: (value: T) => void): void;
+    remove(_key: string, update?: () => void): void;
+    set(_key: string, value: T, update?: () => void): void;
+}

package/build/stores/Base.js

@@ -0,0 +1,74 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const lastError = type => {
+  const error = chrome.runtime.lastError;
+
+  if (error) {
+    console.error(`BaseStore.${type}:: runtime.lastError:`, error);
+  }
+};
+
+export default class BaseStore {
+  #prefix;
+
+  constructor(prefix) {
+    this.#prefix = prefix ? `${prefix}:` : '';
+  }
+
+  getPrefix() {
+    return this.#prefix;
+  }
+
+  all(update) {
+    this.allMap(map => {
+      Object.entries(map).forEach(([key, value]) => {
+        update(key, value);
+      });
+    });
+  }
+
+  allMap(update) {
+    chrome.storage.local.get(null, result => {
+      lastError('all');
+      const entries = Object.entries(result);
+      const map = {};
+
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+
+        if (key.startsWith(this.#prefix)) {
+          map[key.replace(this.#prefix, '')] = value;
+        }
+      }
+
+      update(map);
+    });
+  }
+
+  get(_key, update) {
+    const key = `${this.#prefix}${_key}`;
+    chrome.storage.local.get([key], result => {
+      lastError('get');
+      update(result[key]);
+    });
+  }
+
+  remove(_key, update) {
+    const key = `${this.#prefix}${_key}`;
+    chrome.storage.local.remove(key, () => {
+      lastError('remove');
+      update && update();
+    });
+  }
+
+  set(_key, value, update) {
+    const key = `${this.#prefix}${_key}`;
+    chrome.storage.local.set({
+      [key]: value
+    }, () => {
+      lastError('set');
+      update && update();
+    });
+  }
+
+}

package/build/stores/Metadata.d.ts

@@ -0,0 +1,5 @@
+import type { MetadataDef } from '@subwallet/extension-inject/types';
+import BaseStore from './Base';
+export default class MetadataStore extends BaseStore<MetadataDef> {
+    constructor();
+}

package/build/stores/Metadata.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { EXTENSION_PREFIX } from "../defaults.js";
+import BaseStore from "./Base.js";
+export default class MetadataStore extends BaseStore {
+  constructor() {
+    super(`${EXTENSION_PREFIX}metadata`);
+  }
+
+}

package/build/stores/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AccountsStore } from './Accounts';
+export { default as MetadataStore } from './Metadata';

package/build/stores/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { default as AccountsStore } from "./Accounts.js";
+export { default as MetadataStore } from "./Metadata.js";

package/build/types.d.ts

@@ -0,0 +1,9 @@
+export interface Message extends MessageEvent {
+    data: {
+        error?: string;
+        id: string;
+        origin: string;
+        response?: string;
+        subscription?: string;
+    };
+}

package/build/types.js

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

package/build/utils/canDerive.d.ts

@@ -0,0 +1,2 @@
+import type { KeypairType } from '@polkadot/util-crypto/types';
+export declare function canDerive(type?: KeypairType): boolean;

package/build/utils/canDerive.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export function canDerive(type) {
+  return !!type && ['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(type);
+}

package/build/utils/getId.d.ts

@@ -0,0 +1 @@
+export declare function getId(): string;

package/build/utils/getId.js

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { EXTENSION_PREFIX } from "../defaults.js";
+let counter = 0;
+export function getId() {
+  return `${EXTENSION_PREFIX}.${Date.now()}.${++counter}`;
+}

package/build/utils/index.d.ts

@@ -0,0 +1 @@
+export { canDerive } from './canDerive';

package/build/utils/index.js

@@ -0,0 +1,3 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { canDerive } from "./canDerive.js";

package/build-cjs/background/KoniTypes.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TransferStep = exports.TransferErrorCode = exports.RMRK_VER = exports.CrowdloanParaState = exports.ApiInitStatus = exports.APIItemState = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let ApiInitStatus;
+exports.ApiInitStatus = ApiInitStatus;
+
+(function (ApiInitStatus) {
+  ApiInitStatus[ApiInitStatus["SUCCESS"] = 0] = "SUCCESS";
+  ApiInitStatus[ApiInitStatus["ALREADY_EXIST"] = 1] = "ALREADY_EXIST";
+  ApiInitStatus[ApiInitStatus["NOT_SUPPORT"] = 2] = "NOT_SUPPORT";
+})(ApiInitStatus || (exports.ApiInitStatus = ApiInitStatus = {}));
+
+let APIItemState;
+exports.APIItemState = APIItemState;
+
+(function (APIItemState) {
+  APIItemState["PENDING"] = "pending";
+  APIItemState["READY"] = "ready";
+  APIItemState["CACHED"] = "cached";
+  APIItemState["ERROR"] = "error";
+  APIItemState["NOT_SUPPORT"] = "not_support";
+})(APIItemState || (exports.APIItemState = APIItemState = {}));
+
+let RMRK_VER;
+exports.RMRK_VER = RMRK_VER;
+
+(function (RMRK_VER) {
+  RMRK_VER["VER_1"] = "1.0.0";
+  RMRK_VER["VER_2"] = "2.0.0";
+})(RMRK_VER || (exports.RMRK_VER = RMRK_VER = {}));
+
+let CrowdloanParaState;
+exports.CrowdloanParaState = CrowdloanParaState;
+
+(function (CrowdloanParaState) {
+  CrowdloanParaState["ONGOING"] = "ongoing";
+  CrowdloanParaState["COMPLETED"] = "completed";
+  CrowdloanParaState["FAILED"] = "failed";
+})(CrowdloanParaState || (exports.CrowdloanParaState = CrowdloanParaState = {}));
+
+let TransferErrorCode;
+exports.TransferErrorCode = TransferErrorCode;
+
+(function (TransferErrorCode) {
+  TransferErrorCode["INVALID_FROM_ADDRESS"] = "invalidFromAccount";
+  TransferErrorCode["INVALID_TO_ADDRESS"] = "invalidToAccount";
+  TransferErrorCode["NOT_ENOUGH_VALUE"] = "notEnoughValue";
+  TransferErrorCode["INVALID_VALUE"] = "invalidValue";
+  TransferErrorCode["INVALID_TOKEN"] = "invalidToken";
+  TransferErrorCode["KEYRING_ERROR"] = "keyringError";
+  TransferErrorCode["TRANSFER_ERROR"] = "transferError";
+  TransferErrorCode["TIMEOUT"] = "timeout";
+})(TransferErrorCode || (exports.TransferErrorCode = TransferErrorCode = {}));
+
+let TransferStep;
+exports.TransferStep = TransferStep;
+
+(function (TransferStep) {
+  TransferStep["READY"] = "ready";
+  TransferStep["START"] = "start";
+  TransferStep["PROCESSING"] = "processing";
+  TransferStep["SUCCESS"] = "success";
+  TransferStep["ERROR"] = "error";
+})(TransferStep || (exports.TransferStep = TransferStep = {}));

package/build-cjs/background/RequestBytesSign.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _wrapBytes = require("@subwallet/extension-dapp/wrapBytes");
+
+var _util = require("@polkadot/util");
+
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class RequestBytesSign {
+  constructor(payload) {
+    this.payload = payload;
+  }
+
+  sign(_registry, pair) {
+    return {
+      signature: (0, _util.u8aToHex)(pair.sign((0, _wrapBytes.wrapBytes)(this.payload.data)))
+    };
+  }
+
+}
+
+exports.default = RequestBytesSign;

package/build-cjs/background/RequestExtrinsicSign.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class RequestExtrinsicSign {
+  constructor(payload) {
+    this.payload = payload;
+  }
+
+  sign(registry, pair) {
+    return registry.createType('ExtrinsicPayload', this.payload, {
+      version: this.payload.version
+    }).sign(pair);
+  }
+
+}
+
+exports.default = RequestExtrinsicSign;