@keplr-wallet/hooks-starknet 0.12.133-rc.0

package/src/tx/amount.ts

@@ -0,0 +1,275 @@
+import {
+  IAmountConfig,
+  IFeeConfig,
+  ISenderConfig,
+  UIProperties,
+} from "./types";
+import { TxChainSetter } from "./chain";
+import { ChainGetter } from "@keplr-wallet/stores";
+import { action, computed, makeObservable, observable } from "mobx";
+import { ERC20Currency } from "@keplr-wallet/types";
+import {
+  EmptyAmountError,
+  InsufficientAmountError,
+  InvalidNumberAmountError,
+  NegativeAmountError,
+  NotSupportedCurrencyError,
+  ZeroAmountError,
+} from "./errors";
+import { CoinPretty, Dec, DecUtils } from "@keplr-wallet/unit";
+import { useState } from "react";
+import { StarknetQueriesStore } from "@keplr-wallet/stores-starknet";
+
+export class AmountConfig extends TxChainSetter implements IAmountConfig {
+  @observable.ref
+  protected _currency?: ERC20Currency = undefined;
+
+  @observable
+  protected _value: string = "";
+
+  @observable
+  protected _fraction: number = 0;
+
+  @observable.ref
+  protected _feeConfig: IFeeConfig | undefined = undefined;
+
+  constructor(
+    chainGetter: ChainGetter,
+    protected readonly starknetQueriesStore: StarknetQueriesStore,
+    initialChainId: string,
+    protected readonly senderConfig: ISenderConfig
+  ) {
+    super(chainGetter, initialChainId);
+
+    makeObservable(this);
+  }
+
+  get feeConfig(): IFeeConfig | undefined {
+    return this._feeConfig;
+  }
+
+  @action
+  setFeeConfig(feeConfig: IFeeConfig | undefined) {
+    this._feeConfig = feeConfig;
+  }
+
+  @computed
+  get value(): string {
+    if (this.fraction > 0) {
+      let result = this.starknetQueriesStore
+        .get(this.chainId)
+        .queryStarknetERC20Balance.getBalance(
+          this.chainId,
+          this.chainGetter,
+          this.senderConfig.sender,
+          this.currency.coinMinimalDenom
+        )?.balance;
+      if (!result) {
+        return "0";
+      }
+      if (this.feeConfig) {
+        if (this.feeConfig.fee) {
+          result = result.sub(this.feeConfig.fee);
+        }
+      }
+      if (result.toDec().lte(new Dec(0))) {
+        return "0";
+      }
+
+      return result
+        .mul(new Dec(this.fraction))
+        .trim(true)
+        .locale(false)
+        .hideDenom(true)
+        .toString();
+    }
+
+    return this._value;
+  }
+
+  @action
+  setValue(value: string): void {
+    if (value.startsWith(".")) {
+      value = "0" + value;
+    }
+
+    this._value = value;
+
+    this.setFraction(0);
+  }
+
+  @computed
+  get amount(): CoinPretty[] {
+    let amount: Dec;
+    try {
+      if (this.value.trim() === "") {
+        amount = new Dec(0);
+      } else {
+        amount = new Dec(this.value);
+      }
+    } catch {
+      amount = new Dec(0);
+    }
+
+    return [
+      new CoinPretty(
+        this.currency,
+        amount
+          .mul(DecUtils.getTenExponentN(this.currency.coinDecimals))
+          .truncate()
+      ),
+    ];
+  }
+
+  @computed
+  get currency(): ERC20Currency {
+    const modularChainInfo = this.modularChainInfo;
+    if (!("starknet" in modularChainInfo)) {
+      throw new Error("Chain doesn't support the starknet");
+    }
+
+    if (this._currency) {
+      const find = modularChainInfo.starknet.currencies.find(
+        (cur) => cur.coinMinimalDenom === this._currency!.coinMinimalDenom
+      );
+      if (find) {
+        return find;
+      }
+    }
+
+    return modularChainInfo.starknet.currencies[0];
+  }
+
+  @action
+  setCurrency(currency: ERC20Currency | undefined) {
+    if (currency?.coinMinimalDenom !== this._currency?.coinMinimalDenom) {
+      this._value = "";
+      this.setFraction(0);
+    }
+
+    this._currency = currency;
+  }
+
+  get fraction(): number {
+    return this._fraction;
+  }
+
+  @action
+  setFraction(fraction: number): void {
+    this._fraction = fraction;
+  }
+
+  canUseCurrency(currency: ERC20Currency): boolean {
+    const modularChainInfo = this.modularChainInfo;
+    if (!("starknet" in modularChainInfo)) {
+      throw new Error("Chain doesn't support the starknet");
+    }
+
+    return (
+      modularChainInfo.starknet.currencies.find(
+        (cur) => cur.coinMinimalDenom === currency.coinMinimalDenom
+      ) != null
+    );
+  }
+
+  @computed
+  get uiProperties(): UIProperties {
+    if (!this.currency) {
+      return {
+        error: new Error("Currency to send not set"),
+      };
+    }
+
+    if (this.value.trim() === "") {
+      return {
+        error: new EmptyAmountError("Amount is empty"),
+      };
+    }
+
+    try {
+      const dec = new Dec(this.value);
+      if (dec.equals(new Dec(0))) {
+        return {
+          error: new ZeroAmountError("Amount is zero"),
+        };
+      }
+      if (dec.lt(new Dec(0))) {
+        return {
+          error: new NegativeAmountError("Amount is negative"),
+        };
+      }
+    } catch {
+      return {
+        error: new InvalidNumberAmountError("Invalid form of number"),
+      };
+    }
+
+    for (const amount of this.amount) {
+      const currency = amount.currency;
+
+      if (!("type" in currency) || currency.type !== "erc20") {
+        return {
+          error: new NotSupportedCurrencyError("Not supported currency"),
+        };
+      }
+
+      if (!this.canUseCurrency(currency)) {
+        return {
+          error: new NotSupportedCurrencyError("Not supported currency"),
+        };
+      }
+
+      const bal = this.starknetQueriesStore
+        .get(this.chainId)
+        .queryStarknetERC20Balance.getBalance(
+          this.chainId,
+          this.chainGetter,
+          this.senderConfig.sender,
+          currency.coinMinimalDenom
+        );
+
+      if (!bal) {
+        return {
+          warning: new Error(
+            `Can't parse the balance for ${currency.coinMinimalDenom}`
+          ),
+        };
+      }
+
+      if (bal.error) {
+        return {
+          warning: new Error("Failed to fetch balance"),
+        };
+      }
+
+      if (!bal.response) {
+        return {
+          loadingState: "loading-block",
+        };
+      }
+
+      if (bal.balance.toDec().lt(amount.toDec())) {
+        return {
+          error: new InsufficientAmountError("Insufficient amount"),
+          loadingState: bal.isFetching ? "loading" : undefined,
+        };
+      }
+    }
+
+    return {};
+  }
+}
+
+export const useAmountConfig = (
+  chainGetter: ChainGetter,
+  queriesStore: StarknetQueriesStore,
+  chainId: string,
+  senderConfig: ISenderConfig
+) => {
+  const [txConfig] = useState(
+    () => new AmountConfig(chainGetter, queriesStore, chainId, senderConfig)
+  );
+  txConfig.setChain(chainId);
+
+  return txConfig;
+};

