@subwallet/extension-base 0.5.1 → 0.5.4-0

package/background/handlers/Extension.js

@@ -4,7 +4,7 @@ import { ALLOWED_PATH, PASSWORD_EXPIRY_MS } from '@subwallet/extension-base/defa
 import { TypeRegistry } from '@polkadot/types';
 import keyring from '@polkadot/ui-keyring';
 import { accounts as accountsObservable } from '@polkadot/ui-keyring/observable/accounts';
-import { assert, isHex } from '@polkadot/util';
+import { assert, isHex, u8aToHex } from '@polkadot/util';
 import { keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
 import { withErrorLog } from "./helpers.js";
 import { createSubscription, unsubscribe } from "./subscriptions.js";
@@ -475,6 +475,53 @@ export default class Extension {
       isLocked: pair.isLocked,
       remainingTime
     };
+  }
+
+  qrIsLocked({
+    address
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    const remainingTime = this.refreshAccountPasswordCache(pair);
+    return {
+      isLocked: pair.isLocked,
+      remainingTime
+    };
+  }
+
+  qrSignSubstrate({
+    address,
+    message,
+    password,
+    savePass
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+
+    if (pair.isLocked && !password) {
+      throw new Error('Password needed to unlock the account');
+    }
+
+    if (pair.isLocked) {
+      try {
+        pair.decodePkcs8(password);
+      } catch (e) {
+        throw new Error('invalid password');
+      }
+    }
+
+    const signed = u8aToHex(pair.sign(message));
+    const _address = pair.address;
+
+    if (savePass) {
+      this.#cachedUnlocks[_address] = Date.now() + PASSWORD_EXPIRY_MS;
+    } else {
+      pair.lock();
+    }
+
+    return {
+      signature: signed
+    };
   } // FIXME This looks very much like what we have in authorization
 
 
@@ -662,6 +709,12 @@ export default class Extension {
       case 'pri(signing.isLocked)':
         return this.signingIsLocked(request);
 
+      case 'pri(qr.isLocked)':
+        return this.qrIsLocked(request);
+
+      case 'pri(qr.sign.substrate)':
+        return this.qrSignSubstrate(request);
+
       case 'pri(signing.requests)':
         return this.signingSubscribe(id, port);
 

package/background/types.d.ts

@@ -5,7 +5,7 @@ import type { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types'
 import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType } from '@polkadot/util-crypto/types';
-import { CurrentNetworkInfo, KoniRequestSignatures } from '@subwallet/extension-base/background/KoniTypes';
+import { CurrentNetworkInfo, KoniRequestSignatures, NetworkJson } from '@subwallet/extension-base/background/KoniTypes';
 import { TypeRegistry } from '@polkadot/types';
 import { ALLOWED_PATH } from '../defaults';
 import { AuthUrls } from './handlers/State';
@@ -25,6 +25,7 @@ export declare type SeedLengths = 12 | 24;
 export interface AccountJson extends KeyringPair$Meta {
     address: string;
     genesisHash?: string | null;
+    originGenesisHash?: string | null;
     isExternal?: boolean;
     isHardware?: boolean;
     isHidden?: boolean;
@@ -38,13 +39,20 @@ export interface AccountsWithCurrentAddress {
     accounts: AccountJson[];
     currentAddress?: string;
 }
+export interface CurrentAccountInfo {
+    address: string;
+}
 export declare type AccountWithChildren = AccountJson & {
     children?: AccountWithChildren[];
 };
+export interface FindAccountFunction {
+    (networkMap: Record<string, NetworkJson>, address: string, genesisHash?: string): AccountJson | undefined;
+}
 export declare type AccountsContext = {
     accounts: AccountJson[];
     hierarchy: AccountWithChildren[];
     master?: AccountJson;
+    getAccountByAddress: FindAccountFunction;
 };
 export declare type CurrentAccContext = {
     currentAccount: AccountJson | null;
@@ -276,18 +284,36 @@ export interface RequestSeedValidate {
     suri: string;
     type?: KeypairType;
 }
+export interface RequestParseTransactionSubstrate {
+    genesisHash: string;
+    rawPayload: string;
+    specVersion: number;
+}
+export interface RequestQRIsLocked {
+    address: string;
+}
+export interface RequestQrSignSubstrate {
+    address: string;
+    message: string;
+    savePass: boolean;
+    password?: string;
+}
 export declare type ResponseTypes = {
     [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][1];
 };
 export declare type ResponseType<TMessageType extends keyof RequestSignatures> = RequestSignatures[TMessageType][1];
 interface TransportResponseMessageSub<TMessageType extends MessageTypesWithSubscriptions> {
     error?: string;
+    errorCode?: number;
+    errorData?: unknown;
     id: string;
     response?: ResponseTypes[TMessageType];
     subscription?: SubscriptionMessageTypes[TMessageType];
 }
 interface TransportResponseMessageNoSub<TMessageType extends MessageTypesWithNoSubscriptions> {
     error?: string;
+    errorCode?: number;
+    errorData?: unknown;
     id: string;
     response?: ResponseTypes[TMessageType];
 }
@@ -349,4 +375,30 @@ export interface ResponseJsonGetAccountInfo {
 export interface ResponseAuthorizeList {
     list: AuthUrls;
 }
+export interface FormattedMethod {
+    args?: ArgInfo[];
+    method: string;
+}
+export interface ArgInfo {
+    argName: string;
+    argValue: string | string[];
+}
+export interface EraInfo {
+    period: number;
+    phase: number;
+}
+export interface ResponseParseTransactionSubstrate {
+    era: EraInfo | string;
+    nonce: number;
+    method: string;
+    tip: number;
+    specVersion: number;
+}
+export interface ResponseQRIsLocked {
+    isLocked: boolean;
+    remainingTime: number;
+}
+export interface ResponseQrSignSubstrate {
+    signature: string;
+}
 export {};

package/cjs/background/KoniTypes.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TransferStep = exports.TransferErrorCode = exports.RMRK_VER = exports.NETWORK_STATUS = exports.NETWORK_ERROR = exports.CrowdloanParaState = exports.ApiInitStatus = exports.APIItemState = void 0;
+exports.TransferStep = exports.TransferErrorCode = exports.RMRK_VER = exports.NETWORK_STATUS = exports.NETWORK_ERROR = exports.ExternalRequestPromiseStatus = exports.CrowdloanParaState = exports.BasicTxErrorCode = exports.ApiInitStatus = exports.AccountExternalErrorCode = exports.APIItemState = void 0;
 // Copyright 2019-2022 @polkadot/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 let ApiInitStatus;
@@ -77,19 +77,59 @@ exports.TransferErrorCode = TransferErrorCode;
   TransferErrorCode["NOT_ENOUGH_VALUE"] = "notEnoughValue";
   TransferErrorCode["INVALID_VALUE"] = "invalidValue";
   TransferErrorCode["INVALID_TOKEN"] = "invalidToken";
+  TransferErrorCode["INVALID_PARAM"] = "invalidParam";
   TransferErrorCode["KEYRING_ERROR"] = "keyringError";
   TransferErrorCode["TRANSFER_ERROR"] = "transferError";
   TransferErrorCode["TIMEOUT"] = "timeout";
   TransferErrorCode["UNSUPPORTED"] = "unsupported";
 })(TransferErrorCode || (exports.TransferErrorCode = TransferErrorCode = {}));
 
+let BasicTxErrorCode;
+exports.BasicTxErrorCode = BasicTxErrorCode;
+
+(function (BasicTxErrorCode) {
+  BasicTxErrorCode["INVALID_FROM_ADDRESS"] = "invalidFromAccount";
+  BasicTxErrorCode["INVALID_TO_ADDRESS"] = "invalidToAccount";
+  BasicTxErrorCode["NOT_ENOUGH_VALUE"] = "notEnoughValue";
+  BasicTxErrorCode["INVALID_VALUE"] = "invalidValue";
+  BasicTxErrorCode["INVALID_TOKEN"] = "invalidToken";
+  BasicTxErrorCode["INVALID_PARAM"] = "invalidParam";
+  BasicTxErrorCode["KEYRING_ERROR"] = "keyringError";
+  BasicTxErrorCode["TRANSFER_ERROR"] = "transferError";
+  BasicTxErrorCode["STAKING_ERROR"] = "stakingError";
+  BasicTxErrorCode["UN_STAKING_ERROR"] = "unStakingError";
+  BasicTxErrorCode["WITHDRAW_STAKING_ERROR"] = "withdrawStakingError";
+  BasicTxErrorCode["TIMEOUT"] = "timeout";
+  BasicTxErrorCode["UNSUPPORTED"] = "unsupported";
+})(BasicTxErrorCode || (exports.BasicTxErrorCode = BasicTxErrorCode = {}));
+
 let TransferStep;
 exports.TransferStep = TransferStep;
 
 (function (TransferStep) {
   TransferStep["READY"] = "ready";
+  TransferStep["SIGNING"] = "signing";
   TransferStep["START"] = "start";
   TransferStep["PROCESSING"] = "processing";
   TransferStep["SUCCESS"] = "success";
   TransferStep["ERROR"] = "error";
-})(TransferStep || (exports.TransferStep = TransferStep = {}));
+})(TransferStep || (exports.TransferStep = TransferStep = {}));
+
+let ExternalRequestPromiseStatus;
+exports.ExternalRequestPromiseStatus = ExternalRequestPromiseStatus;
+
+(function (ExternalRequestPromiseStatus) {
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["PENDING"] = 0] = "PENDING";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["REJECTED"] = 1] = "REJECTED";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["FAILED"] = 2] = "FAILED";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["COMPLETED"] = 3] = "COMPLETED";
+})(ExternalRequestPromiseStatus || (exports.ExternalRequestPromiseStatus = ExternalRequestPromiseStatus = {}));
+
+let AccountExternalErrorCode;
+exports.AccountExternalErrorCode = AccountExternalErrorCode;
+
+(function (AccountExternalErrorCode) {
+  AccountExternalErrorCode["INVALID_ADDRESS"] = "invalidToAccount";
+  AccountExternalErrorCode["KEYRING_ERROR"] = "keyringError";
+  AccountExternalErrorCode["UNKNOWN_ERROR"] = "unknownError";
+})(AccountExternalErrorCode || (exports.AccountExternalErrorCode = AccountExternalErrorCode = {}));

