@keplr-wallet/stores-eth 0.12.71-rc.0

package/src/account/base.ts

@@ -0,0 +1,302 @@
+import { simpleFetch } from "@keplr-wallet/simple-fetch";
+import { ChainGetter } from "@keplr-wallet/stores";
+import {
+  AppCurrency,
+  ChainInfo,
+  EthSignType,
+  EthTxReceipt,
+  Keplr,
+} from "@keplr-wallet/types";
+import { DenomHelper, retry } from "@keplr-wallet/common";
+import { erc20ContractInterface } from "../constants";
+import { hexValue } from "@ethersproject/bytes";
+import { parseUnits } from "@ethersproject/units";
+import {
+  UnsignedTransaction,
+  serialize,
+  TransactionTypes,
+} from "@ethersproject/transactions";
+import { getAddress as getEthAddress } from "@ethersproject/address";
+import { action, makeObservable, observable } from "mobx";
+
+export class EthereumAccountBase {
+  @observable
+  protected _isSendingTx: boolean = false;
+
+  constructor(
+    protected readonly chainGetter: ChainGetter,
+    protected readonly chainId: string,
+    protected readonly getKeplr: () => Promise<Keplr | undefined>
+  ) {
+    makeObservable(this);
+  }
+
+  static evmInfo(chainInfo: ChainInfo): ChainInfo["evm"] | undefined {
+    return chainInfo.evm;
+  }
+
+  @action
+  setIsSendingTx(value: boolean) {
+    this._isSendingTx = value;
+  }
+
+  get isSendingTx(): boolean {
+    return this._isSendingTx;
+  }
+
+  async simulateGas({
+    currency,
+    amount,
+    sender,
+    recipient,
+  }: {
+    currency: AppCurrency;
+    amount: string;
+    sender: string;
+    recipient: string;
+  }) {
+    const chainInfo = this.chainGetter.getChain(this.chainId);
+    const evmInfo = EthereumAccountBase.evmInfo(chainInfo);
+    if (!evmInfo) {
+      throw new Error("No EVM chain info provided");
+    }
+
+    if (!EthereumAccountBase.isEthereumHexAddressWithChecksum(sender)) {
+      throw new Error("Invalid sender address");
+    }
+
+    // If the recipient address is invalid, the sender address will be used as the recipient for gas estimating gas.
+    const tempRecipient = EthereumAccountBase.isEthereumHexAddressWithChecksum(
+      recipient
+    )
+      ? recipient
+      : sender;
+
+    const parsedAmount = parseUnits(amount, currency.coinDecimals);
+    const denomHelper = new DenomHelper(currency.coinMinimalDenom);
+
+    const unsignedTx: UnsignedTransaction = (() => {
+      switch (denomHelper.type) {
+        case "erc20":
+          return {
+            from: sender,
+            to: denomHelper.contractAddress,
+            value: "0x0",
+            data: erc20ContractInterface.encodeFunctionData("transfer", [
+              tempRecipient,
+              hexValue(parsedAmount),
+            ]),
+          };
+        default:
+          return {
+            from: sender,
+            to: tempRecipient,
+            value: hexValue(parsedAmount),
+          };
+      }
+    })();
+
+    const estimateGasResponse = await simpleFetch<{
+      result: string;
+    }>(evmInfo.rpc, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_estimateGas",
+        params: [unsignedTx],
+        id: 1,
+      }),
+    });
+
+    return {
+      gasUsed: Number(estimateGasResponse.data.result),
+    };
+  }
+
+  async makeSendTokenTx({
+    currency,
+    amount,
+    from,
+    to,
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  }: {
+    currency: AppCurrency;
+    amount: string;
+    from: string;
+    to: string;
+    gasLimit: number;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+  }): Promise<UnsignedTransaction> {
+    const chainInfo = this.chainGetter.getChain(this.chainId);
+    const evmInfo = EthereumAccountBase.evmInfo(chainInfo);
+    if (!evmInfo) {
+      throw new Error("No EVM chain info provided");
+    }
+
+    const transactionCountResponse = await simpleFetch<{
+      result: string;
+    }>(evmInfo.rpc, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_getTransactionCount",
+        params: [from, "pending"],
+        id: 1,
+      }),
+    });
+
+    const parsedAmount = parseUnits(amount, currency.coinDecimals);
+    const denomHelper = new DenomHelper(currency.coinMinimalDenom);
+
+    // Support EIP-1559 transaction only.
+    const unsignedTx: UnsignedTransaction = (() => {
+      switch (denomHelper.type) {
+        case "erc20":
+          return {
+            type: TransactionTypes.eip1559,
+            chainId: evmInfo.chainId,
+            nonce: Number(transactionCountResponse.data.result),
+            gasLimit: hexValue(gasLimit),
+            maxFeePerGas: hexValue(Number(maxFeePerGas)),
+            maxPriorityFeePerGas: hexValue(Number(maxPriorityFeePerGas)),
+            to: denomHelper.contractAddress,
+            value: "0x0",
+            data: erc20ContractInterface.encodeFunctionData("transfer", [
+              to,
+              hexValue(parsedAmount),
+            ]),
+          };
+        default:
+          return {
+            type: TransactionTypes.eip1559,
+            chainId: evmInfo.chainId,
+            nonce: Number(transactionCountResponse.data.result),
+            gasLimit: hexValue(gasLimit),
+            maxFeePerGas: hexValue(Number(maxFeePerGas)),
+            maxPriorityFeePerGas: hexValue(Number(maxPriorityFeePerGas)),
+            to,
+            value: hexValue(parsedAmount),
+          };
+      }
+    })();
+
+    return unsignedTx;
+  }
+
+  async sendEthereumTx(
+    sender: string,
+    unsignedTx: UnsignedTransaction,
+    onTxEvents?: {
+      onBroadcastFailed?: (e?: Error) => void;
+      onBroadcasted?: (txHash: string) => void;
+      onFulfill?: (txReceipt: EthTxReceipt) => void;
+    }
+  ) {
+    try {
+      const chainInfo = this.chainGetter.getChain(this.chainId);
+      const evmInfo = EthereumAccountBase.evmInfo(chainInfo);
+      if (!evmInfo) {
+        throw new Error("No EVM info provided");
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const keplr = (await this.getKeplr())!;
+      const signEthereum = keplr.signEthereum.bind(keplr);
+      const signature = await signEthereum(
+        this.chainId,
+        sender,
+        JSON.stringify(unsignedTx),
+        EthSignType.TRANSACTION
+      );
+
+      const signedTx = Buffer.from(
+        serialize(unsignedTx, signature).replace("0x", ""),
+        "hex"
+      );
+
+      const sendEthereumTx = keplr.sendEthereumTx.bind(keplr);
+      const txHash = await sendEthereumTx(this.chainId, signedTx);
+      if (!txHash) {
+        throw new Error("No tx hash responded");
+      }
+
+      if (onTxEvents?.onBroadcasted) {
+        onTxEvents.onBroadcasted(txHash);
+      }
+
+      retry(
+        () => {
+          return new Promise<void>(async (resolve, reject) => {
+            const txReceiptResponse = await simpleFetch<{
+              result: EthTxReceipt | null;
+              error?: Error;
+            }>(evmInfo.rpc, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+              },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                method: "eth_getTransactionReceipt",
+                params: [txHash],
+                id: 1,
+              }),
+            });
+
+            if (txReceiptResponse.data.error) {
+              console.error(txReceiptResponse.data.error);
+              resolve();
+            }
+
+            const txReceipt = txReceiptResponse.data.result;
+            if (txReceipt) {
+              onTxEvents?.onFulfill?.(txReceipt);
+              resolve();
+            }
+
+            reject();
+          });
+        },
+        {
+          maxRetries: 10,
+          waitMsAfterError: 500,
+          maxWaitMsAfterError: 4000,
+        }
+      );
+
+      return txHash;
+    } catch (e) {
+      if (onTxEvents?.onBroadcastFailed) {
+        onTxEvents.onBroadcastFailed(e);
+      }
+
+      throw e;
+    }
+  }
+
+  static isEthereumHexAddressWithChecksum(hexAddress: string): boolean {
+    const isHexAddress = !!hexAddress.match(/^0x[0-9A-Fa-f]*$/);
+    const isChecksumAddress = !!hexAddress.match(
+      /([A-F].*[a-f])|([a-f].*[A-F])/
+    );
+    if (!isHexAddress || hexAddress.length !== 42) {
+      return false;
+    }
+
+    const checksumHexAddress = getEthAddress(hexAddress.toLowerCase());
+    if (isChecksumAddress && checksumHexAddress !== hexAddress) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/account/index.ts

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./store";

package/src/account/store.ts

@@ -0,0 +1,19 @@
+import { ChainGetter, HasMapStore } from "@keplr-wallet/stores";
+import { EthereumAccountBase } from "./base";
+import { Keplr } from "@keplr-wallet/types";
+
+export class EthereumAccountStore extends HasMapStore<EthereumAccountBase> {
+  constructor(
+    protected readonly chainGetter: ChainGetter,
+    protected readonly getKeplr: () => Promise<Keplr | undefined>
+  ) {
+    super((chainId: string) => {
+      return new EthereumAccountBase(chainGetter, chainId, getKeplr);
+    });
+  }
+
+  getAccount(chainId: string): EthereumAccountBase {
+    // chain identifier를 통한 접근도 허용하기 위해서 chainGetter를 통해 접근하도록 함.
+    return this.get(this.chainGetter.getChain(chainId).chainId);
+  }
+}

package/src/constants.ts

@@ -0,0 +1,272 @@
+import { Interface } from "@ethersproject/abi";
+
+export const erc20ContractInterface: Interface = new Interface([
+  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "spender",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+    ],
+    name: "Approval",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "usr",
+        type: "address",
+      },
+    ],
+    name: "Deny",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "usr",
+        type: "address",
+      },
+    ],
+    name: "Rely",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+    ],
+    name: "Transfer",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "DOMAIN_SEPARATOR",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "PERMIT_TYPEHASH",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "", type: "address" },
+      { internalType: "address", name: "", type: "address" },
+    ],
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+    ],
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+    ],
+    name: "burn",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      {
+        internalType: "uint256",
+        name: "subtractedValue",
+        type: "uint256",
+      },
+    ],
+    name: "decreaseAllowance",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "usr", type: "address" }],
+    name: "deny",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "deploymentChainId",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "addedValue", type: "uint256" },
+    ],
+    name: "increaseAllowance",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+    ],
+    name: "mint",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "nonces",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+      { internalType: "uint256", name: "deadline", type: "uint256" },
+      { internalType: "uint8", name: "v", type: "uint8" },
+      { internalType: "bytes32", name: "r", type: "bytes32" },
+      { internalType: "bytes32", name: "s", type: "bytes32" },
+    ],
+    name: "permit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "usr", type: "address" }],
+    name: "rely",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+    ],
+    name: "transfer",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" },
+    ],
+    name: "transferFrom",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "version",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "wards",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+]);

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./queries";
+export * from "./account";
+export * from "./constants";

