@keplr-wallet/background 0.10.9 → 0.10.10

package/src/keyring/keyring.ts

@@ -3,7 +3,6 @@ import {
   Mnemonic,
   PrivKeySecp256k1,
   PubKeySecp256k1,
-  RNG,
 } from "@keplr-wallet/crypto";
 import { KVStore } from "@keplr-wallet/common";
 import { LedgerService } from "../ledger";
@@ -73,7 +72,6 @@ export class KeyRing {
     private readonly embedChainInfos: ChainInfo[],
     private readonly kvStore: KVStore,
     private readonly ledgerKeeper: LedgerService,
-    private readonly rng: RNG,
     private readonly crypto: CommonCrypto
   ) {
     this.loaded = false;
@@ -173,8 +171,15 @@ export class KeyRing {
     ];
   }
 
-  public getKey(chainId: string, defaultCoinType: number): Key {
-    return this.loadKey(this.computeKeyStoreCoinType(chainId, defaultCoinType));
+  public getKey(
+    chainId: string,
+    defaultCoinType: number,
+    useEthereumAddress: boolean
+  ): Key {
+    return this.loadKey(
+      this.computeKeyStoreCoinType(chainId, defaultCoinType),
+      useEthereumAddress
+    );
   }
 
   public getKeyStoreMeta(key: string): string {
@@ -200,8 +205,11 @@ export class KeyRing {
       : defaultCoinType;
   }
 
-  public getKeyFromCoinType(coinType: number): Key {
-    return this.loadKey(coinType);
+  public getKeyFromCoinType(
+    coinType: number,
+    useEthereumAddress: boolean
+  ): Key {
+    return this.loadKey(coinType, useEthereumAddress);
   }
 
   public async createMnemonicKey(
@@ -224,7 +232,6 @@ export class KeyRing {
 
     this.mnemonicMasterSeed = Mnemonic.generateMasterSeedFromMnemonic(mnemonic);
     this.keyStore = await KeyRing.CreateMnemonicKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       mnemonic,
@@ -262,7 +269,6 @@ export class KeyRing {
 
     this.privateKey = privateKey;
     this.keyStore = await KeyRing.CreatePrivateKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       privateKey,
@@ -305,7 +311,6 @@ export class KeyRing {
     );
 
     const keyStore = await KeyRing.CreateLedgerKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       this.ledgerPublicKey,
@@ -586,7 +591,7 @@ export class KeyRing {
     return this.getMultiKeyStoreInfo();
   }
 
-  private loadKey(coinType: number): Key {
+  private loadKey(coinType: number, useEthereumAddress: boolean = false): Key {
     if (this.status !== KeyRingStatus.UNLOCKED) {
       throw new KeplrError("keyring", 143, "Key ring is not unlocked");
     }
@@ -600,7 +605,7 @@ export class KeyRing {
         throw new KeplrError("keyring", 150, "Ledger public key not set");
       }
 
-      if (coinType === 60) {
+      if (useEthereumAddress) {
         throw new KeplrError(
           "keyring",
           152,
@@ -620,7 +625,7 @@ export class KeyRing {
       const privKey = this.loadPrivKey(coinType);
       const pubKey = privKey.getPubKey();
 
-      if (coinType === 60) {
+      if (useEthereumAddress) {
         // For Ethereum Key-Gen Only:
         const wallet = new Wallet(privKey.toBytes());
         const ethereumAddress = ETH.decoder(wallet.address);
@@ -697,7 +702,8 @@ export class KeyRing {
     env: Env,
     chainId: string,
     defaultCoinType: number,
-    message: Uint8Array
+    message: Uint8Array,
+    useEthereumSigning: boolean
   ): Promise<Uint8Array> {
     if (this.status !== KeyRingStatus.UNLOCKED) {
       throw new KeplrError("keyring", 143, "Key ring is not unlocked");
@@ -708,8 +714,7 @@ export class KeyRing {
     }
 
     // Sign with Evmos/Ethereum
-    const coinType = this.computeKeyStoreCoinType(chainId, defaultCoinType);
-    if (coinType === 60) {
+    if (useEthereumSigning) {
       return this.signEthereum(chainId, defaultCoinType, message);
     }
 
@@ -746,7 +751,7 @@ export class KeyRing {
     }
   }
 
-  public async signEthereum(
+  private async signEthereum(
     chainId: string,
     defaultCoinType: number,
     message: Uint8Array
@@ -768,14 +773,7 @@ export class KeyRing {
       );
     } else {
       const coinType = this.computeKeyStoreCoinType(chainId, defaultCoinType);
-      if (coinType !== 60) {
-        throw new KeplrError(
-          "keyring",
-          111,
-          "Invalid coin type passed in to Ethereum signing (expected 60)"
-        );
-      }
-
+      // Allow signing with Ethereum for chains with coinType !== 60
       const privKey = this.loadPrivKey(coinType);
 
       // Use ether js to sign Ethereum tx
@@ -841,7 +839,6 @@ export class KeyRing {
     }
 
     const keyStore = await KeyRing.CreateMnemonicKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       mnemonic,
@@ -873,7 +870,6 @@ export class KeyRing {
     }
 
     const keyStore = await KeyRing.CreatePrivateKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       privateKey,
@@ -908,7 +904,6 @@ export class KeyRing {
     const publicKey = await this.ledgerKeeper.getPublicKey(env, bip44HDPath);
 
     const keyStore = await KeyRing.CreateLedgerKeyStore(
-      this.rng,
       this.crypto,
       kdf,
       publicKey,
@@ -1041,7 +1036,6 @@ export class KeyRing {
   }
 
   private static async CreateMnemonicKeyStore(
-    rng: RNG,
     crypto: CommonCrypto,
     kdf: "scrypt" | "sha256" | "pbkdf2",
     mnemonic: string,
@@ -1050,7 +1044,6 @@ export class KeyRing {
     bip44HDPath: BIP44HDPath
   ): Promise<KeyStore> {
     return await Crypto.encrypt(
-      rng,
       crypto,
       kdf,
       "mnemonic",
@@ -1062,7 +1055,6 @@ export class KeyRing {
   }
 
   private static async CreatePrivateKeyStore(
-    rng: RNG,
     crypto: CommonCrypto,
     kdf: "scrypt" | "sha256" | "pbkdf2",
     privateKey: Uint8Array,
@@ -1070,7 +1062,6 @@ export class KeyRing {
     meta: Record<string, string>
   ): Promise<KeyStore> {
     return await Crypto.encrypt(
-      rng,
       crypto,
       kdf,
       "privateKey",
@@ -1081,7 +1072,6 @@ export class KeyRing {
   }
 
   private static async CreateLedgerKeyStore(
-    rng: RNG,
     crypto: CommonCrypto,
     kdf: "scrypt" | "sha256" | "pbkdf2",
     publicKey: Uint8Array,
@@ -1090,7 +1080,6 @@ export class KeyRing {
     bip44HDPath: BIP44HDPath
   ): Promise<KeyStore> {
     return await Crypto.encrypt(
-      rng,
       crypto,
       kdf,
       "ledger",

package/src/keyring/service.ts

@@ -1,6 +1,3 @@
-import { delay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import {
   Key,
   KeyRing,
@@ -34,39 +31,38 @@ import {
 } from "@cosmjs/launchpad";
 import { DirectSignResponse, makeSignBytes } from "@cosmjs/proto-signing";
 
-import { RNG } from "@keplr-wallet/crypto";
 import { SignDoc } from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
 import Long from "long";
 import { Buffer } from "buffer/";
 
-@singleton()
 export class KeyRingService {
-  private readonly keyRing: KeyRing;
+  private keyRing!: KeyRing;
+
+  protected interactionService!: InteractionService;
+  public chainsService!: ChainsService;
+  public permissionService!: PermissionService;
 
   constructor(
-    @inject(TYPES.KeyRingStore)
-    kvStore: KVStore,
-    @inject(TYPES.ChainsEmbedChainInfos)
-    embedChainInfos: ChainInfo[],
-    @inject(delay(() => InteractionService))
-    protected readonly interactionService: InteractionService,
-    @inject(delay(() => ChainsService))
-    public readonly chainsService: ChainsService,
-    @inject(delay(() => PermissionService))
-    public readonly permissionService: PermissionService,
-    @inject(LedgerService)
-    ledgerService: LedgerService,
-    @inject(TYPES.RNG)
-    protected readonly rng: RNG,
-    @inject(TYPES.CommonCrypto)
+    protected readonly kvStore: KVStore,
+    protected readonly embedChainInfos: ChainInfo[],
     protected readonly crypto: CommonCrypto
+  ) {}
+
+  init(
+    interactionService: InteractionService,
+    chainsService: ChainsService,
+    permissionService: PermissionService,
+    ledgerService: LedgerService
   ) {
+    this.interactionService = interactionService;
+    this.chainsService = chainsService;
+    this.permissionService = permissionService;
+
     this.keyRing = new KeyRing(
-      embedChainInfos,
-      kvStore,
+      this.embedChainInfos,
+      this.kvStore,
       ledgerService,
-      rng,
-      crypto
+      this.crypto
     );
   }
 
@@ -210,7 +206,8 @@ export class KeyRingService {
   async getKey(chainId: string): Promise<Key> {
     return this.keyRing.getKey(
       chainId,
-      await this.chainsService.getChainCoinType(chainId)
+      await this.chainsService.getChainCoinType(chainId),
+      (await this.chainsService.getChainEthereumKeyFeatures(chainId)).address
     );
   }
 
@@ -234,8 +231,15 @@ export class KeyRingService {
     }
   ): Promise<AminoSignResponse> {
     const coinType = await this.chainsService.getChainCoinType(chainId);
+    const ethereumKeyFeatures = await this.chainsService.getChainEthereumKeyFeatures(
+      chainId
+    );
 
-    const key = await this.keyRing.getKey(chainId, coinType);
+    const key = await this.keyRing.getKey(
+      chainId,
+      coinType,
+      ethereumKeyFeatures.address
+    );
     const bech32Prefix = (await this.chainsService.getChainInfo(chainId))
       .bech32Config.bech32PrefixAccAddr;
     const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
@@ -301,7 +305,8 @@ export class KeyRingService {
         env,
         chainId,
         coinType,
-        serializeSignDoc(newSignDoc)
+        serializeSignDoc(newSignDoc),
+        ethereumKeyFeatures.signing
       );
 
       return {
@@ -322,8 +327,15 @@ export class KeyRingService {
     signOptions: KeplrSignOptions
   ): Promise<DirectSignResponse> {
     const coinType = await this.chainsService.getChainCoinType(chainId);
+    const ethereumKeyFeatures = await this.chainsService.getChainEthereumKeyFeatures(
+      chainId
+    );
 
-    const key = await this.keyRing.getKey(chainId, coinType);
+    const key = await this.keyRing.getKey(
+      chainId,
+      coinType,
+      ethereumKeyFeatures.address
+    );
     const bech32Address = new Bech32Address(key.address).toBech32(
       (await this.chainsService.getChainInfo(chainId)).bech32Config
         .bech32PrefixAccAddr
@@ -361,7 +373,8 @@ export class KeyRingService {
         env,
         chainId,
         coinType,
-        makeSignBytes(cosmJSSignDoc)
+        makeSignBytes(cosmJSSignDoc),
+        ethereumKeyFeatures.signing
       );
 
       return {
@@ -380,8 +393,15 @@ export class KeyRingService {
     signature: StdSignature
   ): Promise<boolean> {
     const coinType = await this.chainsService.getChainCoinType(chainId);
+    const ethereumKeyFeatures = await this.chainsService.getChainEthereumKeyFeatures(
+      chainId
+    );
 
-    const key = await this.keyRing.getKey(chainId, coinType);
+    const key = await this.keyRing.getKey(
+      chainId,
+      coinType,
+      ethereumKeyFeatures.address
+    );
     const bech32Prefix = (await this.chainsService.getChainInfo(chainId))
       .bech32Config.bech32PrefixAccAddr;
     const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
@@ -420,7 +440,8 @@ export class KeyRingService {
       env,
       chainId,
       await this.chainsService.getChainCoinType(chainId),
-      message
+      message,
+      (await this.chainsService.getChainEthereumKeyFeatures(chainId)).signing
     );
   }
 
@@ -513,7 +534,10 @@ export class KeyRingService {
     const chainInfo = await this.chainsService.getChainInfo(chainId);
 
     for (const path of paths) {
-      const key = await this.keyRing.getKeyFromCoinType(path.coinType);
+      const key = await this.keyRing.getKeyFromCoinType(
+        path.coinType,
+        (await this.chainsService.getChainEthereumKeyFeatures(chainId)).address
+      );
       const bech32Address = new Bech32Address(key.address).toBech32(
         chainInfo.bech32Config.bech32PrefixAccAddr
       );

package/src/keyring/types.ts

@@ -1,3 +1,5 @@
+import { RNG } from "@keplr-wallet/crypto";
+
 export type CoinTypeForChain = {
   [identifier: string]: number;
 };
@@ -9,6 +11,7 @@ export type BIP44HDPath = {
 };
 
 export interface CommonCrypto {
+  rng: RNG;
   scrypt: (text: string, params: ScryptParams) => Promise<Uint8Array>;
 }
 

package/src/ledger/service.ts

@@ -1,6 +1,3 @@
-import { delay as diDelay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import { Ledger, LedgerWebHIDIniter, LedgerWebUSBIniter } from "./ledger";
 
 import delay from "delay";
@@ -12,18 +9,15 @@ import { InteractionService } from "../interaction";
 import { LedgerOptions } from "./options";
 import { Buffer } from "buffer/";
 
-@singleton()
 export class LedgerService {
   private previousInitAborter: ((e: Error) => void) | undefined;
 
   protected options: LedgerOptions;
 
+  protected interactionService!: InteractionService;
+
   constructor(
-    @inject(TYPES.LedgerStore)
     protected readonly kvStore: KVStore,
-    @inject(diDelay(() => InteractionService))
-    protected readonly interactionService: InteractionService,
-    @inject(TYPES.LedgerOptions)
     options: Partial<LedgerOptions>
   ) {
     this.options = {
@@ -39,6 +33,10 @@ export class LedgerService {
     }
   }
 
+  init(interactionService: InteractionService) {
+    this.interactionService = interactionService;
+  }
+
   async getPublicKey(env: Env, bip44HDPath: BIP44HDPath): Promise<Uint8Array> {
     return await this.useLedger(env, async (ledger, retryCount) => {
       try {

package/src/permission/service.ts

@@ -1,6 +1,3 @@
-import { delay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import { InteractionService } from "../interaction";
 import { Env, KeplrError } from "@keplr-wallet/router";
 import {
@@ -13,7 +10,6 @@ import { ChainsService } from "../chains";
 import { KeyRingService } from "../keyring";
 import { ChainIdHelper } from "@keplr-wallet/cosmos";
 
-@singleton()
 export class PermissionService {
   protected permissionMap: {
     [chainIdentifier: string]:
@@ -29,16 +25,12 @@ export class PermissionService {
 
   protected privilegedOrigins: Map<string, boolean> = new Map();
 
+  protected interactionService!: InteractionService;
+  protected chainsService!: ChainsService;
+  protected keyRingService!: KeyRingService;
+
   constructor(
-    @inject(TYPES.PermissionStore)
     protected readonly kvStore: KVStore,
-    @inject(delay(() => InteractionService))
-    protected readonly interactionService: InteractionService,
-    @inject(ChainsService)
-    protected readonly chainsService: ChainsService,
-    @inject(delay(() => KeyRingService))
-    protected readonly keyRingService: KeyRingService,
-    @inject(TYPES.PermissionServicePrivilegedOrigins)
     privilegedOrigins: string[]
   ) {
     for (const origin of privilegedOrigins) {
@@ -46,6 +38,16 @@ export class PermissionService {
     }
 
     this.restore();
+  }
+
+  init(
+    interactionService: InteractionService,
+    chainsService: ChainsService,
+    keyRingService: KeyRingService
+  ) {
+    this.interactionService = interactionService;
+    this.chainsService = chainsService;
+    this.keyRingService = keyRingService;
 
     this.chainsService.addChainRemovedHandler(this.onChainRemoved);
   }

package/src/persistent-memory/service.ts

@@ -1,9 +1,10 @@
-import { singleton } from "tsyringe";
-
-@singleton()
 export class PersistentMemoryService {
   data: any = {};
 
+  init() {
+    // noop
+  }
+
   set(data: any) {
     this.data = { ...this.data, ...data };
   }

package/src/secret-wasm/service.ts

@@ -1,6 +1,3 @@
-import { delay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import { EnigmaUtils } from "secretjs";
 import { KeyRingService } from "../keyring";
 import { ChainsService } from "../chains";
@@ -10,10 +7,8 @@ import { KVStore, Debouncer } from "@keplr-wallet/common";
 import { ChainInfo } from "@keplr-wallet/types";
 import { Bech32Address } from "@keplr-wallet/cosmos";
 import { Env, KeplrError } from "@keplr-wallet/router";
-
 import { Buffer } from "buffer/";
 
-@singleton()
 export class SecretWasmService {
   protected debouncerMap: Map<
     string,
@@ -26,16 +21,21 @@ export class SecretWasmService {
 
   protected cacheEnigmaUtils: Map<string, EnigmaUtils> = new Map();
 
-  constructor(
-    @inject(TYPES.SecretWasmStore)
-    protected readonly kvStore: KVStore,
-    @inject(ChainsService)
-    protected readonly chainsService: ChainsService,
-    @inject(delay(() => KeyRingService))
-    protected readonly keyRingService: KeyRingService,
-    @inject(delay(() => PermissionService))
-    public readonly permissionService: PermissionService
+  protected chainsService!: ChainsService;
+  protected keyRingService!: KeyRingService;
+  public permissionService!: PermissionService;
+
+  constructor(protected readonly kvStore: KVStore) {}
+
+  init(
+    chainsService: ChainsService,
+    keyRingService: KeyRingService,
+    permissionService: PermissionService
   ) {
+    this.chainsService = chainsService;
+    this.keyRingService = keyRingService;
+    this.permissionService = permissionService;
+
     this.chainsService.addChainRemovedHandler(this.onChainRemoved);
   }
 

package/src/tokens/service.ts

@@ -1,6 +1,3 @@
-import { delay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import { Env, KeplrError } from "@keplr-wallet/router";
 import {
   ChainInfo,
@@ -25,20 +22,25 @@ import { Buffer } from "buffer/";
 import { SuggestTokenMsg } from "./messages";
 import { getSecret20ViewingKeyPermissionType } from "./types";
 
-@singleton()
 export class TokensService {
-  constructor(
-    @inject(TYPES.TokensStore)
-    protected readonly kvStore: KVStore,
-    @inject(delay(() => InteractionService))
-    protected readonly interactionService: InteractionService,
-    @inject(delay(() => PermissionService))
-    public readonly permissionService: PermissionService,
-    @inject(ChainsService)
-    protected readonly chainsService: ChainsService,
-    @inject(delay(() => KeyRingService))
-    protected readonly keyRingService: KeyRingService
+  protected interactionService!: InteractionService;
+  public permissionService!: PermissionService;
+  protected chainsService!: ChainsService;
+  protected keyRingService!: KeyRingService;
+
+  constructor(protected readonly kvStore: KVStore) {}
+
+  init(
+    interactionService: InteractionService,
+    permissionService: PermissionService,
+    chainsService: ChainsService,
+    keyRingService: KeyRingService
   ) {
+    this.interactionService = interactionService;
+    this.permissionService = permissionService;
+    this.chainsService = chainsService;
+    this.keyRingService = keyRingService;
+
     this.chainsService.addChainRemovedHandler(this.onChainRemoved);
   }
 

package/src/tx/service.ts

@@ -1,6 +1,3 @@
-import { delay, inject, singleton } from "tsyringe";
-import { TYPES } from "../types";
-
 import Axios from "axios";
 import { ChainsService } from "../chains";
 import { PermissionService } from "../permission";
@@ -22,16 +19,16 @@ interface ABCIMessageLog {
   // Events StringEvents
 }
 
-@singleton()
 export class BackgroundTxService {
-  constructor(
-    @inject(delay(() => ChainsService))
-    protected readonly chainsService: ChainsService,
-    @inject(delay(() => PermissionService))
-    public readonly permissionService: PermissionService,
-    @inject(TYPES.Notification)
-    protected readonly notification: Notification
-  ) {}
+  protected chainsService!: ChainsService;
+  public permissionService!: PermissionService;
+
+  constructor(protected readonly notification: Notification) {}
+
+  init(chainsService: ChainsService, permissionService: PermissionService) {
+    this.chainsService = chainsService;
+    this.permissionService = permissionService;
+  }
 
   async sendTx(
     chainId: string,

package/src/updater/service.ts

@@ -1,19 +1,17 @@
-import { inject, singleton, delay } from "tsyringe";
-import { TYPES } from "../types";
-
 import { ChainInfo } from "@keplr-wallet/types";
 import Axios from "axios";
 import { KVStore } from "@keplr-wallet/common";
 import { ChainIdHelper } from "@keplr-wallet/cosmos";
 import { ChainsService } from "../chains";
 
-@singleton()
 export class ChainUpdaterService {
-  constructor(
-    @inject(TYPES.UpdaterStore) protected readonly kvStore: KVStore,
-    @inject(delay(() => ChainsService))
-    protected readonly chainsService: ChainsService
-  ) {}
+  protected chainsService!: ChainsService;
+
+  constructor(protected readonly kvStore: KVStore) {}
+
+  init(chainsService: ChainsService) {
+    this.chainsService = chainsService;
+  }
 
   async putUpdatedPropertyToChainInfo(
     chainInfo: ChainInfo

package/tsconfig.json

@@ -4,7 +4,6 @@
     "baseUrl": ".",
     "outDir": "build",
     "declaration": true,
-    "rootDir": "src",
-    "emitDecoratorMetadata": true
+    "rootDir": "src"
   }
 }

package/build/types.d.ts

@@ -1,19 +0,0 @@
-export declare const TYPES: {
-    ChainsStore: symbol;
-    ChainsEmbedChainInfos: symbol;
-    InteractionStore: symbol;
-    KeyRingStore: symbol;
-    LedgerStore: symbol;
-    LedgerOptions: symbol;
-    PermissionStore: symbol;
-    PermissionServicePrivilegedOrigins: symbol;
-    PersistentMemoryStore: symbol;
-    SecretWasmStore: symbol;
-    TokensStore: symbol;
-    TxStore: symbol;
-    UpdaterStore: symbol;
-    EventMsgRequester: symbol;
-    RNG: symbol;
-    CommonCrypto: symbol;
-    Notification: symbol;
-};