package/cjs/background/handlers/Extension.js

@@ -557,6 +557,59 @@ class Extension {
       isLocked: pair.isLocked,
       remainingTime
     };
+  }
+
+  qrIsLocked(_ref24) {
+    let {
+      address
+    } = _ref24;
+
+    const pair = _uiKeyring.default.getPair(address);
+
+    (0, _util.assert)(pair, 'Unable to find pair');
+    const remainingTime = this.refreshAccountPasswordCache(pair);
+    return {
+      isLocked: pair.isLocked,
+      remainingTime
+    };
+  }
+
+  qrSignSubstrate(_ref25) {
+    let {
+      address,
+      message,
+      password,
+      savePass
+    } = _ref25;
+
+    const pair = _uiKeyring.default.getPair(address);
+
+    (0, _util.assert)(pair, 'Unable to find pair');
+
+    if (pair.isLocked && !password) {
+      throw new Error('Password needed to unlock the account');
+    }
+
+    if (pair.isLocked) {
+      try {
+        pair.decodePkcs8(password);
+      } catch (e) {
+        throw new Error('invalid password');
+      }
+    }
+
+    const signed = (0, _util.u8aToHex)(pair.sign(message));
+    const _address = pair.address;
+
+    if (savePass) {
+      this.#cachedUnlocks[_address] = Date.now() + _defaults.PASSWORD_EXPIRY_MS;
+    } else {
+      pair.lock();
+    }
+
+    return {
+      signature: signed
+    };
   } // FIXME This looks very much like what we have in authorization
 
 
