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

package/src/queries/block.ts

@@ -0,0 +1,111 @@
+import { ChainGetter, QuerySharedContext } from "@keplr-wallet/stores";
+import { computed, makeObservable } from "mobx";
+import {
+  ObservableEvmChainJsonRpcQuery,
+  ObservableEvmChainJsonRpcQueryMap,
+} from "./evm-chain-json-rpc";
+
+interface Transaction {
+  accessList?: string[];
+  blockHash: string;
+  blockNumber: string;
+  chainId: string;
+  from: string;
+  gas: string;
+  gasPrice: string;
+  hash: string;
+  input: string;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+  nonce: string;
+  r: string;
+  s: string;
+  to: string;
+  transactionIndex: string;
+  type: string;
+  v: string;
+  value: string;
+}
+
+interface EthereumBlock {
+  baseFeePerGas: string;
+  difficulty: string;
+  extraData: string;
+  gasLimit: string;
+  gasUsed: string;
+  hash: string;
+  logsBloom: string;
+  mixHash: string;
+  nonce: string;
+  number: string;
+  parentHash: string;
+  receiptsRoot: string;
+  sha3Uncles: string;
+  size: string;
+  stateRoot: string;
+  timestamp: string;
+  totalDifficulty: string;
+  transactions: Transaction[];
+  transactionsRoot: string;
+  uncles: string[];
+}
+
+export class ObservableQueryEthereumBlockInner extends ObservableEvmChainJsonRpcQuery<EthereumBlock> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    blockNumberOrTagParam?: string
+  ) {
+    super(sharedContext, chainId, chainGetter, "eth_getBlockByNumber", [
+      blockNumberOrTagParam,
+      true,
+    ]);
+
+    makeObservable(this);
+  }
+
+  @computed
+  get block(): EthereumBlock | undefined {
+    if (!this.response) {
+      return;
+    }
+
+    return this.response.data;
+  }
+}
+
+export class ObservableQueryEthereumBlock extends ObservableEvmChainJsonRpcQueryMap<EthereumBlock> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) {
+    super(
+      sharedContext,
+      chainId,
+      chainGetter,
+      (blockNumberOrTagParam: string) => {
+        return new ObservableQueryEthereumBlockInner(
+          this.sharedContext,
+          this.chainId,
+          this.chainGetter,
+          blockNumberOrTagParam
+        );
+      }
+    );
+  }
+
+  getQueryByBlockNumberOrTag(
+    blockNumberOrTag?: number | string
+  ): ObservableQueryEthereumBlockInner {
+    const blockNumberOrTagParam =
+      typeof blockNumberOrTag === "number"
+        ? `0x${Number(blockNumberOrTag).toString(16)}`
+        : blockNumberOrTag;
+
+    return this.get(
+      blockNumberOrTagParam ?? "latest"
+    ) as ObservableQueryEthereumBlockInner;
+  }
+}

package/src/queries/erc20-balance.ts

@@ -0,0 +1,103 @@
+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 { erc20ContractInterface } from "../constants";
+import { DenomHelper } from "@keplr-wallet/common";
+import { EthereumAccountBase } from "../account";
+
+export class ObservableQueryEthereumERC20BalanceImpl
+  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 ethereumHexAddress: string,
+    protected readonly contractAddress: string
+  ) {
+    super(sharedContext, ethereumURL, "", "eth_call", [
+      {
+        to: contractAddress,
+        data: erc20ContractInterface.encodeFunctionData("balanceOf", [
+          ethereumHexAddress,
+        ]),
+      },
+      "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: ${this.contractAddress}`);
+    }
+
+    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 ObservableQueryEthereumERC20BalanceRegistry
+  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 !== "erc20" || !isHexAddress || !chainInfo.evm) {
+      return;
+    }
+
+    return new ObservableQueryEthereumERC20BalanceImpl(
+      this.sharedContext,
+      chainId,
+      chainGetter,
+      denomHelper,
+      chainInfo.evm.rpc,
+      address,
+      denomHelper.contractAddress
+    );
+  }
+}

package/src/queries/erc20-contract-info.ts

