Change contract

pages/verification/index.tsx

@@ -5,10 +5,7 @@ import { useEffect, useState } from "react";
 import Image from "next/image";
 
 // Types
-import {
+import { IcnsVerificationResponse, TwitterAuthInfoResponse } from "../../types";
-  IcnsVerificationResponse,
-  TwitterAuthInfoResponse,
-} from "../../types";
 import { request } from "../../utils/url";
 
 // Styles
@@ -21,10 +18,17 @@ import { SkeletonChainList } from "../../components/skeleton";
 
 import { PrimaryButton } from "../../components/primary-button";
 import { AccountInfos } from "../../config";
-import {
+import { TwitterProfile } from "../../components/twitter-profile";
-  TwitterProfile,
-} from "../../components/twitter-profile";
 import { ChainList } from "../../components/chain-list";
+import {
+  getKeplrFromWindow,
+  KeplrWallet,
+  makeCosmwasmExecMsg,
+  sendMsgs,
+  simulateMsgs,
+} from "../../wallets";
+import { TendermintTxTracer } from "@keplr-wallet/cosmos";
+import { Buffer } from "buffer/";
 
 export default function VerificationPage() {
   const [twitterAuthInfo, setTwitterAuthInfo] =
@@ -46,20 +50,146 @@ export default function VerificationPage() {
 
         setTwitterAuthInfo(newTwitterAuthInfo);
 
-        const icnsVerificationList = (
+        await (async () => {
-          await request<IcnsVerificationResponse>("/api/icns-verification", {
+          const keplr = await getKeplrFromWindow();
-            method: "post",
+          if (keplr) {
-            headers: {
+            const wallet = new KeplrWallet(keplr);
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-              claimer: "osmo1y5mm5nj5m8ttddt5ccspek6xgyyavehrkak7gq",
-              authToken: newTwitterAuthInfo.accessToken,
-            }),
-          })
-        ).verificationList;
 
-        console.log(icnsVerificationList);
+            const mainChainId = "osmo-test-4";
+            const chainIds = (await wallet.getChainInfosWithoutEndpoints()).map(
+              (c) => c.chainId,
+            );
+
+            await wallet.init(chainIds);
+
+            const key = await wallet.getKey(mainChainId);
+
+            const icnsVerificationList = (
+              await request<IcnsVerificationResponse>(
+                "/api/icns-verification",
+                {
+                  method: "post",
+                  headers: {
+                    "Content-Type": "application/json",
+                  },
+                  body: JSON.stringify({
+                    claimer: key.bech32Address,
+                    authToken: newTwitterAuthInfo.accessToken,
+                  }),
+                },
+              )
+            ).verificationList;
+
+            console.log(icnsVerificationList);
+
+            const registerMsg = makeCosmwasmExecMsg(
+              key.bech32Address,
+              "osmo1u3sm9029430ca7xqz5afx4n0d42mgs2w97syex23g3vz2m673hxsv905sn",
+              {
+                claim: {
+                  name: newTwitterAuthInfo.username,
+                  verifying_msg:
+                    icnsVerificationList[0].status === "fulfilled"
+                      ? icnsVerificationList[0].value.data.verifying_msg
+                      : "",
+                  verifications: icnsVerificationList.map((verification) => {
+                    if (verification.status === "fulfilled") {
+                      return {
+                        public_key: verification.value.data.public_key,
+                        signature: verification.value.data.signature,
+                      };
+                    }
+                  }),
+                },
+              },
+              [
+                {
+                  denom: "uosmo",
+                  amount: "500000",
+                },
+              ],
+            );
+
+            const test = await wallet.signICNSAdr36(
+              mainChainId,
+              "osmo1hnjg39mu9r9tygy6zpypd25rhmh9726jm369uh7z0r6gjkmnk5zs3tdtug",
+              key.bech32Address,
+              newTwitterAuthInfo.username,
+              chainIds,
+            );
+
+            const addressMsgs = test.map((adr36Info) => {
+              console.log(adr36Info);
+
+              return makeCosmwasmExecMsg(
+                key.bech32Address,
+                "osmo1hnjg39mu9r9tygy6zpypd25rhmh9726jm369uh7z0r6gjkmnk5zs3tdtug",
+                {
+                  set_record: {
+                    name: newTwitterAuthInfo.username,
+                    bech32_prefix: adr36Info.bech32Prefix,
+                    adr36_info: {
+                      signer_bech32_address: adr36Info.bech32Address,
+                      address_hash: adr36Info.addressHash,
+                      pub_key: Buffer.from(adr36Info.pubKey).toString("base64"),
+                      signature: Buffer.from(adr36Info.signature).toString(
+                        "base64",
+                      ),
+                      signature_salt: adr36Info.signatureSalt.toString(),
+                    },
+                  },
+                },
+                [],
+              );
+            });
+
+            const aminoMsgs = [registerMsg.amino];
+            const protoMsgs = [registerMsg.proto];
+            for (const addressMsg of addressMsgs) {
+              aminoMsgs.push(addressMsg.amino);
+              protoMsgs.push(addressMsg.proto);
+            }
+
+            const chainInfo = {
+              chainId: mainChainId,
+              rest: "https://lcd.testnet.osmosis.zone",
+            };
+
+            const simulated = await simulateMsgs(
+              chainInfo,
+              key.bech32Address,
+              {
+                proto: protoMsgs,
+              },
+              {
+                amount: [],
+              },
+            );
+
+            const txHash = await sendMsgs(
+              wallet,
+              chainInfo,
+              key.bech32Address,
+              {
+                amino: aminoMsgs,
+                proto: protoMsgs,
+              },
+              {
+                amount: [],
+                gas: Math.floor(simulated.gasUsed * 1.5).toString(),
+              },
+            );
+
+            const txTracer = new TendermintTxTracer(
+              "https://rpc.testnet.osmosis.zone",
+              "/websocket",
+            );
+
+            const result = await txTracer.traceTx(txHash);
+
+            console.log(result);
+          }
+        })();
 
         setIsLoading(false);
       }