package/src/queries/balance.ts

@@ -0,0 +1,94 @@
+import { DenomHelper } from "@keplr-wallet/common";
+import {
+  BalanceRegistry,
+  ChainGetter,
+  IObservableQueryBalanceImpl,
+  ObservableJsonRPCQuery,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { AppCurrency, ChainInfo } from "@keplr-wallet/types";
+import { CoinPretty, Int } from "@keplr-wallet/unit";
+import { computed, makeObservable } from "mobx";
+import bigInteger from "big-integer";
+import { EthereumAccountBase } from "../account";
+
+export class ObservableQueryEthAccountBalanceImpl
+  extends ObservableJsonRPCQuery<string>
+  implements IObservableQueryBalanceImpl
+{
+  constructor(
+    sharedContext: QuerySharedContext,
+    protected readonly chainId: string,
+    protected readonly chainGetter: ChainGetter,
+    protected readonly denomHelper: DenomHelper,
+    protected readonly ethereumURL: string,
+    protected readonly ethereumeHexAddress: string
+  ) {
+    super(sharedContext, ethereumURL, "", "eth_getBalance", [
+      ethereumeHexAddress,
+      "latest",
+    ]);
+    makeObservable(this);
+  }
+
+  @computed
+  get balance(): CoinPretty {
+    const denom = this.denomHelper.denom;
+
+    const chainInfo = this.chainGetter.getChain(this.chainId);
+    const currency = chainInfo.currencies.find(
+      (cur) => cur.coinMinimalDenom === denom
+    );
+
+    if (!currency) {
+      throw new Error(`Unknown currency: ${denom}`);
+    }
+
+    if (!this.response || !this.response.data) {
+      return new CoinPretty(currency, new Int(0)).ready(false);
+    }
+
+    return new CoinPretty(
+      currency,
+      new Int(bigInteger(this.response.data.replace("0x", ""), 16).toString())
+    );
+  }
+
+  @computed
+  get currency(): AppCurrency {
+    const denom = this.denomHelper.denom;
+
+    const chainInfo = this.chainGetter.getChain(this.chainId);
+    return chainInfo.forceFindCurrency(denom);
+  }
+}
+
+export class ObservableQueryEthAccountBalanceRegistry
+  implements BalanceRegistry
+{
+  constructor(protected readonly sharedContext: QuerySharedContext) {}
+
+  getBalanceImpl(
+    chainId: string,
+    chainGetter: ChainGetter<ChainInfo>,
+    address: string,
+    minimalDenom: string
+  ): IObservableQueryBalanceImpl | undefined {
+    const denomHelper = new DenomHelper(minimalDenom);
+    const chainInfo = chainGetter.getChain(chainId);
+    const isHexAddress =
+      EthereumAccountBase.isEthereumHexAddressWithChecksum(address);
+    if (denomHelper.type !== "native" || !isHexAddress || !chainInfo.evm) {
+      return;
+    }
+
+    return new ObservableQueryEthAccountBalanceImpl(
+      this.sharedContext,
+      chainId,
+      chainGetter,
+      denomHelper,
+      chainInfo.evm.rpc,
+      address
+    );
+  }
+}