@@ -0,0 +1,66 @@
+import {
+  ChainGetter,
+  HasMapStore,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { ObservableQueryEVMChainERC20MetadataInner } from "./erc20-metadata";
+import { computed } from "mobx";
+
+interface ERC20ContractInfo {
+  decimals: number;
+  symbol: string;
+}
+
+export class ObservableQueryERC20ContactInfoInner extends ObservableQueryEVMChainERC20MetadataInner {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    contractAddress: string
+  ) {
+    super(sharedContext, chainId, chainGetter, contractAddress);
+  }
+
+  @computed
+  get tokenInfo(): ERC20ContractInfo | undefined {
+    if (this.symbol === undefined || this.decimals === undefined) {
+      return undefined;
+    }
+
+    return {
+      decimals: this.decimals,
+      symbol: this.symbol,
+    };
+  }
+
+  get isFetching(): boolean {
+    return this._querySymbol.isFetching || this._queryDecimals.isFetching;
+  }
+
+  get error() {
+    return this._querySymbol.error || this._queryDecimals.error;
+  }
+}
+
+export class ObservableQueryERC20ContractInfo extends HasMapStore<ObservableQueryERC20ContactInfoInner> {
+  constructor(
+    protected readonly sharedContext: QuerySharedContext,
+    protected readonly chainId: string,
+    protected readonly chainGetter: ChainGetter
+  ) {
+    super((contractAddress: string) => {
+      return new ObservableQueryERC20ContactInfoInner(
+        this.sharedContext,
+        this.chainId,
+        this.chainGetter,
+        contractAddress
+      );
+    });
+  }
+
+  getQueryContract(
+    contractAddress: string
+  ): ObservableQueryERC20ContactInfoInner {
+    return this.get(contractAddress) as ObservableQueryERC20ContactInfoInner;
+  }
+}

package/src/queries/erc20-metadata.ts

@@ -0,0 +1,184 @@
+import {
+  ChainGetter,
+  HasMapStore,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { Interface } from "@ethersproject/abi";
+import { computed, makeObservable } from "mobx";
+import { ObservableEvmChainJsonRpcQuery } from "./evm-chain-json-rpc";
+
+const erc20MetadataInterface: Interface = new Interface([
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        name: "",
+        type: "string",
+      },
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        name: "",
+        type: "uint8",
+      },
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function",
+  },
+]);
+
+export class ObservableQueryEVMChainERC20MetadataSymbol extends ObservableEvmChainJsonRpcQuery<string> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    protected contractAddress: string
+  ) {
+    super(sharedContext, chainId, chainGetter, "eth_call", [
+      {
+        to: contractAddress,
+        data: erc20MetadataInterface.encodeFunctionData("symbol"),
+      },
+      "latest",
+    ]);
+
+    makeObservable(this);
+  }
+
+  protected override canFetch(): boolean {
+    return super.canFetch() && this.contractAddress !== "";
+  }
+
+  @computed
+  get symbol(): string | undefined {
+    if (!this.response) {
+      return undefined;
+    }
+
+    try {
+      return erc20MetadataInterface.decodeFunctionResult(
+        "symbol",
+        this.response.data
+      )[0];
+    } catch (e) {
+      console.log(e);
+    }
+    return undefined;
+  }
+}
+
+export class ObservableQueryEVMChainERC20MetadataDecimals extends ObservableEvmChainJsonRpcQuery<string> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    protected contractAddress: string
+  ) {
+    super(sharedContext, chainId, chainGetter, "eth_call", [
+      {
+        to: contractAddress,
+        data: erc20MetadataInterface.encodeFunctionData("decimals"),
+      },
+      "latest",
+    ]);
+
+    makeObservable(this);
+  }
+
+  protected override canFetch(): boolean {
+    return super.canFetch() && this.contractAddress !== "";
+  }
+
+  @computed
+  get decimals(): number | undefined {
+    if (!this.response) {
+      return undefined;
+    }
+
+    try {
+      return erc20MetadataInterface.decodeFunctionResult(
+        "decimals",
+        this.response.data
+      )[0];
+    } catch (e) {
+      console.log(e);
+    }
+    return undefined;
+  }
+}
+
+export class ObservableQueryEVMChainERC20MetadataInner {
+  protected readonly _querySymbol: ObservableQueryEVMChainERC20MetadataSymbol;
+  protected readonly _queryDecimals: ObservableQueryEVMChainERC20MetadataDecimals;
+
+  constructor(
+    protected readonly sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    contractAddress: string
+  ) {
+    this._querySymbol = new ObservableQueryEVMChainERC20MetadataSymbol(
+      sharedContext,
+      chainId,
+      chainGetter,
+      contractAddress
+    );
+
+    this._queryDecimals = new ObservableQueryEVMChainERC20MetadataDecimals(
+      sharedContext,
+      chainId,
+      chainGetter,
+      contractAddress
+    );
+  }
+
+  get querySymbol(): ObservableQueryEVMChainERC20MetadataSymbol {
+    return this._querySymbol;
+  }
+
+  get queryDecimals(): ObservableQueryEVMChainERC20MetadataDecimals {
+    return this._queryDecimals;
+  }
+
+  get symbol(): string | undefined {
+    return this._querySymbol.symbol;
+  }
+
+  get decimals(): number | undefined {
+    return this._queryDecimals.decimals;
+  }
+}
+
+export class ObservableQueryEVMChainERC20Metadata extends HasMapStore<ObservableQueryEVMChainERC20MetadataInner> {
+  constructor(
+    protected readonly sharedContext: QuerySharedContext,
+    protected readonly chainId: string,
+    protected readonly chainGetter: ChainGetter
+  ) {
+    super((contractAddress) => {
+      return new ObservableQueryEVMChainERC20MetadataInner(
+        this.sharedContext,
+        this.chainId,
+        this.chainGetter,
+        contractAddress
+      );
+    });
+  }
+
+  override get(
+    contractAddress: string
+  ): ObservableQueryEVMChainERC20MetadataInner {
+    return super.get(contractAddress);
+  }
+}

