@subwallet/extension-base 0.3.6-0

package/build/background/KoniTypes.d.ts

@@ -0,0 +1,462 @@
+import { AuthUrls, Resolver } from '@subwallet/extension-base/background/handlers/State';
+import { AccountJson, AuthorizeRequest, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestBatchRestore, RequestCurrentAccountAddress, RequestDeriveCreate, RequestJsonRestore, ResponseAuthorizeList, SeedLengths } from '@subwallet/extension-base/background/types';
+import { InjectedAccount, MetadataDefBase } from '@subwallet/extension-inject/types';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
+import { Registry } from '@polkadot/types/types';
+import { Keyring } from '@polkadot/ui-keyring';
+import { BN } from '@polkadot/util';
+import { KeypairType } from '@polkadot/util-crypto/types';
+export declare enum ApiInitStatus {
+    SUCCESS = 0,
+    ALREADY_EXIST = 1,
+    NOT_SUPPORT = 2
+}
+export interface AuthRequestV2 extends Resolver<ResultResolver> {
+    id: string;
+    idStr: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export interface RequestAuthorizeApproveV2 {
+    id: string;
+    accounts: string[];
+}
+export interface RequestAuthorizationAll {
+    connectValue: boolean;
+}
+export interface RequestAuthorization extends RequestAuthorizationAll {
+    url: string;
+}
+export interface RequestAuthorizationPerAccount extends RequestAuthorization {
+    address: string;
+}
+export interface ResultResolver {
+    result: boolean;
+    accounts: string[];
+}
+export interface RejectResolver {
+    error: Error;
+    accounts: string[];
+}
+export interface RequestForgetSite {
+    url: string;
+}
+export interface StakingRewardItem {
+    state: APIItemState;
+    name: string;
+    chainId: string;
+    latestReward?: string;
+    totalReward?: string;
+    totalSlash?: string;
+    smartContract?: string;
+}
+export interface StakingRewardJson {
+    details: Array<StakingRewardItem>;
+}
+export interface StakingItem {
+    name: string;
+    chainId: string;
+    balance?: string;
+    nativeToken: string;
+    unit?: string;
+    state: APIItemState;
+}
+export interface StakingJson {
+    ready?: boolean;
+    details: Record<string, StakingItem>;
+}
+export interface PriceJson {
+    ready?: boolean;
+    currency: string;
+    priceMap: Record<string, number>;
+    tokenPriceMap: Record<string, number>;
+}
+export declare enum APIItemState {
+    PENDING = "pending",
+    READY = "ready",
+    CACHED = "cached",
+    ERROR = "error",
+    NOT_SUPPORT = "not_support"
+}
+export declare enum RMRK_VER {
+    VER_1 = "1.0.0",
+    VER_2 = "2.0.0"
+}
+export declare enum CrowdloanParaState {
+    ONGOING = "ongoing",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+export interface NftTransferExtra {
+    cronUpdate: boolean;
+    forceUpdate: boolean;
+    selectedNftCollection?: NftCollection;
+    nftItems?: NftItem[];
+}
+export interface NftItem {
+    id?: string;
+    name?: string;
+    image?: string;
+    external_url?: string;
+    rarity?: string;
+    collectionId?: string;
+    description?: string;
+    properties?: Record<any, any> | null;
+    chain?: string;
+    rmrk_ver?: RMRK_VER;
+}
+export interface NftCollection {
+    collectionId: string;
+    collectionName?: string;
+    image?: string;
+    chain?: string;
+    itemCount?: number;
+}
+export interface NftJson {
+    total: number;
+    nftList: Array<NftItem>;
+}
+export interface NftCollectionJson {
+    ready: boolean;
+    nftCollectionList: Array<NftCollection>;
+}
+export interface TokenBalanceRaw {
+    reserved: BN;
+    frozen: BN;
+    free: BN;
+}
+export interface BalanceChildItem {
+    reserved: string;
+    frozen: string;
+    free: string;
+    decimals: number;
+}
+export interface BalanceItem {
+    state: APIItemState;
+    free: string;
+    reserved: string;
+    miscFrozen: string;
+    feeFrozen: string;
+    children?: Record<string, BalanceChildItem>;
+}
+export interface BalanceJson {
+    details: Record<string, BalanceItem>;
+}
+export interface CrowdloanItem {
+    state: APIItemState;
+    paraState?: CrowdloanParaState;
+    contribute: string;
+}
+export interface CrowdloanJson {
+    details: Record<string, CrowdloanItem>;
+}
+export interface ChainRegistry {
+    chainDecimals: number[];
+    chainTokens: string[];
+    tokenMap: Record<string, TokenInfo>;
+}
+export interface DefaultFormatBalance {
+    decimals?: number[] | number;
+    unit?: string[] | string;
+}
+export interface ApiState {
+    apiDefaultTx: SubmittableExtrinsicFunction;
+    apiDefaultTxSudo: SubmittableExtrinsicFunction;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isDevelopment?: boolean;
+    isEthereum?: boolean;
+    specName: string;
+    specVersion: string;
+    systemChain: string;
+    systemName: string;
+    systemVersion: string;
+    registry: Registry;
+    defaultFormatBalance: DefaultFormatBalance;
+}
+export interface ApiProps extends ApiState {
+    api: ApiPromise;
+    apiError?: string;
+    apiUrl: string;
+    isNotSupport?: boolean;
+    isApiReadyOnce: boolean;
+    isApiConnected: boolean;
+    isEthereum: boolean;
+    isApiInitialized: boolean;
+    isReady: Promise<ApiProps>;
+    apiRetry?: number;
+    recoverConnect?: () => void;
+    useEvmAddress?: boolean;
+}
+export declare type NetWorkGroup = 'RELAY_CHAIN' | 'POLKADOT_PARACHAIN' | 'KUSAMA_PARACHAIN' | 'MAIN_NET' | 'TEST_NET' | 'UNKNOWN';
+export interface NetWorkInfo {
+    chain: string;
+    genesisHash: string;
+    icon?: string;
+    ss58Format: number;
+    chainType?: 'substrate' | 'ethereum';
+    provider: string;
+    groups: NetWorkGroup[];
+    paraId?: number;
+    isEthereum?: boolean;
+    nativeToken?: string;
+    crowdloanUrl?: string;
+    decimals?: number;
+}
+export interface DonateInfo {
+    key: string;
+    name: string;
+    value: string;
+    icon: string;
+    link: string;
+}
+export interface NetWorkMetadataDef extends MetadataDefBase {
+    networkKey: string;
+    groups: NetWorkGroup[];
+    isEthereum: boolean;
+    paraId?: number;
+    isAvailable: boolean;
+}
+export declare type CurrentNetworkInfo = {
+    networkKey: string;
+    networkPrefix: number;
+    icon: string;
+    genesisHash: string;
+    isEthereum: boolean;
+};
+export declare type TokenInfo = {
+    isMainToken: boolean;
+    symbol: string;
+    erc20Address?: string;
+    assetIndex?: number;
+    decimals: number;
+    name: string;
+    coinGeckoKey?: string;
+    specialOption?: object;
+};
+export interface AccountsWithCurrentAddress {
+    accounts: AccountJson[];
+    currentAddress?: string;
+    isShowBalance?: boolean;
+    allAccountLogo?: string;
+}
+export interface CurrentAccountInfo {
+    address: string;
+}
+export interface RequestSettingsType {
+    isShowBalance: boolean;
+    accountAllLogo: string;
+}
+export interface ResponseSettingsType {
+    isShowBalance: boolean;
+    accountAllLogo: string;
+}
+export interface RandomTestRequest {
+    start: number;
+    end: number;
+}
+export declare type PdotApi = {
+    keyring: Keyring;
+    apisMap: Record<string, ApiProps>;
+};
+export interface BackgroundWindow extends Window {
+    pdotApi: PdotApi;
+}
+export interface TransactionHistoryItemType {
+    time: number;
+    networkKey: string;
+    change: string;
+    fee?: string;
+    isSuccess: boolean;
+    action: 'send' | 'received';
+    extrinsicHash: string;
+}
+export interface RequestTransactionHistoryGet {
+    address: string;
+    networkKey: string;
+}
+export interface RequestTransactionHistoryGetByMultiNetworks {
+    address: string;
+    networkKeys: string[];
+}
+export interface RequestTransactionHistoryAdd {
+    address: string;
+    networkKey: string;
+    item: TransactionHistoryItemType;
+}
+export interface RequestApi {
+    networkKey: string;
+}
+export interface RequestAccountExportPrivateKey {
+    address: string;
+    password: string;
+}
+export interface ResponseAccountExportPrivateKey {
+    privateKey: string;
+}
+export interface RequestSeedCreateV2 {
+    length?: SeedLengths;
+    seed?: string;
+    types?: Array<KeypairType>;
+}
+export interface RequestSeedValidateV2 {
+    suri: string;
+    types?: Array<KeypairType>;
+}
+export interface RequestAccountCreateSuriV2 {
+    name: string;
+    genesisHash?: string | null;
+    password: string;
+    suri: string;
+    types?: Array<KeypairType>;
+}
+export interface ResponseSeedCreateV2 {
+    seed: string;
+    addressMap: Record<KeypairType, string>;
+}
+export interface RequestCheckTransfer {
+    networkKey: string;
+    from: string;
+    to: string;
+    value?: string;
+    transferAll?: boolean;
+    token?: string;
+}
+export interface RequestTransfer extends RequestCheckTransfer {
+    password: string;
+}
+export declare type ResponseSeedValidateV2 = ResponseSeedCreateV2;
+export declare type ResponseAccountCreateSuriV2 = Record<KeypairType, string>;
+export declare type AccountRef = Array<string>;
+export declare type AccountRefMap = Record<string, AccountRef>;
+export declare type RequestPrice = null;
+export declare type RequestSubscribePrice = null;
+export declare type RequestBalance = null;
+export declare type RequestSubscribeBalance = null;
+export declare type RequestSubscribeBalancesVisibility = null;
+export declare type RequestCrowdloan = null;
+export declare type RequestSubscribeCrowdloan = null;
+export declare type RequestSubscribeNft = null;
+export declare type RequestSubscribeStaking = null;
+export declare type RequestSubscribeStakingReward = null;
+export declare type RequestNftForceUpdate = {
+    collectionId: string;
+    nft: NftItem;
+    isSendingSelf: boolean;
+    chain: string;
+};
+export declare enum TransferErrorCode {
+    INVALID_FROM_ADDRESS = "invalidFromAccount",
+    INVALID_TO_ADDRESS = "invalidToAccount",
+    NOT_ENOUGH_VALUE = "notEnoughValue",
+    INVALID_VALUE = "invalidValue",
+    INVALID_TOKEN = "invalidToken",
+    KEYRING_ERROR = "keyringError",
+    TRANSFER_ERROR = "transferError",
+    TIMEOUT = "timeout"
+}
+export declare type TransferError = {
+    code: TransferErrorCode;
+    data?: object;
+    message: string;
+};
+export interface ResponseCheckTransfer {
+    errors?: Array<TransferError>;
+    fromAccountFree: string;
+    toAccountFree: string;
+    estimateFee?: string;
+}
+export declare enum TransferStep {
+    READY = "ready",
+    START = "start",
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface ResponseTransfer {
+    step: TransferStep;
+    errors?: Array<TransferError>;
+    extrinsicHash?: string;
+    extrinsicStatus?: string;
+    data?: object;
+}
+export interface EvmNftTransactionRequest {
+    networkKey: string;
+    senderAddress: string;
+    recipientAddress: string;
+    params: Record<string, any>;
+}
+export interface EvmNftTransaction {
+    tx: Record<string, any> | null;
+    estimatedFee: string | null;
+}
+export interface EvmNftSubmitTransaction {
+    senderAddress: string;
+    password: string;
+    recipientAddress: string;
+    networkKey: string;
+    rawTransaction: Record<string, any>;
+}
+export interface EvmNftTransactionResponse {
+    passwordError?: string | null;
+    callHash?: string;
+    status?: boolean;
+    transactionHash?: string;
+    txError?: boolean;
+    isSendingSelf: boolean;
+}
+export interface KoniRequestSignatures {
+    'pri(evmNft.submitTransaction)': [EvmNftSubmitTransaction, EvmNftTransactionResponse, EvmNftTransactionResponse];
+    'pri(evmNft.getTransaction)': [EvmNftTransactionRequest, EvmNftTransaction];
+    'pri(nftTransfer.setNftTransfer)': [NftTransferExtra, boolean];
+    'pri(nftTransfer.getNftTransfer)': [null, NftTransferExtra];
+    'pri(nftTransfer.getSubscription)': [null, NftTransferExtra, NftTransferExtra];
+    'pri(nft.forceUpdate)': [RequestNftForceUpdate, boolean];
+    'pri(api.init)': [RequestApi, ApiInitStatus];
+    'pri(staking.getStaking)': [null, StakingJson];
+    'pri(staking.getSubscription)': [RequestSubscribeStaking, StakingJson, StakingJson];
+    'pri(stakingReward.getStakingReward)': [null, StakingRewardJson];
+    'pri(stakingReward.getSubscription)': [RequestSubscribeStakingReward, StakingRewardJson, StakingRewardJson];
+    'pri(nft.getNft)': [null, NftJson];
+    'pri(nft.getSubscription)': [RequestSubscribeNft, NftJson, NftJson];
+    'pri(nftCollection.getNftCollection)': [null, NftCollectionJson];
+    'pri(nftCollection.getSubscription)': [null, NftCollectionJson, NftCollectionJson];
+    'pri(price.getPrice)': [RequestPrice, PriceJson];
+    'pri(price.getSubscription)': [RequestSubscribePrice, PriceJson, PriceJson];
+    'pri(balance.getBalance)': [RequestBalance, BalanceJson];
+    'pri(balance.getSubscription)': [RequestSubscribeBalance, BalanceJson, BalanceJson];
+    'pri(crowdloan.getCrowdloan)': [RequestCrowdloan, CrowdloanJson];
+    'pri(crowdloan.getSubscription)': [RequestSubscribeCrowdloan, CrowdloanJson, CrowdloanJson];
+    'pri(authorize.listV2)': [null, ResponseAuthorizeList];
+    'pri(authorize.requestsV2)': [RequestAuthorizeSubscribe, boolean, AuthorizeRequest[]];
+    'pri(authorize.approveV2)': [RequestAuthorizeApproveV2, boolean];
+    'pri(authorize.changeSiteAll)': [RequestAuthorizationAll, boolean, AuthUrls];
+    'pri(authorize.changeSite)': [RequestAuthorization, boolean, AuthUrls];
+    'pri(authorize.changeSitePerAccount)': [RequestAuthorizationPerAccount, boolean, AuthUrls];
+    'pri(authorize.forgetSite)': [RequestForgetSite, boolean, AuthUrls];
+    'pri(authorize.forgetAllSite)': [null, boolean, AuthUrls];
+    'pri(authorize.rejectV2)': [RequestAuthorizeReject, boolean];
+    'pri(seed.createV2)': [RequestSeedCreateV2, ResponseSeedCreateV2];
+    'pri(seed.validateV2)': [RequestSeedValidateV2, ResponseSeedValidateV2];
+    'pri(accounts.create.suriV2)': [RequestAccountCreateSuriV2, ResponseAccountCreateSuriV2];
+    'pri(accounts.checkTransfer)': [RequestCheckTransfer, ResponseCheckTransfer];
+    'pri(accounts.transfer)': [RequestTransfer, Array<TransferError>, ResponseTransfer];
+    'pri(derivation.createV2)': [RequestDeriveCreate, boolean];
+    'pri(json.restoreV2)': [RequestJsonRestore, void];
+    'pri(json.batchRestoreV2)': [RequestBatchRestore, void];
+    'pri(accounts.exportPrivateKey)': [RequestAccountExportPrivateKey, ResponseAccountExportPrivateKey];
+    'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, boolean, AccountsWithCurrentAddress];
+    'pri(accounts.triggerSubscription)': [null, boolean];
+    'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, boolean, CurrentAccountInfo];
+    'pri(currentAccount.changeBalancesVisibility)': [null, boolean, ResponseSettingsType];
+    'pri(currentAccount.subscribeSettings)': [null, ResponseSettingsType, ResponseSettingsType];
+    'pri(currentAccount.saveAccountAllLogo)': [string, boolean, ResponseSettingsType];
+    'pri(networkMetadata.list)': [null, NetWorkMetadataDef[]];
+    'pri(chainRegistry.getSubscription)': [null, Record<string, ChainRegistry>, Record<string, ChainRegistry>];
+    'pri(transaction.history.getSubscription)': [null, Record<string, TransactionHistoryItemType[]>, Record<string, TransactionHistoryItemType[]>];
+    'pri(transaction.history.add)': [RequestTransactionHistoryAdd, boolean, TransactionHistoryItemType[]];
+    'pub(utils.getRandom)': [RandomTestRequest, number];
+    'pub(accounts.listV2)': [RequestAccountList, InjectedAccount[]];
+    'pub(accounts.subscribeV2)': [RequestAccountSubscribe, boolean, InjectedAccount[]];
+}

package/build/background/KoniTypes.js

@@ -0,0 +1,57 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export let ApiInitStatus;
+
+(function (ApiInitStatus) {
+  ApiInitStatus[ApiInitStatus["SUCCESS"] = 0] = "SUCCESS";
+  ApiInitStatus[ApiInitStatus["ALREADY_EXIST"] = 1] = "ALREADY_EXIST";
+  ApiInitStatus[ApiInitStatus["NOT_SUPPORT"] = 2] = "NOT_SUPPORT";
+})(ApiInitStatus || (ApiInitStatus = {}));
+
+export let APIItemState;
+
+(function (APIItemState) {
+  APIItemState["PENDING"] = "pending";
+  APIItemState["READY"] = "ready";
+  APIItemState["CACHED"] = "cached";
+  APIItemState["ERROR"] = "error";
+  APIItemState["NOT_SUPPORT"] = "not_support";
+})(APIItemState || (APIItemState = {}));
+
+export let RMRK_VER;
+
+(function (RMRK_VER) {
+  RMRK_VER["VER_1"] = "1.0.0";
+  RMRK_VER["VER_2"] = "2.0.0";
+})(RMRK_VER || (RMRK_VER = {}));
+
+export let CrowdloanParaState;
+
+(function (CrowdloanParaState) {
+  CrowdloanParaState["ONGOING"] = "ongoing";
+  CrowdloanParaState["COMPLETED"] = "completed";
+  CrowdloanParaState["FAILED"] = "failed";
+})(CrowdloanParaState || (CrowdloanParaState = {}));
+
+export let 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 || (TransferErrorCode = {}));
+
+export let TransferStep;
+
+(function (TransferStep) {
+  TransferStep["READY"] = "ready";
+  TransferStep["START"] = "start";
+  TransferStep["PROCESSING"] = "processing";
+  TransferStep["SUCCESS"] = "success";
+  TransferStep["ERROR"] = "error";
+})(TransferStep || (TransferStep = {}));

package/build/background/RequestBytesSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@polkadot/keyring/types';
+import type { SignerPayloadRaw } from '@polkadot/types/types';
+import type { HexString } from '@polkadot/util/types';
+import type { RequestSign } from './types';
+import { TypeRegistry } from '@polkadot/types';
+export default class RequestBytesSign implements RequestSign {
+    readonly payload: SignerPayloadRaw;
+    constructor(payload: SignerPayloadRaw);
+    sign(_registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/build/background/RequestBytesSign.js

@@ -0,0 +1,16 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { wrapBytes } from '@subwallet/extension-dapp/wrapBytes';
+import { u8aToHex } from '@polkadot/util';
+export default class RequestBytesSign {
+  constructor(payload) {
+    this.payload = payload;
+  }
+
+  sign(_registry, pair) {
+    return {
+      signature: u8aToHex(pair.sign(wrapBytes(this.payload.data)))
+    };
+  }
+
+}

package/build/background/RequestExtrinsicSign.d.ts

@@ -0,0 +1,12 @@
+import type { KeyringPair } from '@polkadot/keyring/types';
+import type { SignerPayloadJSON } from '@polkadot/types/types';
+import type { HexString } from '@polkadot/util/types';
+import type { RequestSign } from './types';
+import { TypeRegistry } from '@polkadot/types';
+export default class RequestExtrinsicSign implements RequestSign {
+    readonly payload: SignerPayloadJSON;
+    constructor(payload: SignerPayloadJSON);
+    sign(registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}

package/build/background/RequestExtrinsicSign.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export default class RequestExtrinsicSign {
+  constructor(payload) {
+    this.payload = payload;
+  }
+
+  sign(registry, pair) {
+    return registry.createType('ExtrinsicPayload', this.payload, {
+      version: this.payload.version
+    }).sign(pair);
+  }
+
+}

package/build/background/handlers/Extension.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="chrome" />
+import type { KeypairType } from '@polkadot/util-crypto/types';
+import type { MessageTypes, RequestTypes, ResponseType } from '../types';
+import State from './State';
+export declare const SEED_DEFAULT_LENGTH = 12;
+export declare const SEED_LENGTHS: number[];
+export declare const ETH_DERIVE_DEFAULT = "/m/44'/60'/0'/0/0";
+export declare function getSuri(seed: string, type?: KeypairType): string;
+export default class Extension {
+    #private;
+    constructor(state: State);
+    private accountsCreateExternal;
+    private accountsCreateHardware;
+    private accountsCreateSuri;
+    private accountsChangePassword;
+    private accountsEdit;
+    private accountsExport;
+    private accountsForget;
+    private refreshAccountPasswordCache;
+    private accountsShow;
+    private accountsTie;
+    private accountsValidate;
+    private accountsSubscribe;
+    private authorizeApprove;
+    private getAuthList;
+    private authorizeReject;
+    private authorizeSubscribe;
+    private metadataApprove;
+    private metadataGet;
+    private metadataList;
+    private metadataReject;
+    private metadataSubscribe;
+    private jsonRestore;
+    private batchRestore;
+    private jsonGetAccountInfo;
+    private seedCreate;
+    private seedValidate;
+    private signingApprovePassword;
+    private signingApproveSignature;
+    private signingCancel;
+    private signingIsLocked;
+    private signingSubscribe;
+    private windowOpen;
+    private derive;
+    private derivationValidate;
+    private derivationCreate;
+    private toggleAuthorization;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
+}