types/api-response.ts

@@ -21,8 +21,12 @@ export interface IcnsVerificationResponse {
         value: {
           errors: Error[];
           data: {
+            // JSON string
             verifying_msg: string;
-            signature: number[];
+            // Base64 encoded
+            public_key: string;
+            // Base64 encoded
+            signature: string;
             algorithm: string;
           };
         };

utils/encoding.ts

@@ -1,5 +1,7 @@
-export function base64URLEncode(str: Buffer) {
+import { Buffer } from "buffer/";
-  return str
+
+export function base64URLEncode(str: Uint8Array) {
+  return Buffer.from(str)
     .toString("base64")
     .replace(/\+/g, "-")
     .replace(/\//g, "_")

wallets/keplr.ts

@@ -41,7 +41,7 @@ export class KeplrWallet implements Wallet {
   constructor(public readonly keplr: Keplr) {}
 
   broadcastTxSync(chainId: string, tx: Uint8Array): Promise<Uint8Array> {
-    return this.keplr.sendTx(chainId, tx, BroadcastMode.Sync);
+    return this.keplr.sendTx(chainId, tx, "sync" as BroadcastMode);
   }
 
   getChainInfosWithoutEndpoints(): Promise<
@@ -54,7 +54,7 @@ export class KeplrWallet implements Wallet {
   getKey(chainId: string): Promise<{
     readonly name: string;
     readonly pubKey: Uint8Array;
-    readonly address: Uint8Array;
+    readonly bech32Address: string;
   }> {
     return this.keplr.getKey(chainId);
   }
@@ -77,15 +77,17 @@ export class KeplrWallet implements Wallet {
     owner: string,
     username: string,
     addressChainIds: string[],
-  ): Promise<{
+  ): Promise<
-    chainId: string;
+    {
-    bech32Prefix: string;
+      chainId: string;
-    bech32Address: string;
+      bech32Prefix: string;
-    addressHash: "cosmos" | "ethereum";
+      bech32Address: string;
-    pubKey: Uint8Array;
+      addressHash: "cosmos" | "ethereum";
-    signatureSalt: number;
+      pubKey: Uint8Array;
-    signature: Uint8Array;
+      signatureSalt: number;
-  }> {
+      signature: Uint8Array;
+    }[]
+  > {
     // TODO: Update @keplr-wallet/types
     return (this.keplr as any).signICNSAdr36(
       chainId,

wallets/types.ts

@@ -10,7 +10,7 @@ export interface Wallet {
   getKey(chainId: string): Promise<{
     readonly name: string;
     readonly pubKey: Uint8Array;
-    readonly address: Uint8Array;
+    readonly bech32Address: string;
   }>;
   signAmino(
     chainId: string,
@@ -25,13 +25,15 @@ export interface Wallet {
     owner: string,
     username: string,
     addressChainIds: string[],
-  ): Promise<{
+  ): Promise<
-    chainId: string;
+    {
-    bech32Prefix: string;
+      chainId: string;
-    bech32Address: string;
+      bech32Prefix: string;
-    addressHash: "cosmos" | "ethereum";
+      bech32Address: string;
-    pubKey: Uint8Array;
+      addressHash: "cosmos" | "ethereum";
-    signatureSalt: number;
+      pubKey: Uint8Array;
-    signature: Uint8Array;
+      signatureSalt: number;
-  }>;
+      signature: Uint8Array;
+    }[]
+  >;
 }