package/src/queries/evm-chain-json-rpc.ts

@@ -0,0 +1,48 @@
+import {
+  ChainGetter,
+  HasMapStore,
+  ObservableJsonRPCQuery,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+
+export class ObservableEvmChainJsonRpcQuery<
+  T = unknown,
+  E = unknown
+> extends ObservableJsonRPCQuery<T, E> {
+  // Chain Id should not be changed after creation.
+  protected readonly _chainId: string;
+  protected readonly chainGetter: ChainGetter;
+
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    method: string,
+    params: any[]
+  ) {
+    const chainInfo = chainGetter.getChain(chainId);
+
+    super(sharedContext, chainInfo.evm?.rpc ?? "", "", method, params);
+
+    this._chainId = chainId;
+    this.chainGetter = chainGetter;
+  }
+
+  get chainId(): string {
+    return this._chainId;
+  }
+}
+
+export class ObservableEvmChainJsonRpcQueryMap<
+  T = unknown,
+  E = unknown
+> extends HasMapStore<ObservableEvmChainJsonRpcQuery<T, E>> {
+  constructor(
+    protected readonly sharedContext: QuerySharedContext,
+    protected readonly chainId: string,
+    protected readonly chainGetter: ChainGetter,
+    creater: (key: string) => ObservableEvmChainJsonRpcQuery<T, E>
+  ) {
+    super(creater);
+  }
+}

package/src/queries/fee-histroy.ts