package/src/tx/chain.ts

@@ -0,0 +1,32 @@
+import { action, computed, makeObservable, observable } from "mobx";
+import { ChainGetter } from "@keplr-wallet/stores";
+import { ITxChainSetter } from "./types";
+import { ModularChainInfo } from "@keplr-wallet/types";
+
+export class TxChainSetter implements ITxChainSetter {
+  @observable
+  protected _chainId: string;
+
+  constructor(
+    protected readonly chainGetter: ChainGetter,
+    initialChainId: string
+  ) {
+    this._chainId = initialChainId;
+
+    makeObservable(this);
+  }
+
+  @computed
+  get modularChainInfo(): ModularChainInfo {
+    return this.chainGetter.getModularChain(this.chainId);
+  }
+
+  get chainId(): string {
+    return this._chainId;
+  }
+
+  @action
+  setChain(chainId: string) {
+    this._chainId = chainId;
+  }
+}

package/src/tx/errors.ts

@@ -0,0 +1,127 @@
+export class AccountNotDeployed extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, AccountNotDeployed.prototype);
+  }
+}
+
+export class EmptyAddressError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, EmptyAddressError.prototype);
+  }
+}
+
+export class InvalidBech32Error extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, InvalidBech32Error.prototype);
+  }
+}
+
+export class ICNSIsFetchingError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, ICNSIsFetchingError.prototype);
+  }
+}
+
+export class ICNSFailedToFetchError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, ICNSFailedToFetchError.prototype);
+  }
+}
+
+export class EmptyAmountError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, EmptyAmountError.prototype);
+  }
+}
+
+export class InvalidNumberAmountError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, InvalidNumberAmountError.prototype);
+  }
+}
+
+export class ZeroAmountError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, ZeroAmountError.prototype);
+  }
+}
+
+export class NegativeAmountError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, NegativeAmountError.prototype);
+  }
+}
+
+export class InsufficientAmountError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, InsufficientAmountError.prototype);
+  }
+}
+
+export class NotLoadedFeeError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, NotLoadedFeeError.prototype);
+  }
+}
+
+export class InsufficientFeeError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, InsufficientFeeError.prototype);
+  }
+}
+
+export class UnknownCurrencyError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, UnknownCurrencyError.prototype);
+  }
+}
+
+export class NotSupportedCurrencyError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, UnknownCurrencyError.prototype);
+  }
+}
+
+export class InvalidHexError extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, InvalidHexError.prototype);
+  }
+}
+
+export class MemoSuspectMnemonicInclusion extends Error {
+  constructor(m: string) {
+    super(m);
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, MemoSuspectMnemonicInclusion.prototype);
+  }
+}

