@subwallet/extension-base 0.5.3-1 → 0.5.6-0

package/background/KoniTypes.d.ts

@@ -1,13 +1,15 @@
 import { AuthUrls, Resolver } from '@subwallet/extension-base/background/handlers/State';
-import { AccountAuthType, AccountJson, AuthorizeRequest, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@subwallet/extension-base/background/types';
+import { AccountAuthType, AccountJson, AuthorizeRequest, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, RequestParseTransactionSubstrate, RequestQRIsLocked, RequestQrSignSubstrate, ResponseAuthorizeList, ResponseJsonGetAccountInfo, ResponseParseTransactionSubstrate, ResponseQRIsLocked, ResponseQrSignSubstrate, SeedLengths } from '@subwallet/extension-base/background/types';
+import { ExternalState, LedgerState, QrState } from '@subwallet/extension-base/signers/types';
 import { InjectedAccount, MetadataDefBase } from '@subwallet/extension-inject/types';
 import Web3 from 'web3';
 import { RequestArguments, TransactionConfig } from 'web3-core';
 import { JsonRpcPayload, JsonRpcResponse } from 'web3-core-helpers';
 import { ApiPromise } from '@polkadot/api';
 import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
-import { KeyringPair$Json } from '@polkadot/keyring/types';
+import { KeyringPair$Json, KeyringPair$Meta } from '@polkadot/keyring/types';
 import { Registry } from '@polkadot/types/types';
+import { SignerResult } from '@polkadot/types/types/extrinsic';
 import { SingleAddress } from '@polkadot/ui-keyring/observable/types';
 import { KeyringOptions } from '@polkadot/ui-keyring/options/types';
 import { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
@@ -315,11 +317,12 @@ export declare type TokenInfo = {
     symbol: string;
     symbolAlt?: string;
     erc20Address?: string;
-    assetIndex?: number;
+    assetIndex?: number | string;
     decimals: number;
     name: string;
     coinGeckoKey?: string;
     specialOption?: object;
+    assetId?: string;
 };
 export interface AccountsWithCurrentAddress {
     accounts: AccountJson[];
@@ -453,8 +456,20 @@ export interface RequestCrossChainTransfer extends RequestCheckCrossChainTransfe
 }
 export interface ResponseCheckCrossChainTransfer {
     errors?: Array<TransferError>;
-    estimateFee?: string;
-    feeSymbol?: string;
+    feeString?: string;
+    estimatedFee: string;
+    feeSymbol: string;
+}
+export declare type RequestTransferExternal = RequestCheckTransfer;
+export declare type RequestCrossChainTransferExternal = RequestCheckCrossChainTransfer;
+export interface RequestRejectExternalRequest {
+    id: string;
+    message?: string;
+    throwError?: boolean;
+}
+export interface RequestResolveExternalRequest {
+    id: string;
+    data: SignerResult;
 }
 export interface ResponsePrivateKeyValidateV2 {
     addressMap: Record<KeypairType, string>;
@@ -505,16 +520,36 @@ export declare enum TransferErrorCode {
     NOT_ENOUGH_VALUE = "notEnoughValue",
     INVALID_VALUE = "invalidValue",
     INVALID_TOKEN = "invalidToken",
+    INVALID_PARAM = "invalidParam",
     KEYRING_ERROR = "keyringError",
     TRANSFER_ERROR = "transferError",
     TIMEOUT = "timeout",
     UNSUPPORTED = "unsupported"
 }
+export declare enum BasicTxErrorCode {
+    INVALID_FROM_ADDRESS = "invalidFromAccount",
+    INVALID_TO_ADDRESS = "invalidToAccount",
+    NOT_ENOUGH_VALUE = "notEnoughValue",
+    INVALID_VALUE = "invalidValue",
+    INVALID_TOKEN = "invalidToken",
+    INVALID_PARAM = "invalidParam",
+    KEYRING_ERROR = "keyringError",
+    TRANSFER_ERROR = "transferError",
+    STAKING_ERROR = "stakingError",
+    UN_STAKING_ERROR = "unStakingError",
+    WITHDRAW_STAKING_ERROR = "withdrawStakingError",
+    TIMEOUT = "timeout",
+    UNSUPPORTED = "unsupported"
+}
 export declare type TransferError = {
     code: TransferErrorCode;
     data?: object;
     message: string;
 };
+export interface BaseTxError {
+    code: BasicTxErrorCode;
+    message: string;
+}
 export interface ResponseCheckTransfer {
     errors?: Array<TransferError>;
     fromAccountFree: string;
@@ -524,12 +559,13 @@ export interface ResponseCheckTransfer {
 }
 export declare enum TransferStep {
     READY = "ready",
+    SIGNING = "signing",
     START = "start",
     PROCESSING = "processing",
     SUCCESS = "success",
     ERROR = "error"
 }
-declare type TxResultType = {
+export declare type TxResultType = {
     change: string;
     changeSymbol?: string;
     fee?: string;
@@ -544,6 +580,16 @@ export interface ResponseTransfer {
     txResult?: TxResultType;
     isFinalized?: boolean;
 }
+export interface ResponseTransferExternal extends ResponseTransfer {
+    externalState?: ExternalState;
+}
+export interface ResponseTransferQr extends ResponseTransferExternal {
+    qrState?: QrState;
+    isBusy?: boolean;
+}
+export interface ResponseTransferLedger extends ResponseTransferExternal {
+    ledgerState?: LedgerState;
+}
 export interface EvmNftTransactionRequest {
     networkKey: string;
     senderAddress: string;
@@ -562,14 +608,6 @@ export interface EvmNftSubmitTransaction {
     networkKey: string;
     rawTransaction: Record<string, any>;
 }
-export interface NftTransactionResponse {
-    passwordError?: string | null;
-    callHash?: string;
-    status?: boolean;
-    transactionHash?: string;
-    txError?: boolean;
-    isSendingSelf: boolean;
-}
 export interface ValidateNetworkResponse {
     success: boolean;
     key: string;
@@ -672,12 +710,60 @@ export interface SubstrateNftSubmitTransaction {
 export declare type ChainRelationType = 'p' | 'r';
 export interface ChainRelationInfo {
     type: ChainRelationType;
+    isEthereum: boolean;
     supportedToken: string[];
 }
 export interface CrossChainRelation {
     type: ChainRelationType;
+    isEthereum: boolean;
     relationMap: Record<string, ChainRelationInfo>;
 }
+export interface RequestAccountMeta {
+    address: string | Uint8Array;
+}
+export interface ResponseAccountMeta {
+    meta: KeyringPair$Meta;
+}
+export declare type ResponseRejectExternalRequest = void;
+export declare type ResponseResolveExternalRequest = void;
+export declare enum ExternalRequestPromiseStatus {
+    PENDING = 0,
+    REJECTED = 1,
+    FAILED = 2,
+    COMPLETED = 3
+}
+export interface ExternalRequestPromise {
+    resolve?: (result: SignerResult | PromiseLike<SignerResult>) => void;
+    reject?: (error?: Error) => void;
+    status: ExternalRequestPromiseStatus;
+    message?: string;
+    createdAt: number;
+}
+export interface RequestAccountCreateExternalV2 {
+    address: string;
+    genesisHash?: string | null;
+    name: string;
+    isEthereum: boolean;
+    isAllowed: boolean;
+}
+export interface RequestAccountCreateHardwareV2 {
+    accountIndex: number;
+    address: string;
+    addressOffset: number;
+    genesisHash: string;
+    hardwareType: string;
+    name: string;
+    isAllowed?: boolean;
+}
+export declare enum AccountExternalErrorCode {
+    INVALID_ADDRESS = "invalidToAccount",
+    KEYRING_ERROR = "keyringError",
+    UNKNOWN_ERROR = "unknownError"
+}
+export interface AccountExternalError {
+    code: AccountExternalErrorCode;
+    message: string;
+}
 export declare type RequestEvmEvents = null;
 export declare type EvmEventType = 'connect' | 'disconnect' | 'accountsChanged' | 'chainChanged' | 'message' | 'data' | 'reconnect' | 'error';
 export declare type EvmAccountsChangedPayload = string[];
@@ -702,11 +788,13 @@ export interface ResponseEvmProviderSend {
     error: (Error | null);
     result?: JsonRpcResponse;
 }
-export interface EvmProviderRpcErrorInterface extends Error {
-    message: string;
-    code: number;
+export interface SubWalletProviderErrorInterface extends Error {
+    code?: number;
     data?: unknown;
 }
+export interface EvmProviderRpcErrorInterface extends SubWalletProviderErrorInterface {
+    code: number;
+}
 export declare type EvmRpcErrorHelperMap = Record<'USER_REJECTED_REQUEST' | 'UNAUTHORIZED' | 'UNSUPPORTED_METHOD' | 'DISCONNECTED' | 'CHAIN_DISCONNECTED' | 'INVALID_PARAMS' | 'INTERNAL_ERROR', [number, string]>;
 export interface EvmSendTransactionParams {
     from: string;
@@ -745,15 +833,51 @@ export interface ConfirmationResult<T> {
     payload?: T;
     password?: string;
 }
+export interface ConfirmationResultQr<T> extends ConfirmationResult<T> {
+    signature: `0x${string}`;
+}
 export interface EvmSendTransactionRequest extends TransactionConfig {
     estimateGas: string;
 }
+export interface EvmRequestQr {
+    qrPayload: string;
+    canSign: boolean;
+}
+export interface EvmSendTransactionRequestQr extends TransactionConfig, EvmRequestQr {
+    estimateGas: string;
+}
+export interface EvmSignatureRequestQr extends EvmSignatureRequest, EvmRequestQr {
+}
 export interface ConfirmationDefinitions {
     addNetworkRequest: [ConfirmationsQueueItem<NetworkJson>, ConfirmationResult<NetworkJson>];
     addTokenRequest: [ConfirmationsQueueItem<CustomEvmToken>, ConfirmationResult<boolean>];
     switchNetworkRequest: [ConfirmationsQueueItem<SwitchNetworkRequest>, ConfirmationResult<boolean>];
     evmSignatureRequest: [ConfirmationsQueueItem<EvmSignatureRequest>, ConfirmationResult<string>];
+    evmSignatureRequestQr: [ConfirmationsQueueItem<EvmSignatureRequestQr>, ConfirmationResultQr<string>];
     evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<boolean>];
+    evmSendTransactionRequestQr: [ConfirmationsQueueItem<EvmSendTransactionRequestQr>, ConfirmationResultQr<boolean>];
+}
+export interface RequestParseTransactionEVM {
+    data: string;
+}
+export interface ResponseParseTransactionEVM {
+    data: ParseEVMTransactionData | string;
+    input: string;
+    nonce: number;
+    to: string;
+    gas: number;
+    gasPrice: number;
+    value: number;
+}
+export interface RequestQrSignEVM {
+    address: string;
+    message: string;
+    type: 'message' | 'transaction';
+    chainId?: number;
+    password: string;
+}
+export interface ResponseQrSignEVM {
+    signature: string;
 }
 export declare type ConfirmationType = keyof ConfirmationDefinitions;
 export declare type ConfirmationsQueue = {
@@ -812,6 +936,9 @@ export interface BasicTxResponse {
     transactionHash?: string;
     txError?: boolean;
 }
+export interface NftTransactionResponse extends BasicTxResponse {
+    isSendingSelf: boolean;
+}
 export interface BondingOptionParams {
     networkKey: string;
     address: string;
@@ -860,6 +987,51 @@ export interface StakeClaimRewardParams {
     validatorAddress?: string;
     password?: string;
 }
+export interface ResponseNftTransferExternal extends NftTransactionResponse {
+    externalState?: ExternalState;
+}
+export interface ResponseNftTransferQr extends ResponseNftTransferExternal {
+    qrState?: QrState;
+    isBusy?: boolean;
+}
+export interface ResponseNftTransferLedger extends ResponseNftTransferExternal {
+    ledgerState?: LedgerState;
+}
+export declare type RequestNftTransferExternalSubstrate = Omit<SubstrateNftSubmitTransaction, 'password'>;
+export declare type RequestNftTransferExternalEVM = Omit<EvmNftSubmitTransaction, 'password'>;
+export declare type RequestStakeExternal = Omit<BondingSubmitParams, 'password'>;
+export interface ResponseStakeExternal extends BasicTxResponse {
+    externalState?: ExternalState;
+}
+export interface ResponseStakeQr extends ResponseStakeExternal {
+    qrState?: QrState;
+    isBusy?: boolean;
+}
+export interface ResponseStakeLedger extends ResponseStakeExternal {
+    ledgerState?: LedgerState;
+}
+export declare type RequestUnStakeExternal = Omit<UnbondingSubmitParams, 'password'>;
+export interface ResponseUnStakeExternal extends BasicTxResponse {
+    externalState?: ExternalState;
+}
+export interface ResponseUnStakeQr extends ResponseUnStakeExternal {
+    qrState?: QrState;
+    isBusy?: boolean;
+}
+export interface ResponseUnStakeLedger extends ResponseUnStakeExternal {
+    ledgerState?: LedgerState;
+}
+export declare type RequestWithdrawStakeExternal = Omit<StakeWithdrawalParams, 'password'>;
+export interface ResponseWithdrawStakeExternal extends BasicTxResponse {
+    externalState?: ExternalState;
+}
+export interface ResponseWithdrawStakeQr extends ResponseWithdrawStakeExternal {
+    qrState?: QrState;
+    isBusy?: boolean;
+}
+export interface ResponseWithdrawStakeLedger extends ResponseWithdrawStakeExternal {
+    ledgerState?: LedgerState;
+}
 export interface StakeDelegationRequest {
     address: string;
     networkKey: string;
@@ -889,6 +1061,13 @@ export interface RequestParseEVMTransactionInput {
 export interface ResponseParseEVMTransactionInput {
     result: ParseEVMTransactionData | string;
 }
+export interface LedgerNetwork {
+    genesisHash: string;
+    displayName: string;
+    network: string;
+    icon: 'substrate' | 'ethereum';
+    isDevMode: boolean;
+}
 export interface KoniRequestSignatures {
     'pri(staking.delegationInfo)': [StakeDelegationRequest, DelegationItem[]];
     'pri(staking.submitClaimReward)': [StakeClaimRewardParams, BasicTxResponse, BasicTxResponse];
@@ -957,6 +1136,8 @@ export interface KoniRequestSignatures {
     'pri(seed.validateV2)': [RequestSeedValidateV2, ResponseSeedValidateV2];
     'pri(privateKey.validateV2)': [RequestSeedValidateV2, ResponsePrivateKeyValidateV2];
     'pri(accounts.create.suriV2)': [RequestAccountCreateSuriV2, ResponseAccountCreateSuriV2];
+    'pri(accounts.create.externalV2)': [RequestAccountCreateExternalV2, AccountExternalError[]];
+    'pri(accounts.create.hardwareV2)': [RequestAccountCreateHardwareV2, boolean];
     'pri(accounts.checkTransfer)': [RequestCheckTransfer, ResponseCheckTransfer];
     'pri(accounts.checkCrossChainTransfer)': [RequestCheckCrossChainTransfer, ResponseCheckCrossChainTransfer];
     'pri(accounts.transfer)': [RequestTransfer, Array<TransferError>, ResponseTransfer];
@@ -969,6 +1150,7 @@ export interface KoniRequestSignatures {
     'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
     'pri(accounts.saveRecent)': [RequestSaveRecentAccount, SingleAddress];
     'pri(accounts.triggerSubscription)': [null, boolean];
+    'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
     'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, boolean, CurrentAccountInfo];
     'pri(settings.changeBalancesVisibility)': [null, boolean, ResponseSettingsType];
     'pri(settings.subscribe)': [null, ResponseSettingsType, ResponseSettingsType];
@@ -987,13 +1169,32 @@ export interface KoniRequestSignatures {
     'pub(utils.getRandom)': [RandomTestRequest, number];
     'pub(accounts.listV2)': [RequestAccountList, InjectedAccount[]];
     'pub(accounts.subscribeV2)': [RequestAccountSubscribe, boolean, InjectedAccount[]];
+    'pri(qr.transaction.parse.substrate)': [RequestParseTransactionSubstrate, ResponseParseTransactionSubstrate];
+    'pri(qr.transaction.parse.evm)': [RequestParseTransactionEVM, ResponseParseTransactionEVM];
+    'pri(qr.isLocked)': [RequestQRIsLocked, ResponseQRIsLocked];
+    'pri(qr.sign.substrate)': [RequestQrSignSubstrate, ResponseQrSignSubstrate];
+    'pri(qr.sign.evm)': [RequestQrSignEVM, ResponseQrSignEVM];
+    'pri(account.external.reject)': [RequestRejectExternalRequest, ResponseRejectExternalRequest];
+    'pri(account.external.resolve)': [RequestResolveExternalRequest, ResponseResolveExternalRequest];
     'evm(events.subscribe)': [RequestEvmEvents, boolean, EvmEvent];
     'evm(request)': [RequestArguments, unknown];
     'evm(provider.send)': [RequestEvmProviderSend, string | number, ResponseEvmProviderSend];
     'pri(evm.transaction.parse.input)': [RequestParseEVMTransactionInput, ResponseParseEVMTransactionInput];
+    'pri(accounts.transfer.qr.create)': [RequestTransferExternal, Array<TransferError>, ResponseTransferQr];
+    'pri(accounts.cross.transfer.qr.create)': [RequestCrossChainTransferExternal, Array<TransferError>, ResponseTransferQr];
+    'pri(nft.transfer.qr.create.substrate)': [RequestNftTransferExternalSubstrate, Array<BaseTxError>, ResponseNftTransferQr];
+    'pri(nft.transfer.qr.create.evm)': [RequestNftTransferExternalEVM, Array<BaseTxError>, ResponseNftTransferQr];
+    'pri(stake.qr.create)': [RequestStakeExternal, Array<BaseTxError>, ResponseStakeQr];
+    'pri(unStake.qr.create)': [RequestUnStakeExternal, Array<BaseTxError>, ResponseUnStakeQr];
+    'pri(withdrawStake.qr.create)': [RequestWithdrawStakeExternal, Array<BaseTxError>, ResponseWithdrawStakeQr];
+    'pri(accounts.transfer.ledger.create)': [RequestTransferExternal, Array<TransferError>, ResponseTransferLedger];
+    'pri(accounts.cross.transfer.ledger.create)': [RequestCrossChainTransferExternal, Array<TransferError>, ResponseTransferLedger];
+    'pri(nft.transfer.ledger.create.substrate)': [RequestNftTransferExternalSubstrate, Array<BaseTxError>, ResponseNftTransferQr];
+    'pri(stake.ledger.create)': [RequestStakeExternal, Array<BaseTxError>, ResponseStakeLedger];
+    'pri(unStake.ledger.create)': [RequestUnStakeExternal, Array<BaseTxError>, ResponseUnStakeLedger];
+    'pri(withdrawStake.ledger.create)': [RequestWithdrawStakeExternal, Array<BaseTxError>, ResponseWithdrawStakeLedger];
     'pri(authorize.subscribe)': [null, AuthUrls, AuthUrls];
 }
 export interface ApplicationMetadataType {
     version: string;
 }
-export {};

package/background/KoniTypes.js

@@ -64,18 +64,55 @@ export let 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 || (TransferErrorCode = {}));
 
+export let 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 || (BasicTxErrorCode = {}));
+
 export let TransferStep;
 
 (function (TransferStep) {
   TransferStep["READY"] = "ready";
+  TransferStep["SIGNING"] = "signing";
   TransferStep["START"] = "start";
   TransferStep["PROCESSING"] = "processing";
   TransferStep["SUCCESS"] = "success";
   TransferStep["ERROR"] = "error";
-})(TransferStep || (TransferStep = {}));
+})(TransferStep || (TransferStep = {}));
+
+export let ExternalRequestPromiseStatus;
+
+(function (ExternalRequestPromiseStatus) {
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["PENDING"] = 0] = "PENDING";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["REJECTED"] = 1] = "REJECTED";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["FAILED"] = 2] = "FAILED";
+  ExternalRequestPromiseStatus[ExternalRequestPromiseStatus["COMPLETED"] = 3] = "COMPLETED";
+})(ExternalRequestPromiseStatus || (ExternalRequestPromiseStatus = {}));
+
+export let AccountExternalErrorCode;
+
+(function (AccountExternalErrorCode) {
+  AccountExternalErrorCode["INVALID_ADDRESS"] = "invalidToAccount";
+  AccountExternalErrorCode["KEYRING_ERROR"] = "keyringError";
+  AccountExternalErrorCode["UNKNOWN_ERROR"] = "unknownError";
+})(AccountExternalErrorCode || (AccountExternalErrorCode = {}));

package/background/handlers/Extension.d.ts

@@ -39,6 +39,8 @@ export default class Extension {
     private signingApproveSignature;
     private signingCancel;
     private signingIsLocked;
+    private qrIsLocked;
+    private qrSignSubstrate;
     private signingSubscribe;
     private windowOpen;
     private derive;

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 {};