@keplr-wallet/background 0.12.20 → 0.12.21-rc.0

package/src/keyring-cosmos/messages.ts

@@ -255,6 +255,10 @@ export class PrivilegeCosmosSignAminoWithdrawRewardsMsg extends Message<AminoSig
     }
   }
 
+  override approveExternal(): boolean {
+    return true;
+  }
+
   route(): string {
     return ROUTE;
   }
@@ -264,6 +268,59 @@ export class PrivilegeCosmosSignAminoWithdrawRewardsMsg extends Message<AminoSig
   }
 }
 
+export class PrivilegeCosmosSignAminoDelegateMsg extends Message<AminoSignResponse> {
+  public static type() {
+    return "PrivilegeCosmosSignAminoDelegate";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly signer: string,
+    public readonly signDoc: StdSignDoc
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new KeplrError("keyring", 270, "chain id not set");
+    }
+
+    if (!this.signer) {
+      throw new KeplrError("keyring", 230, "signer not set");
+    }
+
+    // Validate bech32 address.
+    Bech32Address.validate(this.signer);
+
+    // Check and validate the ADR-36 sign doc.
+    // ADR-36 sign doc doesn't have the chain id
+    if (!checkAndValidateADR36AminoSignDoc(this.signDoc)) {
+      if (this.signDoc.chain_id !== this.chainId) {
+        throw new KeplrError(
+          "keyring",
+          234,
+          "Chain id in the message is not matched with the requested chain id"
+        );
+      }
+    } else {
+      throw new Error("Can't use ADR-36 sign doc");
+    }
+  }
+
+  override approveExternal(): boolean {
+    return true;
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return PrivilegeCosmosSignAminoDelegateMsg.type();
+  }
+}
+
 export class RequestCosmosSignAminoADR36Msg extends Message<StdSignature> {
   public static type() {
     return "request-cosmos-sign-amino-adr-36";

package/src/keyring-cosmos/service.ts

@@ -37,7 +37,8 @@ export class KeyRingCosmosService {
     protected readonly keyRingService: KeyRingService,
     protected readonly interactionService: InteractionService,
     protected readonly chainsUIService: ChainsUIService,
-    protected readonly analyticsService: AnalyticsService
+    protected readonly analyticsService: AnalyticsService,
+    protected readonly msgPrivilegedOrigins: string[]
   ) {}
 
   async init() {
@@ -283,12 +284,18 @@ export class KeyRingCosmosService {
   }
 
   async privilegeSignAminoWithdrawRewards(
+    env: Env,
+    origin: string,
     chainId: string,
     signer: string,
     signDoc: StdSignDoc
   ) {
     // TODO: 이 기능은 ledger에서는 사용할 수 없고 어케 이 문제를 해결할지도 아직 명확하지 않음.
 
+    if (!env.isInternalMsg && !this.msgPrivilegedOrigins.includes(origin)) {
+      throw new Error("Permission Rejected");
+    }
+
     const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
 
     const vaultId = this.keyRingService.selectedVaultId;
@@ -358,8 +365,8 @@ export class KeyRingCosmosService {
 
       this.analyticsService.logEventIgnoreError("tx_signed", {
         chainId,
-        isInternal: true,
-        origin: new URL(browser.runtime.getURL("")).origin,
+        isInternal: env.isInternalMsg,
+        origin,
         signMode: "amino",
         privileged: "withdrawRewards",
       });
@@ -373,6 +380,103 @@ export class KeyRingCosmosService {
     }
   }
 
+  async privilegeSignAminoDelegate(
+    env: Env,
+    origin: string,
+    chainId: string,
+    signer: string,
+    signDoc: StdSignDoc
+  ) {
+    // TODO: 이 기능은 ledger에서는 사용할 수 없고 어케 이 문제를 해결할지도 아직 명확하지 않음.
+
+    if (!env.isInternalMsg && !this.msgPrivilegedOrigins.includes(origin)) {
+      throw new Error("Permission Rejected");
+    }
+
+    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
+
+    const vaultId = this.keyRingService.selectedVaultId;
+
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+
+    const keyInfo = this.keyRingService.getKeyInfo(vaultId);
+    if (!keyInfo) {
+      throw new Error("Null key info");
+    }
+
+    if (isEthermintLike && keyInfo.type === "ledger") {
+      KeyRingCosmosService.throwErrorIfEthermintWithLedgerButNotSupported(
+        chainId
+      );
+    }
+
+    signDoc = {
+      ...signDoc,
+      memo: escapeHTML(signDoc.memo),
+    };
+
+    signDoc = trimAminoSignDoc(signDoc);
+    signDoc = sortObjectByKey(signDoc);
+
+    const key = await this.getKey(vaultId, chainId);
+    const bech32Prefix =
+      this.chainsService.getChainInfoOrThrow(chainId).bech32Config
+        .bech32PrefixAccAddr;
+    const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
+    if (signer !== bech32Address) {
+      throw new Error("Signer mismatched");
+    }
+
+    const isADR36SignDoc = checkAndValidateADR36AminoSignDoc(
+      signDoc,
+      bech32Prefix
+    );
+    if (isADR36SignDoc) {
+      throw new Error("Can't use ADR-36 sign doc");
+    }
+
+    if (!signDoc.msgs || signDoc.msgs.length === 0) {
+      throw new Error("No msgs");
+    }
+
+    for (const msg of signDoc.msgs) {
+      // Some chains modify types for obscure reasons. For now, treat it like this:
+      const i = msg.type.indexOf("/");
+      if (i < 0) {
+        throw new Error("Invalid msg type");
+      }
+      const action = msg.type.slice(i + 1);
+      if (action !== "MsgDelegate") {
+        throw new Error("Invalid msg type");
+      }
+    }
+
+    try {
+      const _sig = await this.keyRingService.sign(
+        chainId,
+        vaultId,
+        serializeSignDoc(signDoc),
+        isEthermintLike ? "keccak256" : "sha256"
+      );
+      const signature = new Uint8Array([..._sig.r, ..._sig.s]);
+
+      this.analyticsService.logEventIgnoreError("tx_signed", {
+        chainId,
+        isInternal: env.isInternalMsg,
+        origin,
+        signMode: "amino",
+        privileged: "delegate",
+      });
+
+      return {
+        signed: signDoc,
+        signature: encodeSecp256k1Signature(key.pubKey, signature),
+      };
+    } finally {
+      this.interactionService.dispatchEvent(APP_PORT, "request-sign-end", {});
+    }
+  }
+
   async signAminoADR36Selected(
     env: Env,
     origin: string,

package/src/phishing-list/handler.ts

@@ -40,6 +40,11 @@ const handleURLTempAllow: (
   service: PhishingListService
 ) => InternalHandler<URLTempAllowMsg> =
   (service: PhishingListService) => (_, msg) => {
+    const blocklistPageURL = new URL(msg.origin);
+    if (blocklistPageURL.origin !== new URL(service.blocklistPageURL).origin) {
+      throw new Error("Permission rejected");
+    }
+
     service.allowUrlTemp(msg.url);
   };
 

package/src/phishing-list/messages.ts

@@ -46,6 +46,10 @@ export class URLTempAllowMsg extends Message<void> {
     parseDomain(url.origin);
   }
 
+  override approveExternal(): boolean {
+    return true;
+  }
+
   route(): string {
     return ROUTE;
   }

package/src/phishing-list/service.spec.ts

@@ -266,12 +266,15 @@ describe("Test phishing list service", () => {
   };
 
   test("Test basic PhishingListService with valid cases", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/list1`,
-      fetchingIntervalMs: 3600,
-      retryIntervalMs: 3600,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/list1`,
+        fetchingIntervalMs: 3600,
+        retryIntervalMs: 3600,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     eachService = service;
 
     service.init();
@@ -282,12 +285,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test basic PhishingListService with strange separators", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/list2`,
-      fetchingIntervalMs: 3600,
-      retryIntervalMs: 3600,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/list2`,
+        fetchingIntervalMs: 3600,
+        retryIntervalMs: 3600,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     eachService = service;
 
     service.init();
@@ -298,12 +304,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test basic PhishingListService with strange cases", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/list3`,
-      fetchingIntervalMs: 3600,
-      retryIntervalMs: 3600,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/list3`,
+        fetchingIntervalMs: 3600,
+        retryIntervalMs: 3600,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     eachService = service;
 
     service.init();
@@ -314,12 +323,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test basic PhishingListService fetching interval", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/list3`,
-      fetchingIntervalMs: 200,
-      retryIntervalMs: 3600,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/list3`,
+        fetchingIntervalMs: 200,
+        retryIntervalMs: 3600,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     const spyFetch = jest.spyOn(service.urlFetcher, "fetch");
     eachService = service;
 
@@ -357,12 +369,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test basic PhishingListService fetching interval with retry interval", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/test-retry`,
-      fetchingIntervalMs: 200,
-      retryIntervalMs: 100,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/test-retry`,
+        fetchingIntervalMs: 200,
+        retryIntervalMs: 100,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     const spyFetch = jest.spyOn(service.urlFetcher, "fetch");
     eachService = service;
 
@@ -433,12 +448,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test addUrlTemp allow blocked url", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/list1`,
-      fetchingIntervalMs: 200,
-      retryIntervalMs: 100,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/list1`,
+        fetchingIntervalMs: 200,
+        retryIntervalMs: 100,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     eachService = service;
 
     service.init();
@@ -476,12 +494,15 @@ describe("Test phishing list service", () => {
   });
 
   test("Test subdomains", async () => {
-    const service = new PhishingListService({
-      blockListUrl: `http://127.0.0.1:${port}/subdomains`,
-      fetchingIntervalMs: 200,
-      retryIntervalMs: 100,
-      allowTimeoutMs: 100,
-    });
+    const service = new PhishingListService(
+      {
+        blockListUrl: `http://127.0.0.1:${port}/subdomains`,
+        fetchingIntervalMs: 200,
+        retryIntervalMs: 100,
+        allowTimeoutMs: 100,
+      },
+      "http://noop.com"
+    );
     eachService = service;
 
     service.init();

package/src/phishing-list/service.ts

@@ -86,7 +86,8 @@ export class PhishingListService {
       readonly fetchingIntervalMs: number;
       readonly retryIntervalMs: number;
       readonly allowTimeoutMs: number;
-    }
+    },
+    public readonly blocklistPageURL: string
   ) {
     this.urlFetcher = new IntervalFetcher(
       {