@@ -600,12 +653,12 @@ class Extension {
     }
   }
 
-  derivationValidate(_ref24) {
+  derivationValidate(_ref26) {
     let {
       parentAddress,
       parentPassword,
       suri
-    } = _ref24;
+    } = _ref26;
     const childPair = this.derive(parentAddress, suri, parentPassword, {});
     return {
       address: childPair.address,
@@ -613,7 +666,7 @@ class Extension {
     };
   }
 
-  derivationCreate(_ref25) {
+  derivationCreate(_ref27) {
     let {
       genesisHash,
       name,
@@ -621,7 +674,7 @@ class Extension {
       parentPassword,
       password,
       suri
-    } = _ref25;
+    } = _ref27;
     const childPair = this.derive(parentAddress, suri, parentPassword, {
       genesisHash,
       name,
@@ -748,6 +801,12 @@ class Extension {
       case 'pri(signing.isLocked)':
         return this.signingIsLocked(request);
 
+      case 'pri(qr.isLocked)':
+        return this.qrIsLocked(request);
+
+      case 'pri(qr.sign.substrate)':
+        return this.qrSignSubstrate(request);
+
       case 'pri(signing.requests)':
         return this.signingSubscribe(id, port);
 

package/cjs/defaults.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.PORT_EXTENSION = exports.PORT_CONTENT = exports.PHISHING_PAGE_REDIRECT = exports.PASSWORD_EXPIRY_MS = exports.PASSWORD_EXPIRY_MIN = exports.MESSAGE_ORIGIN_PAGE = exports.MESSAGE_ORIGIN_CONTENT = exports.EXTENSION_PREFIX = exports.ALLOWED_PATH = void 0;
 // Copyright 2019-2022 @polkadot/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-const ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json', '/account/create'];
+const ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json', '/account/create', '/account/settings'];
 exports.ALLOWED_PATH = ALLOWED_PATH;
 const PHISHING_PAGE_REDIRECT = '/phishing-page-detected';
 exports.PHISHING_PAGE_REDIRECT = PHISHING_PAGE_REDIRECT;

package/cjs/errors/SubWalletProviderError.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SubWalletProviderError = void 0;
+
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class SubWalletProviderError extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+
+}
+
+exports.SubWalletProviderError = SubWalletProviderError;

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '0.5.1'
+  version: '0.5.4-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/page/index.js

@@ -9,6 +9,8 @@ exports.enable = enable;
 exports.handleResponse = handleResponse;
 exports.sendMessage = sendMessage;
 
+var _SubWalletProviderError = require("@subwallet/extension-base/errors/SubWalletProviderError");
+
 var _defaults = require("../defaults");
 
 var _getId = require("../utils/getId");
@@ -62,7 +64,7 @@ function handleResponse(data) {
     // eslint-disable-next-line @typescript-eslint/ban-types
     handler.subscriber(data.subscription);
   } else if (data.error) {
-    handler.reject(new Error(data.error));
+    handler.reject(new _SubWalletProviderError.SubWalletProviderError(data.error, data.errorCode, data.errorData));
   } else {
     handler.resolve(data.response);
   }

package/cjs/signers/substrates/LedgerSigner.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+
+var _util = require("@polkadot/util");
+
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class LedgerSigner {
+  #registry;
+  #callback;
+  #setState;
+  #id;
+
+  constructor(registry, callback, id, setState) {
+    this.#registry = registry;
+    this.#callback = callback;
+    this.#id = id;
+    this.#setState = setState;
+  }
+
+  async signPayload(payload) {
+    return new Promise((resolve, reject) => {
+      const raw = this.#registry.createType('ExtrinsicPayload', payload, {
+        version: payload.version
+      });
+      const ledgerPayload = raw.toU8a(true);
+      this.#setState({
+        reject: reject,
+        resolve: resolve,
+        status: _KoniTypes.ExternalRequestPromiseStatus.PENDING,
+        createdAt: new Date().getTime()
+      });
+      this.#callback({
+        ledgerState: {
+          ledgerPayload: (0, _util.u8aToHex)(ledgerPayload),
+          ledgerId: this.#id
+        }
+      });
+    });
+  }
+
+}
+
+exports.default = LedgerSigner;