package/src/tx/fee.ts

@@ -0,0 +1,209 @@
+import {
+  IAmountConfig,
+  IFeeConfig,
+  IGasConfig,
+  ISenderConfig,
+  UIProperties,
+} from "./types";
+import { TxChainSetter } from "./chain";
+import { ChainGetter } from "@keplr-wallet/stores";
+import { action, computed, makeObservable, observable } from "mobx";
+import { useState } from "react";
+import { StarknetQueriesStore } from "@keplr-wallet/stores-starknet";
+import { CoinPretty, Dec, Int } from "@keplr-wallet/unit";
+import { InsufficientFeeError } from "./errors";
+
+export class FeeConfig extends TxChainSetter implements IFeeConfig {
+  @observable.ref
+  protected _gasPrice: CoinPretty | undefined = undefined;
+  @observable.ref
+  protected _maxGasPrice: CoinPretty | undefined = undefined;
+  @observable
+  protected _type: "ETH" | "STRK" = "STRK";
+
+  @observable
+  protected _disableBalanceCheck: boolean = false;
+
+  constructor(
+    chainGetter: ChainGetter,
+    protected readonly starknetQueriesStore: StarknetQueriesStore,
+    initialChainId: string,
+    protected readonly senderConfig: ISenderConfig,
+    protected readonly amountConfig: IAmountConfig,
+    protected readonly gasConfig: IGasConfig
+  ) {
+    super(chainGetter, initialChainId);
+
+    makeObservable(this);
+  }
+
+  @action
+  setDisableBalanceCheck(bool: boolean) {
+    this._disableBalanceCheck = bool;
+  }
+
+  get disableBalanceCheck(): boolean {
+    return this._disableBalanceCheck;
+  }
+
+  @computed
+  get uiProperties(): UIProperties {
+    if (this.disableBalanceCheck) {
+      return {};
+    }
+
+    if (!this._gasPrice) {
+      return {
+        error: new Error("Fee is not set"),
+        loadingState: "loading-block",
+      };
+    }
+
+    if (!this._maxGasPrice) {
+      return {
+        error: new Error("Fee is not set"),
+        loadingState: "loading-block",
+      };
+    }
+
+    if (!this.fee) {
+      return {
+        error: new Error("Fee is not set"),
+        loadingState: "loading-block",
+      };
+    }
+
+    if (!this.maxFee) {
+      return {
+        error: new Error("Fee is not set"),
+        loadingState: "loading-block",
+      };
+    }
+
+    const maxFee = this.maxFee;
+
+    const bal = this.starknetQueriesStore
+      .get(this.chainId)
+      .queryStarknetERC20Balance.getBalance(
+        this.chainId,
+        this.chainGetter,
+        this.senderConfig.value,
+        maxFee.currency.coinMinimalDenom
+      );
+
+    if (!bal) {
+      return {
+        warning: new Error(
+          `Can't parse the balance for ${maxFee.currency.coinMinimalDenom}`
+        ),
+      };
+    }
+
+    if (bal.error) {
+      return {
+        warning: new Error("Failed to fetch balance"),
+      };
+    }
+
+    if (!bal.response) {
+      return {
+        loadingState: "loading-block",
+      };
+    }
+
+    if (
+      new Int(bal.balance.toCoin().amount).lt(new Int(maxFee.toCoin().amount))
+    ) {
+      return {
+        error: new InsufficientFeeError("Insufficient fee"),
+        loadingState: bal.isFetching ? "loading" : undefined,
+      };
+    }
+
+    return {};
+  }
+
+  get gasPrice(): CoinPretty | undefined {
+    return this._gasPrice;
+  }
+
+  get maxGasPrice(): CoinPretty | undefined {
+    return this._maxGasPrice;
+  }
+
+  get type(): "ETH" | "STRK" {
+    return this._type;
+  }
+
+  @action
+  setGasPrice(
+    gasPrice:
+      | {
+          gasPrice: CoinPretty;
+          maxGasPrice: CoinPretty;
+        }
+      | undefined
+  ): void {
+    this._gasPrice = gasPrice?.gasPrice;
+    this._maxGasPrice = gasPrice?.maxGasPrice;
+  }
+
+  @action
+  setType(type: "ETH" | "STRK"): void {
+    if (this._type !== type) {
+      this._type = type;
+      this._gasPrice = undefined;
+      this._maxGasPrice = undefined;
+    }
+  }
+
+  @computed
+  get fee(): CoinPretty | undefined {
+    if (!this._gasPrice) {
+      return;
+    }
+
+    const gasDec = new Dec(this.gasConfig.gas);
+    return this._gasPrice.mul(gasDec);
+  }
+
+  @computed
+  get maxFee(): CoinPretty | undefined {
+    if (!this._maxGasPrice) {
+      return;
+    }
+
+    const gasDec = new Dec(this.gasConfig.gas);
+    return this._maxGasPrice.mul(gasDec);
+  }
+}
+
+export const useFeeConfig = (
+  chainGetter: ChainGetter,
+  queriesStore: StarknetQueriesStore,
+  chainId: string,
+  senderConfig: ISenderConfig,
+  amountConfig: IAmountConfig,
+  gasConfig: IGasConfig,
+  initialFn?: (config: FeeConfig) => void
+) => {
+  const [config] = useState(() => {
+    const config = new FeeConfig(
+      chainGetter,
+      queriesStore,
+      chainId,
+      senderConfig,
+      amountConfig,
+      gasConfig
+    );
+
+    if (initialFn) {
+      initialFn(config);
+    }
+
+    return config;
+  });
+  config.setChain(chainId);
+
+  return config;
+};