@@ -0,0 +1,80 @@
+import { ChainGetter, QuerySharedContext } from "@keplr-wallet/stores";
+import { computed, makeObservable } from "mobx";
+import {
+  ObservableEvmChainJsonRpcQuery,
+  ObservableEvmChainJsonRpcQueryMap,
+} from "./evm-chain-json-rpc";
+
+interface EthereumFeeHistory {
+  oldestBlock: string;
+  baseFeePerGas?: string[];
+  gasUsedRatio: number[];
+  reward?: string[][];
+}
+
+export class ObservableQueryEthereumFeeHistoryInner extends ObservableEvmChainJsonRpcQuery<EthereumFeeHistory> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter,
+    blockCount: string | number,
+    newestBlock: string,
+    rewardPercentiles: number[]
+  ) {
+    super(sharedContext, chainId, chainGetter, "eth_feeHistory", [
+      blockCount,
+      newestBlock,
+      rewardPercentiles,
+    ]);
+
+    makeObservable(this);
+  }
+
+  @computed
+  get feeHistory(): EthereumFeeHistory | undefined {
+    if (!this.response) {
+      return;
+    }
+
+    return this.response.data;
+  }
+}
+
+export class ObservableQueryEthereumFeeHistory extends ObservableEvmChainJsonRpcQueryMap<EthereumFeeHistory> {
+  constructor(
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) {
+    super(sharedContext, chainId, chainGetter, (stringifiedParams: string) => {
+      const params = (() => {
+        try {
+          return JSON.parse(stringifiedParams);
+        } catch {
+          throw new Error("Invalid JSON RPC params");
+        }
+      })();
+      const blockCount = params[0];
+      const newestBlock = params[1];
+      const rewardPercentiles = params[2];
+
+      return new ObservableQueryEthereumFeeHistoryInner(
+        this.sharedContext,
+        this.chainId,
+        this.chainGetter,
+        blockCount,
+        newestBlock,
+        rewardPercentiles
+      );
+    });
+  }
+
+  getQueryByFeeHistoryParams(
+    blockCount: string | number,
+    newestBlock: string,
+    rewardPercentiles: number[]
+  ): ObservableQueryEthereumFeeHistoryInner {
+    const key = JSON.stringify([blockCount, newestBlock, rewardPercentiles]);
+    return this.get(key) as ObservableQueryEthereumFeeHistoryInner;
+  }
+}

package/src/queries/index.ts

@@ -0,0 +1,86 @@
+import {
+  QueriesSetBase,
+  ChainGetter,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { ObservableQueryEthAccountBalanceRegistry } from "./balance";
+import { ObservableQueryEthereumERC20BalanceRegistry } from "./erc20-balance";
+import { DeepReadonly } from "utility-types";
+import { ObservableQueryEthereumBlock } from "./block";
+import { ObservableQueryEthereumFeeHistory } from "./fee-histroy";
+import { ObservableQueryEVMChainERC20Metadata } from "./erc20-metadata";
+import { ObservableQueryERC20ContractInfo } from "./erc20-contract-info";
+
+export interface EthereumQueries {
+  ethereum: EthereumQueriesImpl;
+}
+
+export const EthereumQueries = {
+  use(): (
+    queriesSetBase: QueriesSetBase,
+    sharedContext: QuerySharedContext,
+    chainId: string,
+    chainGetter: ChainGetter
+  ) => EthereumQueries {
+    return (
+      queriesSetBase: QueriesSetBase,
+      sharedContext: QuerySharedContext,
+      chainId: string,
+      chainGetter: ChainGetter
+    ) => {
+      return {
+        ethereum: new EthereumQueriesImpl(
+          queriesSetBase,
+          sharedContext,
+          chainId,
+          chainGetter
+        ),
+      };
+    };
+  },
+};
+
+export class EthereumQueriesImpl {
+  public readonly queryEthereumBlock: DeepReadonly<ObservableQueryEthereumBlock>;
+  public readonly queryEthereumFeeHistory: DeepReadonly<ObservableQueryEthereumFeeHistory>;
+  public readonly queryEthereumERC20Metadata: DeepReadonly<ObservableQueryEVMChainERC20Metadata>;
+  public readonly queryEthereumERC20ContractInfo: DeepReadonly<ObservableQueryERC20ContractInfo>;
+
+  constructor(
+    base: QueriesSetBase,
+    sharedContext: QuerySharedContext,
+    protected chainId: string,
+    protected chainGetter: ChainGetter
+  ) {
+    base.queryBalances.addBalanceRegistry(
+      new ObservableQueryEthAccountBalanceRegistry(sharedContext)
+    );
+    base.queryBalances.addBalanceRegistry(
+      new ObservableQueryEthereumERC20BalanceRegistry(sharedContext)
+    );
+
+    this.queryEthereumBlock = new ObservableQueryEthereumBlock(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
+
+    this.queryEthereumFeeHistory = new ObservableQueryEthereumFeeHistory(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
+
+    this.queryEthereumERC20Metadata = new ObservableQueryEVMChainERC20Metadata(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
+
+    this.queryEthereumERC20ContractInfo = new ObservableQueryERC20ContractInfo(
+      sharedContext,
+      chainId,
+      chainGetter
+    );
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "build",
+    "declaration": true,
+    "rootDir": "src"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}