package/cjs/signers/substrates/QrSigner.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+
+var _util = require("@polkadot/util");
+
+var _utilCrypto = require("@polkadot/util-crypto");
+
+// Copyright 2017-2022 @polkadot/react-signer authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class QrSigner {
+  #callback;
+  #id;
+  #registry;
+  #resolver;
+  #setState;
+
+  constructor(_ref) {
+    let {
+      callback,
+      id,
+      registry,
+      resolver,
+      setState
+    } = _ref;
+    this.#callback = callback;
+    this.#id = id;
+    this.#registry = registry;
+    this.#resolver = resolver;
+    this.#setState = setState;
+  }
+
+  async signPayload(payload) {
+    return new Promise((resolve, reject) => {
+      // limit size of the transaction
+      const isQrHashed = payload.method.length > 5000;
+      const wrapper = this.#registry.createType('ExtrinsicPayload', payload, {
+        version: payload.version
+      });
+      const qrPayload = isQrHashed ? (0, _utilCrypto.blake2AsU8a)(wrapper.toU8a(true)) : wrapper.toU8a();
+
+      const resolver = result => {
+        this.#resolver();
+        resolve(result);
+      };
+
+      this.#setState({
+        reject: reject,
+        resolve: resolver,
+        status: _KoniTypes.ExternalRequestPromiseStatus.PENDING,
+        createdAt: new Date().getTime()
+      });
+      this.#callback({
+        qrState: {
+          isQrHashed,
+          qrAddress: payload.address,
+          qrPayload: (0, _util.u8aToHex)(qrPayload),
+          qrId: this.#id,
+          isEthereum: false
+        }
+      });
+    });
+  }
+
+}
+
+exports.default = QrSigner;

