@berachain/berajs 0.1.2 → 0.2.0

package/src/types/{dex.ts → dex.d.ts}

@@ -1,29 +1,23 @@
 import type { SwapKind } from "@berachain-foundation/berancer-sdk";
-import type { Abi, Address, PublicClient } from "viem";
+import type { Abi, Address, Hex, PublicClient } from "viem";
 
-import type { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
 import type { HoneyConfigContextReturn } from "~/contexts/HoneyConfigProvider";
-import type { IContractWrite, TokenBalance } from "./global";
 
 export type MinimalERC20 = {
   address: Address;
   decimals: number;
   symbol: string;
   name: string;
+  chainId: number;
 };
 
 export type TokenWithMetadata = MinimalERC20 & {
   tags?: string[];
   base64?: string;
   logoURI?: string;
-  chainId?: number;
 };
 
 export type Token = TokenWithMetadata & {
-  /**
-   * @deprecated
-   */
-  default?: boolean;
   totalSupply?: string;
   weight?: number | string | null;
 };
@@ -31,6 +25,7 @@ export type Token = TokenWithMetadata & {
 export interface TokenPriceInfo {
   price: number;
   updatedAt: number;
+  chainId: number;
 }
 
 export type TokenCurrentPriceMap = Record<
@@ -40,19 +35,39 @@ export type TokenCurrentPriceMap = Record<
 
 export interface TokenWithAmount extends Token {
   amount: string;
+  exceeding?: boolean;
 }
 
-export interface BalanceToken extends Token {
-  balance: bigint;
-  formattedBalance: string;
-  price?: number;
+export interface TokenWithPrice extends Token {
+  price: number;
 }
 
-export type BalanceTokenWithMetadata = BalanceToken & TokenWithMetadata;
-
-export interface TokenInput extends Token {
-  amount: string;
-  exceeding: boolean;
+export interface BalanceToken extends Token {
+  balance: {
+    /**
+     * This is the string representation of the balance in wei.
+     *
+     * It can be safely parsed to a bigint, but we're returning it as a string to avoid serialization issues.
+     *
+     * @example "1200000000000000000"
+     */
+    raw: string;
+    /**
+     * This is the formatted representation of the balance in the token's decimals.
+     *
+     * @example "1.2"
+     */
+    formatted: string;
+  };
+  /**
+   * Price of the token in USD.
+   */
+  price?: number;
+  /**
+   * Balance value in USD.
+   * Calculated as balance * price.
+   */
+  usdValue?: number;
 }
 
 export interface SwapRequest {
@@ -65,25 +80,48 @@ export interface SwapRequest {
   swapKind: SwapKind;
 }
 
+/**
+ * Object with properties to check the allowance of a token.
+ */
+export interface AllowanceQueryItem {
+  token: MinimalERC20;
+  /**
+   * The amount of the token to approve.
+   */
+  amount: {
+    raw: string;
+    formatted: string;
+  };
+  /**
+   * The address to approve the tokens to.
+   */
+  spender: Address;
+}
+
+export interface AllowanceToken extends AllowanceQueryItem {
+  /**
+   * The current allowance of the token.
+   */
+  allowance: {
+    raw: string;
+    formatted: string;
+  };
+  /**
+   * Whether the allowance is needed to perform the transaction.
+   */
+  needsApproval: boolean;
+}
+
 export interface IUserPosition {
-  lpBalance?: TokenBalance;
-  tokenBalances?: TokenBalance[];
+  lpBalance?: BalanceToken;
+  tokenBalances?: Omit<BalanceToken, "chainId">[];
   userSharePercentage?: number;
-  stakedBalance?: TokenBalance;
+  stakedBalance?: Pick<BalanceToken, "address" | "balance" | "usdValue">;
   /**
    * Just a utility to detect if there is a price for the LP token.
    */
   lpTokenPrice?: number;
 }
-
-export enum PoolCreationStep {
-  POOL_TYPE = "Pool Type",
-  SELECT_TOKENS = "Select Tokens",
-  DEPOSIT_LIQUIDITY = "Deposit Liquidity",
-  SET_PARAMETERS = "Set Parameters",
-  SET_INFO = "Set Info",
-}
-
 export type BexStatus = {
   protocol: {
     /**
@@ -120,10 +158,11 @@ export type BexStatus = {
 };
 
 export type IAggregatorArgs = {
-  tokenIn: string;
-  tokenOut: string;
-  tokenInDecimals?: number;
-  tokenOutDecimals?: number;
+  tokenIn: MinimalERC20;
+  tokenOut: MinimalERC20;
+  /**
+   * Amount of tokenIn to swap in wei.
+   */
   amount: string;
   slippage: number;
   account?: Address;
@@ -131,55 +170,50 @@ export type IAggregatorArgs = {
   aggregatorsFeeBps?: number;
   proxyAggregatorsThroughVercel?: boolean;
   referrer?: SwapReferrer;
+  /**
+   * If provided, the aggregator will swap to the underlying token and deposit it into the vault (tokenOut).
+   *
+   * The aggregator won't check if the tokenOut is an ERC4626 vault, so this needs to be asserted by the caller.
+   * This is used for Staked BERA/iBera and Bend Vaults.
+   */
+  underlyingToken?: MinimalERC20 | null;
   /**
    * If provided, the aggregator will stake into the reward vault after the swap.
    */
   rewardVault?: Address;
+  /**
+   * Only needed by the honey mint/redeem aggregator.
+   */
   honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
 };
 
-export enum Aggregators {
-  Oogabooga = "Oogabooga",
-  Fly = "Fly",
-  HubPools = "Hub Pools",
-  Wrap = "Wrap",
-  Unwrap = "Unwrap",
-  KyberSwap = "KyberSwap",
-  OpenOcean = "OpenOcean",
-  Haiku = "Haiku",
-  Enso = "Enso",
-  RedeemBgt = "RedeemBgt",
-  Honey = "Honey",
-}
+export type Calldata = {
+  params?: readonly unknown[] | undefined;
+  functionName?: string;
+  abi?: Abi;
+  address: Address;
+  data?: Hex;
+  value: bigint;
+  gasLimit?: bigint;
+};
 
-export type IRawAggregatorQuote<isRoutedThroughAggregator = true> = {
+export type IRawAggregatorQuote = {
   amountOut: string;
   amountIn: string;
   name: Aggregators;
-  spender: Address | undefined;
+  allowanceRequirements: AllowanceQueryItem[];
   /**
    * True if it's bera wrap/unwrap or bgt redeem.
    */
   isNativeSwap?: boolean;
-  priceImpactPercentage?: number;
+  priceImpactPercentage?: number | null;
   swapFeeBps: number;
-  calldata?: isRoutedThroughAggregator extends true
-    ? Omit<
-        IContractWrite<typeof aggregatorsRouterAbi, "swap">,
-        "message" | "actionType"
-      >
-    : {
-        params: readonly unknown[] | undefined;
-        functionName: string;
-        abi: Abi;
-        address: Address;
-        value?: bigint;
-      };
+  getCalldata?: ({ account }: { account: Address }) => Calldata;
 };
 
 export type IAggregatorQuote =
   // no need to force to swapAndStake as type check is done on each getQuote
-  IRawAggregatorQuote<false> & {
+  IRawAggregatorQuote & {
     amountOut: string;
     amountOutUsd: string;
     amountIn: string;
@@ -189,8 +223,3 @@ export type IAggregatorQuote =
     relativeLossPercentage: number;
     isBest?: boolean;
   };
-
-export enum SwapReferrer {
-  SWAP = "SWAP",
-  ZAP = "ZAP",
-}

package/src/types/{enso.ts → enso.d.ts}

@@ -8,7 +8,7 @@ type StrictOutputReference<T> = {
   index?: number;
 };
 
-export interface GetZapTransactionRequestsArgs {
+export interface GetEnsoSwapBundleArgs {
   fromAddress: Address;
   amountIn: Quantity;
   tokenIn: Address;

package/src/types/exports.ts

@@ -0,0 +1,8 @@
+export * from "./bribe-boost.d";
+export * from "./dex.d";
+export * from "./enso.d";
+export * from "./global.d";
+export * from "./governance.d";
+export * from "./honeySwap.d";
+export * from "./pol.d";
+export * from "./staking.d";

package/src/types/{global.ts → global.d.ts}

@@ -13,12 +13,12 @@ import type {
 
 import type { BeraConfig, ChainId } from "@berachain/config";
 
+import type { ContractName } from "~/enum/contracts";
 import type { TransactionActionType } from "~/enum/txnEnum";
 import type {
   IUseContractWriteArgs,
   TxnEventKeys,
 } from "~/hooks/useContractWrite/types";
-import type { Token } from "./dex";
 
 export type DefaultHookOptions = {
   opts?: SWRConfiguration & { isEnabled?: boolean };
@@ -31,24 +31,6 @@ export type DefaultHookReturnType<T = any> = Omit<
   refresh: () => void;
 };
 
-export interface TokenBalance {
-  address: Address;
-  /**
-   * Balance in wei, should be string to be serializable in JSON
-   */
-  balance: bigint | string;
-  formattedBalance: string;
-  /**
-   * Balance in USD
-   */
-  usdValue?: number;
-}
-
-export interface AllowanceToken extends Token {
-  allowance: bigint;
-  formattedAllowance: string;
-}
-
 export type IContractWriteFn = <
   abi extends Abi | undefined = undefined,
   functionName extends abi extends Abi
@@ -84,17 +66,6 @@ type EventData = Record<
     >
 >;
 
-/**
- * A list of contract names that are not mapped in the devrel's contract mapping or that are generated by factories (e.g. RewardVault).
- */
-export enum ContractName {
-  ENSO_ROUTER = "enso.router",
-  POL_REWARD_VAULT = "pol.rewardVault",
-  BEX_POOL = "bex.pool",
-  ERC20 = "others.erc20",
-  BEX_EXPLOITED_FUND_DISTRIBUTOR = "bex.exploitedFundDistributor",
-}
-
 export type IContractWrite<
   abi extends Abi | undefined = undefined,
   functionName extends abi extends Abi

package/src/types/{governance.ts → governance.d.ts}

@@ -5,57 +5,20 @@ import type {
   ProposalWithVotesFragment,
 } from "@berachain/graphql/governance";
 
+import type { ProposalErrorCodes, ProposalTypeEnum } from "~/enum/governance";
+
 export type Proposal = ProposalWithVotesFragment;
 
 export type Vote = ProposalVoteFragment;
 
 export type Voter = Address;
 
-/**
- * Maps the proposal state from the governor contract to a more human-readable format.
- * Don't edit this enum manually, it's synced with the governor contract.
- *
- * @see https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/governance/IGovernor.sol
- */
-export enum ProposalState {
-  Pending = 0,
-  Active = 1,
-  Canceled = 2,
-  Defeated = 3,
-  Succeeded = 4,
-  Queued = 5,
-  Expired = 6,
-  Executed = 7,
-}
-
 export type ProposalVotes = {
   yes: number;
   no: number;
   abstain: number;
 };
 
-export const VoteColorMap = {
-  yes: "#059669",
-  1: "#059669",
-  no: "#DC2629",
-  2: "#DC2629",
-  veto: "#0284C7",
-  4: "#0284C7",
-  abstain: "#78716c",
-  3: "#78716c",
-  yes_secondary: "#ECFDF5",
-  no_secondary: "#FEF2F2",
-  veto_secondary: "#F0F9FF",
-  abstain_secondary: "#E7E5E4",
-  default: "#57534e",
-};
-
-export enum VoteEnum {
-  AGAINST = "no",
-  FOR = "yes",
-  ABSTAIN = "abstain",
-}
-
 export type PROPOSAL_GENRE = "berahub" | "honey" | "bend" | "berps" | "general";
 
 export type CustomProposalActionErrors = {
@@ -84,22 +47,6 @@ export type CustomProposalErrors = {
   actions?: CustomProposalActionErrors[];
 };
 
-export enum ProposalErrorCodes {
-  REQUIRED = "Required",
-  INVALID_AMOUNT = "Invalid amount",
-  NEGATIVE_AMOUNT = "Negative amount",
-  INVALID_ADDRESS = "Invalid address",
-  INVALID_ACTION = "Invalid action",
-  INVALID_ABI = "Invalid ABI",
-  MUST_BE_HTTPS = "Must be HTTPS",
-  MUST_BE_HTTPS_OR_IPFS = "Must be HTTPS or IPFS",
-  INVALID_BASEPATH = "Must be a berachain forum link",
-  /**
-   * Mainly used when it's not a reward vault
-   */
-  INVALID_CONTRACT = "This is not a valid contract",
-}
-
 export type GovernanceTopic = {
   id: PROPOSAL_GENRE;
   color: string;
@@ -111,15 +58,6 @@ export type GovernanceTopic = {
   description?: string;
   comingSoon?: boolean;
 };
-
-export enum ProposalTypeEnum {
-  CUSTOM_PROPOSAL = "custom-action",
-  WHITELIST_REWARD_VAULT = "whitelist-reward-vault",
-  BLACKLIST_REWARD_VAULT = "blacklist-reward-vault",
-  ERC20_TRANSFER = "erc20-transfer",
-  WHITELIST_REWARD_VAULT_INCENTIVE = "whitelist-reward-vault-incentive",
-}
-
 export type CustomProposal = {
   title: string;
   description: any;

package/src/types/{honeySwap.ts → honeySwap.d.ts}

@@ -2,19 +2,7 @@ import type { Address, Hex } from "viem";
 
 import type { HoneyPreviewResult } from "~/actions/honey/getHoneyPreview";
 import type { TokenWithOrder } from "~/contexts/HoneyConfigProvider";
-
-export enum HoneySwapAction {
-  RESET_AMOUNTS = "RESET_AMOUNTS",
-  ACTION_TYPE_CHANGE = "ACTION_TYPE_CHANGE",
-  COLLATERALS_CHANGE = "COLLATERALS_CHANGE",
-  FROM_AMOUNT_CHANGE = "FROM_AMOUNT_CHANGE",
-  TO_AMOUNT_CHANGE = "TO_AMOUNT_CHANGE",
-  PREVIEW_CHANGE = "PREVIEW_CHANGE",
-  IS_BASKET_MODE_ENABLED_CHANGE = "IS_BASKET_MODE_ENABLED_CHANGE",
-  IS_TYPING_CHANGE = "IS_TYPING_CHANGE",
-  IS_SUBMITTING_CHANGE = "IS_SUBMITTING_CHANGE",
-  IS_LOADING_CHANGE = "IS_LOADING_CHANGE",
-}
+import type { HoneySwapAction } from "~/enum/honey";
 
 export type PythPriceFeedMap = Record<Address, Hex>;
 

package/src/types/{pol.ts → pol.d.ts}

@@ -2,7 +2,7 @@ import type { Address } from "viem";
 
 import type { ApiValidatorFragment } from "@berachain/graphql/pol/api";
 
-import type { Token } from "./dex";
+import type { Token, TokenWithMetadata } from "./dex";
 
 export type IncentiveReward = {
   tokenMetadata: Token | undefined;
@@ -23,6 +23,7 @@ export interface IncentiveRewardChunksWithValidatorData {
   minTimestamp: number | undefined;
   totalValue: number;
   tokenTotals: {
+    chainId: number;
     address: Address;
     amount: number;
     value: number;
@@ -37,6 +38,7 @@ export interface AggregatedTokenTotals {
   amount: number;
   value: number;
   metadata: Token | undefined;
+  chainId: number;
 }
 
 export type ClaimedIncentives = Record<string, string>;
@@ -50,3 +52,12 @@ export interface UserVaultInfo {
   rewards: string;
   percentage: string;
 }
+
+export type StakedBeraAsset = {
+  token: TokenWithMetadata;
+  apr: number;
+  stakedAmount: number;
+  stakedAmountUsd: number;
+  earnedAmount: number;
+  earnedAmountUsd: number;
+};

package/src/types/staking.d.ts

@@ -0,0 +1,22 @@
+import type { TokenWithMetadata } from "./dex";
+
+export interface ProtocolMetadata {
+  name: string;
+  logoURI: string;
+  url: string;
+  description: string;
+  tags?: string[];
+}
+
+/**
+ * Configuration for a single staking option.
+ * Maps receipt tokens to their accepted input tokens.
+ */
+export type StakingConfig = {
+  /** Unique identifier for this staking config */
+  id: string;
+  /** The token received when staking (e.g., sWBERA, siBERA) */
+  receiptToken: TokenWithMetadata;
+  /** Tokens that can be staked to receive the receipt token */
+  inputTokens: TokenWithMetadata[];
+};

package/src/utils/createEmitter.ts

@@ -0,0 +1,122 @@
+interface EventsMap {
+  [event: string]: any;
+}
+
+interface DefaultEvents extends EventsMap {
+  [event: string]: (...args: any) => void;
+}
+
+export type Unsubscribe = () => void;
+
+export interface Emitter<Events extends EventsMap = DefaultEvents> {
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on<K extends keyof Events>(event: K, cb: Events[K]): Unsubscribe;
+  events: Partial<{ [E in keyof Events]: Events[E][] }>;
+}
+
+/**
+ * An interface for mixins that expose the `on` function (without the emitter
+ * bound to `this`)
+ *
+ * ```js
+ * import { createEmitter } from '~utils/createEmitter'
+ *
+ * class Ticker implements EmitterMixin<Events> {
+ *   constructor() {
+ *     this.emitter = createEmitter()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ */
+export interface EmitterMixin<Events extends EventsMap = DefaultEvents> {
+  on<K extends keyof Events>(event: K, cb: Events[K]): Unsubscribe;
+}
+
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import { createEmitter } from '~/utils/createEmitter'
+ *
+ * class Ticker {
+ *   constructor() {
+ *     this.emitter = createEmitter()
+ *   }
+ *   on(...args) {
+ *     return this.emitter.on(...args)
+ *   }
+ *   tick() {
+ *     this.emitter.emit('tick')
+ *   }
+ * }
+ * ```
+ *
+ * Inspired by {@link https://github.com/ai/nanoevents}
+ */
+export function createEmitter<
+  Events extends EventsMap = DefaultEvents,
+>(): Emitter<Events> {
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * ```js
+   * emitter1.events = emitter2.events
+   * emitter2.events = { }
+   * ```
+   */
+  const events: Partial<{ [E in keyof Events]: Events[E][] }> = {};
+
+  return {
+    emit(event, ...args) {
+      for (const callback of events[event] || []) {
+        callback(...args);
+      }
+    },
+    events,
+    on(event, cb) {
+      if (!events[event]) {
+        events[event] = [];
+      }
+
+      events[event].push(cb);
+
+      return () => {
+        events[event] = events[event]?.filter((i) => cb !== i);
+      };
+    },
+  };
+}