@keplr-wallet/hooks-starknet 0.12.194 → 0.12.195-rc.1

package/src/tx/recipient.ts

@@ -1,120 +1,16 @@
 import {
   IRecipientConfig,
-  IRecipientConfigWithStarknetID,
   UIProperties,
+  IRecipientConfigWithNameServices,
 } from "./types";
 import { TxChainSetter } from "./chain";
 import { ChainGetter } from "@keplr-wallet/stores";
-import {
-  action,
-  computed,
-  makeObservable,
-  observable,
-  runInAction,
-} from "mobx";
-import {
-  EmptyAddressError,
-  InvalidHexError,
-  StarknetIDFailedToFetchError,
-  StarknetIDIsFetchingError,
-} from "./errors";
+import { action, computed, makeObservable, observable } from "mobx";
+import { EmptyAddressError, InvalidHexError } from "./errors";
 import { useState } from "react";
-import { Buffer } from "buffer/";
-import { simpleFetch } from "@keplr-wallet/simple-fetch";
-import { CallData, constants } from "starknet";
-
-interface StarknetIDFetchData {
-  isFetching: boolean;
-  starknetHexAddress?: string;
-  error?: Error;
-}
-
-const networkToNamingContractAddress = {
-  [constants.NetworkName.SN_MAIN]:
-    "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678",
-  [constants.NetworkName.SN_SEPOLIA]:
-    "0x0707f09bc576bd7cfee59694846291047e965f4184fe13dac62c56759b3b6fa7",
-};
-
-const basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
-const basicSizePlusOne = BigInt(basicAlphabet.length + 1);
-const bigAlphabet = "这来";
-const basicAlphabetSize = BigInt(basicAlphabet.length);
-const bigAlphabetSize = BigInt(bigAlphabet.length);
-
-// Reference: https://github.com/lfglabs-dev/starknetid.js/blob/main/packages/core/src/utils.ts
-function isStarkDomain(domain: string): boolean {
-  return /^(?:[a-z0-9-]{1,48}(?:[a-z0-9-]{1,48}[a-z0-9-])?\.)*[a-z0-9-]{1,48}\.stark$/.test(
-    domain
-  );
-}
-
-function encodeDomain(domain: string | undefined | null): bigint[] {
-  if (!domain) return [BigInt(0)];
-
-  const encoded = [];
-  for (const subdomain of domain.replace(".stark", "").split("."))
-    encoded.push(encode(subdomain));
-  return encoded;
-}
-
-function extractStars(str: string): [string, number] {
-  let k = 0;
-  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
-    str = str.substring(0, str.length - 1);
-    k += 1;
-  }
-  return [str, k];
-}
-
-function encode(decoded: string | undefined): bigint {
-  let encoded = BigInt(0);
-  let multiplier = BigInt(1);
-
-  if (!decoded) {
-    return encoded;
-  }
-
-  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
-    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
-    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
-  } else {
-    const [str, k] = extractStars(decoded);
-    if (k)
-      decoded =
-        str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
-  }
-
-  for (let i = 0; i < decoded.length; i += 1) {
-    const char = decoded[i];
-    const index = basicAlphabet.indexOf(char);
-    const bnIndex = BigInt(basicAlphabet.indexOf(char));
-
-    if (index !== -1) {
-      // add encoded + multiplier * index
-      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
-        encoded += multiplier * basicAlphabetSize;
-        multiplier *= basicSizePlusOne;
-        // add 0
-        multiplier *= basicSizePlusOne;
-      } else {
-        encoded += multiplier * bnIndex;
-        multiplier *= basicSizePlusOne;
-      }
-    } else if (bigAlphabet.indexOf(char) !== -1) {
-      // add encoded + multiplier * (basicAlphabetSize)
-      encoded += multiplier * basicAlphabetSize;
-      multiplier *= basicSizePlusOne;
-      // add encoded + multiplier * index
-      const newid =
-        (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
-      encoded += multiplier * BigInt(newid);
-      multiplier *= bigAlphabetSize;
-    }
-  }
-
-  return encoded;
-}
+import { Buffer } from "buffer";
+import { NameService } from "./name-service";
+import { StarknetIdNameService } from "./name-service-starknet-id";
 
 function isStarknetHexAddress(address: string): boolean {
   if (!address.startsWith("0x")) {
@@ -135,179 +31,96 @@ function isStarknetHexAddress(address: string): boolean {
 
 export class RecipientConfig
   extends TxChainSetter
-  implements IRecipientConfig, IRecipientConfigWithStarknetID
+  implements IRecipientConfig, IRecipientConfigWithNameServices
 {
   @observable
   protected _value: string = "";
 
-  // Deep equal check is required to avoid infinite re-render.
-  @observable.struct
-  protected _starknetID:
-    | {
-        networkName: string;
-        namingContractAddress: string;
-      }
-    | undefined = undefined;
+  @observable
+  protected _preferredNameService: string | undefined = undefined;
 
-  // Key is {chain identifier}/{starknet username}
-  @observable.shallow
-  protected _starknetIDFetchDataMap = new Map<string, StarknetIDFetchData>();
+  @observable.ref
+  protected nameServices: NameService[] = [];
 
   constructor(chainGetter: ChainGetter, initialChainId: string) {
     super(chainGetter, initialChainId);
 
+    this.nameServices.push(new StarknetIdNameService(this, chainGetter));
+
     makeObservable(this);
   }
 
-  @action
-  setStarknetID(chainId: string) {
-    const split = chainId.split(":"); // `starknet:networkName`
-    if (split.length < 2) {
-      return;
-    }
-
-    const networkName = split[1] as constants.NetworkName;
-    if (!networkName) {
-      return;
-    }
-
-    const namingContractAddress = networkToNamingContractAddress[networkName];
-    if (!namingContractAddress) {
-      return;
-    }
-
-    this._starknetID = {
-      networkName,
-      namingContractAddress,
-    };
+  get preferredNameService(): string | undefined {
+    return this._preferredNameService;
   }
 
-  protected getStarknetIDFetchData(username: string): StarknetIDFetchData {
-    const modularChainInfo = this.chainGetter.getModularChain(this.chainId);
-    if (!("starknet" in modularChainInfo)) {
-      throw new Error(`${this.chainId} is not starknet chain`);
-    }
-
-    if (!this._starknetID) {
-      throw new Error("Starknet ID is not set");
-    }
-
-    if (!isStarkDomain(username)) {
-      return {
-        isFetching: false,
-        error: new Error("Invalid domain for Starknet ID"),
-      };
-    }
-
-    const key = `${this.chainId}/${username}`;
-
-    if (!this._starknetIDFetchDataMap.has(key)) {
-      runInAction(() => {
-        this._starknetIDFetchDataMap.set(key, {
-          isFetching: true,
-        });
-      });
-
-      const domain = encodeDomain(username).map((v) => v.toString(10));
-
-      simpleFetch<{
-        jsonrpc: "2.0";
-        result?: string[];
-        id: string;
-        error?: {
-          code?: number;
-          message?: string;
-        };
-      }>(modularChainInfo.starknet.rpc, "", {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: "1",
-          method: "starknet_call",
-          params: [
-            {
-              contract_address: this._starknetID.namingContractAddress,
-              calldata: CallData.toHex({ domain, hint: [] }),
-              entry_point_selector:
-                "0x2e269d930f6d7ab92b15ce8ff9f5e63709391617e3465fff79ba6baf278ce60", // selector.getSelectorFromName("domain_to_address"),
-            },
-            "latest",
-          ],
-        }),
-        signal: new AbortController().signal,
-      })
-        .then((resp) => {
-          if (resp.data.error && resp.data.error.message) {
-            throw new StarknetIDIsFetchingError(resp.data.error.message);
-          }
-
-          const data = resp.data.result;
-          if (!data) {
-            throw new StarknetIDIsFetchingError("no address found");
-          }
-
-          const rawHexAddr = data[0];
-          if (rawHexAddr === "0x0") {
-            throw new StarknetIDIsFetchingError("no address found");
-          }
-
-          const addr = "0x" + rawHexAddr.replace("0x", "").padStart(64, "0");
-
-          if (!isStarknetHexAddress(addr)) {
-            throw new StarknetIDIsFetchingError("no address found");
-          }
-
-          runInAction(() => {
-            this._starknetIDFetchDataMap.set(key, {
-              isFetching: false,
-              starknetHexAddress: addr,
-            });
-          });
-        })
-        .catch((error) => {
-          runInAction(() => {
-            this._starknetIDFetchDataMap.set(key, {
-              isFetching: false,
-              error,
-            });
-          });
-        });
-    }
-
-    return this._starknetIDFetchDataMap.get(key) ?? { isFetching: false };
+  @action
+  setPreferredNameService(nameService: string | undefined) {
+    this._preferredNameService = nameService;
   }
 
-  get isStarknetIDEnabled(): boolean {
-    return !!this._starknetID;
+  getNameService(type: string): NameService | undefined {
+    return this.nameServices.find((nameService) => nameService.type === type);
   }
 
-  @computed
-  get isStarknetID(): boolean {
-    if (this.isStarknetIDEnabled) {
-      const parsed = this.value.trim().split(".");
-      return parsed.length > 1 && parsed[parsed.length - 1] === "stark";
-    }
-
-    return false;
+  getNameServices(): NameService[] {
+    return this.nameServices;
   }
 
   @computed
-  get isStarknetIDFetching(): boolean {
-    if (!this.isStarknetIDEnabled || !this.isStarknetID) {
-      return false;
-    }
+  get nameServiceResult(): {
+    type: string;
+    address: string;
+    fullName: string;
+    domain: string;
+    suffix: string;
+  }[] {
+    const result: {
+      type: string;
+      address: string;
+      fullName: string;
+      domain: string;
+      suffix: string;
+    }[] = [];
+    for (const nameService of this.nameServices) {
+      if (
+        this.preferredNameService &&
+        nameService.type !== this.preferredNameService
+      ) {
+        continue;
+      }
 
-    return this.getStarknetIDFetchData(this.value.trim()).isFetching;
+      const r = nameService.result;
+      if (r) {
+        result.push({
+          ...r,
+          type: nameService.type,
+        });
+      }
+    }
+    return result;
   }
 
-  get starknetExpectedDomain(): string {
-    return "stark";
+  @action
+  setStarknetID(chainId: string) {
+    const found = this.nameServices.find(
+      (nameService) => nameService.type === "starknet-id"
+    );
+    if (found) {
+      (found as StarknetIdNameService).setStarknetID(chainId);
+    } else {
+      this.nameServices.push(
+        new StarknetIdNameService(this, this.chainGetter, chainId)
+      );
+    }
   }
 
   get recipient(): string {
+    if (this.nameServiceResult.length > 0) {
+      const r = this.nameServiceResult[0];
+      return r.address;
+    }
+
     const rawRecipient = this.value.trim();
 
     const modularChainInfo = this.modularChainInfo;
@@ -315,22 +128,12 @@ export class RecipientConfig
       throw new Error("Chain doesn't support the starknet");
     }
 
-    if (this.isStarknetIDEnabled && this.isStarknetID) {
-      try {
-        return (
-          this.getStarknetIDFetchData(rawRecipient).starknetHexAddress || ""
-        );
-      } catch {
-        return "";
-      }
-    }
-
     return rawRecipient;
   }
 
   @computed
   get uiProperties(): UIProperties {
-    const rawRecipient = this.value.trim();
+    let rawRecipient = this.value.trim();
 
     if (!rawRecipient) {
       return {
@@ -338,46 +141,9 @@ export class RecipientConfig
       };
     }
 
-    if (this.isStarknetIDEnabled && this.isStarknetID) {
-      try {
-        const fetched = this.getStarknetIDFetchData(rawRecipient);
-
-        if (fetched.isFetching) {
-          return {
-            loadingState: "loading-block",
-          };
-        }
-
-        if (fetched.error) {
-          if (fetched.error instanceof StarknetIDIsFetchingError) {
-            return {
-              error: new StarknetIDFailedToFetchError(
-                "Failed to fetch the address from Starknet ID"
-              ),
-              loadingState: fetched.isFetching ? "loading-block" : undefined,
-            };
-          }
-
-          return {
-            error: fetched.error,
-          };
-        }
-
-        if (!fetched.starknetHexAddress) {
-          return {
-            error: new StarknetIDFailedToFetchError(
-              "Failed to fetch the address from Starknet ID"
-            ),
-            loadingState: fetched.isFetching ? "loading-block" : undefined,
-          };
-        }
-
-        return {};
-      } catch (e) {
-        return {
-          error: e,
-        };
-      }
+    if (this.nameServiceResult.length > 0) {
+      const r = this.nameServiceResult[0];
+      rawRecipient = r.address;
     }
 
     if (!isStarknetHexAddress(rawRecipient)) {
@@ -396,6 +162,10 @@ export class RecipientConfig
   @action
   setValue(value: string): void {
     this._value = value;
+
+    for (const nameService of this.nameServices) {
+      nameService.setValue(value);
+    }
   }
 }
 

package/src/tx/types.ts

@@ -1,9 +1,11 @@
-import { ERC20Currency } from "@keplr-wallet/types";
+import { ERC20Currency, ModularChainInfo } from "@keplr-wallet/types";
 import { CoinPretty } from "@keplr-wallet/unit";
+import { NameService } from "./name-service";
 
 export interface ITxChainSetter {
   chainId: string;
   setChain(chainId: string): void;
+  modularChainInfo: ModularChainInfo;
 }
 
 export interface UIProperties {
@@ -64,11 +66,21 @@ export interface IRecipientConfig extends ITxChainSetter {
   uiProperties: UIProperties;
 }
 
-export interface IRecipientConfigWithStarknetID extends IRecipientConfig {
-  readonly isStarknetIDEnabled: boolean;
-  readonly isStarknetID: boolean;
-  readonly starknetExpectedDomain: string;
-  readonly isStarknetIDFetching: boolean;
+export interface IRecipientConfigWithNameServices extends IRecipientConfig {
+  preferredNameService: string | undefined;
+  setPreferredNameService(nameService: string | undefined): void;
+  getNameService(type: string): NameService | undefined;
+  getNameServices(): NameService[];
+  // address를 반환하는 name service의 결과를 반환한다.
+  // preferredNameService가 설정되어 있지 않으면 모든 name service의 결과를 반환한다.
+  // preferredNameService가 설정되어 있으면 해당 name service의 결과를 반환한다.
+  nameServiceResult: {
+    type: string;
+    address: string;
+    fullName: string;
+    domain: string;
+    suffix: string;
+  }[];
 }
 
 export interface IAmountConfig extends ITxChainSetter {