package/cjs/signers/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/signers/web3/QrSigner.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+
+var _rlp = _interopRequireDefault(require("rlp"));
+
+var _util = require("@polkadot/util");
+
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class QrSigner {
+  #callback;
+  #id;
+  #resolver;
+  #setState;
+
+  constructor(_ref) {
+    let {
+      callback,
+      id,
+      resolver,
+      setState
+    } = _ref;
+    this.#callback = callback;
+    this.#id = id;
+    this.#resolver = resolver;
+    this.#setState = setState;
+  }
+
+  async signTransaction(tx) {
+    return new Promise((resolve, reject) => {
+      const data = [tx.nonce, tx.gasPrice, tx.gasLimit, tx.to, tx.value, tx.data, tx.chainId, new Uint8Array([0x00]), new Uint8Array([0x00])];
+
+      const qrPayload = _rlp.default.encode(data);
+
+      const resolver = result => {
+        this.#resolver();
+        resolve(result);
+      };
+
+      this.#setState({
+        reject: reject,
+        resolve: resolver,
+        status: _KoniTypes.ExternalRequestPromiseStatus.PENDING,
+        createdAt: new Date().getTime()
+      });
+      this.#callback({
+        qrState: {
+          isQrHashed: false,
+          qrAddress: tx.from,
+          qrPayload: (0, _util.u8aToHex)(qrPayload),
+          qrId: this.#id,
+          isEthereum: true
+        }
+      });
+    });
+  }
+
+}
+
+exports.default = QrSigner;

package/defaults.d.ts

@@ -1,4 +1,4 @@
-declare const ALLOWED_PATH: readonly ["/", "/account/import-ledger", "/account/restore-json", "/account/create"];
+declare const ALLOWED_PATH: readonly ["/", "/account/import-ledger", "/account/restore-json", "/account/create", "/account/settings"];
 declare const PHISHING_PAGE_REDIRECT = "/phishing-page-detected";
 declare const EXTENSION_PREFIX: string;
 declare const PORT_CONTENT: string;

package/defaults.js

@@ -1,6 +1,6 @@
 // Copyright 2019-2022 @polkadot/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-const ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json', '/account/create'];
+const ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json', '/account/create', '/account/settings'];
 const PHISHING_PAGE_REDIRECT = '/phishing-page-detected';
 const EXTENSION_PREFIX = process.env.EXTENSION_PREFIX || '';
 const PORT_CONTENT = `${EXTENSION_PREFIX}koni-content`;

package/errors/SubWalletProviderError.d.ts

@@ -0,0 +1,6 @@
+import { SubWalletProviderErrorInterface } from '@subwallet/extension-base/background/KoniTypes';
+export declare class SubWalletProviderError extends Error implements SubWalletProviderErrorInterface {
+    code: number | undefined;
+    data: unknown | undefined;
+    constructor(message: string, code?: number, data?: unknown);
+}

package/errors/SubWalletProviderError.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export class SubWalletProviderError extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+
+}