@steerprotocol/sdk 3.0.27 → 3.1.0-test-archived-subgraph-support.1

package/dist/index.d.mts

@@ -1,7 +1,6 @@
 import * as _$viem from "viem";
 import { Address, Client, Hash, PublicClient, TestClient, WalletClient } from "viem";
 import { Campaign, createClient } from "@steerprotocol/api-sdk";
-import { Pool } from "@uniswap/v3-sdk";
 import { Decimal } from "decimal.js";
 
 //#region src/utils/subgraph-types.d.ts
@@ -310,9 +309,7 @@ declare enum MultiPositionManagers {
   MultiPositionHenjinAlgebraHook = "HenjinIntegralHook",
   MultiPositionHydrex = "MultiPositionHydrex",
   MultiPositionBittensorUniV3 = "MultiPositionBittensorUniV3",
-  MultiPositionReserveV4 = "MultiPositionReserveV4",
-  TestCypherAlgebraIntegralHook = "TestCypherAlgebraIntegralHook",
-  TestQuickswapAlgebraIntegralHook = "TestQuickswapAlgebraIntegralHook"
+  MultiPositionReserveV4 = "MultiPositionReserveV4"
 }
 declare const AlgebgraHookBeacons: MultiPositionManagers[];
 declare const UniswapHookBeacons: MultiPositionManagers[];
@@ -585,7 +582,6 @@ type ProtocolInfo = {
   EntryPointAddress?: Partial<{ [chain in Chain]: string }>;
   beaconAlgebraHook?: string;
   algebraHookSupportedChains?: Chain[];
-  algebraHookBeaconsByChain?: Partial<{ [chain in Chain]: string[] }>;
 };
 type AMMConfigType = Partial<{ [protocol in SupportedProtocol]: ProtocolInfo }>;
 interface Fee {
@@ -745,11 +741,6 @@ interface NetworkData {
  * URL for accessing deprecated bundle information
  */
 declare const deprecatedBundlesURL = "https://api.steer.finance/deprecated-bundles";
-/**
- * Configuration mapping of supported chains to their respective subgraph endpoints.
- * Each chain has a dedicated subgraph URL for querying protocol data.
- * Updated each chains for ormi and thegraph
-*/
 declare const steerSubgraphConfig: { [protocol in SteerSupportedChains]: string };
 /**
  * Retrieves the subgraph URL for a given chain ID.
@@ -8554,6 +8545,421 @@ interface PoolSlot0 {
   unlocked: boolean;
 }
 //#endregion
+//#region node_modules/jsbi/jsbi.d.ts
+declare class JSBI {
+  private constructor(length: number, sign: boolean);
+  private length: number;
+  private sign: boolean;
+  static BigInt(from: number | string | boolean | object): JSBI;
+  toString(radix?: number): string;
+  static toNumber(x: JSBI): number;
+  static unaryMinus(x: JSBI): JSBI;
+  static bitwiseNot(x: JSBI): JSBI;
+  static exponentiate(x: JSBI, y: JSBI): JSBI;
+  static multiply(x: JSBI, y: JSBI): JSBI;
+  static divide(x: JSBI, y: JSBI): JSBI;
+  static remainder(x: JSBI, y: JSBI): JSBI;
+  static add(x: JSBI, y: JSBI): JSBI;
+  static subtract(x: JSBI, y: JSBI): JSBI;
+  static leftShift(x: JSBI, y: JSBI): JSBI;
+  static signedRightShift(x: JSBI, y: JSBI): JSBI;
+  static lessThan(x: JSBI, y: JSBI): boolean;
+  static lessThanOrEqual(x: JSBI, y: JSBI): boolean;
+  static greaterThan(x: JSBI, y: JSBI): boolean;
+  static greaterThanOrEqual(x: JSBI, y: JSBI): boolean;
+  static equal(x: JSBI, y: JSBI): boolean;
+  static notEqual(x: JSBI, y: JSBI): boolean;
+  static bitwiseAnd(x: JSBI, y: JSBI): JSBI;
+  static bitwiseXor(x: JSBI, y: JSBI): JSBI;
+  static bitwiseOr(x: JSBI, y: JSBI): JSBI;
+  static asIntN(n: number, x: JSBI): JSBI;
+  static asUintN(n: number, x: JSBI): JSBI;
+  static ADD(x: any, y: any): any;
+  static LT(x: any, y: any): boolean;
+  static LE(x: any, y: any): boolean;
+  static GT(x: any, y: any): boolean;
+  static GE(x: any, y: any): boolean;
+  static EQ(x: any, y: any): boolean;
+  static NE(x: any, y: any): boolean;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/constants.d.ts
+declare type BigintIsh = JSBI | string | number;
+declare enum Rounding {
+  ROUND_DOWN = 0,
+  ROUND_HALF_UP = 1,
+  ROUND_UP = 2
+}
+//#endregion
+//#region node_modules/@ethersproject/bytes/lib/index.d.ts
+declare type Bytes = ArrayLike<number>;
+interface Hexable {
+  toHexString(): string;
+}
+//#endregion
+//#region node_modules/@ethersproject/bignumber/lib/bignumber.d.ts
+declare type BigNumberish = BigNumber | Bytes | bigint | string | number;
+declare class BigNumber implements Hexable {
+  readonly _hex: string;
+  readonly _isBigNumber: boolean;
+  constructor(constructorGuard: any, hex: string);
+  fromTwos(value: number): BigNumber;
+  toTwos(value: number): BigNumber;
+  abs(): BigNumber;
+  add(other: BigNumberish): BigNumber;
+  sub(other: BigNumberish): BigNumber;
+  div(other: BigNumberish): BigNumber;
+  mul(other: BigNumberish): BigNumber;
+  mod(other: BigNumberish): BigNumber;
+  pow(other: BigNumberish): BigNumber;
+  and(other: BigNumberish): BigNumber;
+  or(other: BigNumberish): BigNumber;
+  xor(other: BigNumberish): BigNumber;
+  mask(value: number): BigNumber;
+  shl(value: number): BigNumber;
+  shr(value: number): BigNumber;
+  eq(other: BigNumberish): boolean;
+  lt(other: BigNumberish): boolean;
+  lte(other: BigNumberish): boolean;
+  gt(other: BigNumberish): boolean;
+  gte(other: BigNumberish): boolean;
+  isNegative(): boolean;
+  isZero(): boolean;
+  toNumber(): number;
+  toBigInt(): bigint;
+  toString(): string;
+  toHexString(): string;
+  toJSON(key?: string): any;
+  static from(value: any): BigNumber;
+  static isBigNumber(value: any): value is BigNumber;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/token.d.ts
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+declare class Token extends BaseCurrency {
+  readonly isNative: false;
+  readonly isToken: true;
+  /**
+   * The contract address on the chain on which this token lives
+   */
+  readonly address: string;
+  /**
+   * Relevant for fee-on-transfer (FOT) token taxes,
+   * Not every ERC20 token is FOT token, so this field is optional
+   */
+  readonly buyFeeBps?: BigNumber;
+  readonly sellFeeBps?: BigNumber;
+  /**
+   *
+   * @param chainId {@link BaseCurrency#chainId}
+   * @param address The contract address on the chain on which this token lives
+   * @param decimals {@link BaseCurrency#decimals}
+   * @param symbol {@link BaseCurrency#symbol}
+   * @param name {@link BaseCurrency#name}
+   * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+   * @param buyFeeBps Buy fee tax for FOT tokens, in basis points
+   * @param sellFeeBps Sell fee tax for FOT tokens, in basis points
+   */
+  constructor(chainId: number, address: string, decimals: number, symbol?: string, name?: string, bypassChecksum?: boolean, buyFeeBps?: BigNumber, sellFeeBps?: BigNumber);
+  /**
+   * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+   * @param other other token to compare
+   */
+  equals(other: Currency): boolean;
+  /**
+   * Returns true if the address of this token sorts before the address of the other token
+   * @param other other token to compare
+   * @throws if the tokens have the same address
+   * @throws if the tokens are on different chains
+   */
+  sortsBefore(other: Token): boolean;
+  /**
+   * Return this token, which does not need to be wrapped
+   */
+  get wrapped(): Token;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/baseCurrency.d.ts
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+declare abstract class BaseCurrency {
+  /**
+   * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+   */
+  abstract readonly isNative: boolean;
+  /**
+   * Returns whether the currency is a token that is usable in Uniswap without wrapping
+   */
+  abstract readonly isToken: boolean;
+  /**
+   * The chain ID on which this currency resides
+   */
+  readonly chainId: number;
+  /**
+   * The decimals used in representing currency amounts
+   */
+  readonly decimals: number;
+  /**
+   * The symbol of the currency, i.e. a short textual non-unique identifier
+   */
+  readonly symbol?: string;
+  /**
+   * The name of the currency, i.e. a descriptive textual non-unique identifier
+   */
+  readonly name?: string;
+  /**
+   * Constructs an instance of the base class `BaseCurrency`.
+   * @param chainId the chain ID on which this currency resides
+   * @param decimals decimals of the currency
+   * @param symbol symbol of the currency
+   * @param name of the currency
+   */
+  protected constructor(chainId: number, decimals: number, symbol?: string, name?: string);
+  /**
+   * Returns whether this currency is functionally equivalent to the other currency
+   * @param other the other currency
+   */
+  abstract equals(other: Currency): boolean;
+  /**
+   * Return the wrapped version of this currency that can be used with the Uniswap contracts. Currencies must
+   * implement this to be used in Uniswap
+   */
+  abstract get wrapped(): Token;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/nativeCurrency.d.ts
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+declare abstract class NativeCurrency extends BaseCurrency {
+  readonly isNative: true;
+  readonly isToken: false;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/currency.d.ts
+declare type Currency = NativeCurrency | Token;
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/fractions/fraction.d.ts
+declare class Fraction {
+  readonly numerator: JSBI;
+  readonly denominator: JSBI;
+  constructor(numerator: BigintIsh, denominator?: BigintIsh);
+  private static tryParseFraction;
+  get quotient(): JSBI;
+  get remainder(): Fraction;
+  invert(): Fraction;
+  add(other: Fraction | BigintIsh): Fraction;
+  subtract(other: Fraction | BigintIsh): Fraction;
+  lessThan(other: Fraction | BigintIsh): boolean;
+  equalTo(other: Fraction | BigintIsh): boolean;
+  greaterThan(other: Fraction | BigintIsh): boolean;
+  multiply(other: Fraction | BigintIsh): Fraction;
+  divide(other: Fraction | BigintIsh): Fraction;
+  toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+  toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+  /**
+   * Helper method for converting any super class back to a fraction
+   */
+  get asFraction(): Fraction;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/fractions/currencyAmount.d.ts
+declare class CurrencyAmount<T extends Currency> extends Fraction {
+  readonly currency: T;
+  readonly decimalScale: JSBI;
+  /**
+   * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+   * @param currency the currency in the amount
+   * @param rawAmount the raw token or ether amount
+   */
+  static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+  /**
+   * Construct a currency amount with a denominator that is not equal to 1
+   * @param currency the currency
+   * @param numerator the numerator of the fractional token amount
+   * @param denominator the denominator of the fractional token amount
+   */
+  static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+  protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+  add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+  subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+  multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+  divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+  toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+  toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+  toExact(format?: object): string;
+  get wrapped(): CurrencyAmount<Token>;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/node_modules/@uniswap/sdk-core/dist/entities/fractions/price.d.ts
+declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+  readonly baseCurrency: TBase;
+  readonly quoteCurrency: TQuote;
+  readonly scalar: Fraction;
+  /**
+   * Construct a price, either with the base and quote currency amount, or the
+   * @param args
+   */
+  constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [{
+    baseAmount: CurrencyAmount<TBase>;
+    quoteAmount: CurrencyAmount<TQuote>;
+  }]);
+  /**
+   * Flip the price, switching the base and quote currency
+   */
+  invert(): Price<TQuote, TBase>;
+  /**
+   * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+   * @param other the other price
+   */
+  multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+  /**
+   * Return the amount of quote currency corresponding to a given amount of the base currency
+   * @param currencyAmount the amount of base currency to quote against the price
+   */
+  quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+  /**
+   * Get the value scaled by decimals for formatting
+   * @private
+   */
+  private get adjustedForDecimals();
+  toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+  toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/dist/constants.d.ts
+/**
+ * The default factory enabled fee amounts, denominated in hundredths of bips.
+ */
+declare enum FeeAmount {
+  LOWEST = 100,
+  LOW_200 = 200,
+  LOW_300 = 300,
+  LOW_400 = 400,
+  LOW = 500,
+  MEDIUM = 3000,
+  HIGH = 10000
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/dist/entities/tick.d.ts
+interface TickConstructorArgs {
+  index: number;
+  liquidityGross: BigintIsh;
+  liquidityNet: BigintIsh;
+}
+declare class Tick {
+  readonly index: number;
+  readonly liquidityGross: JSBI;
+  readonly liquidityNet: JSBI;
+  constructor({
+    index,
+    liquidityGross,
+    liquidityNet
+  }: TickConstructorArgs);
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/dist/entities/tickDataProvider.d.ts
+/**
+ * Provides information about ticks
+ */
+interface TickDataProvider {
+  /**
+   * Return information corresponding to a specific tick
+   * @param tick the tick to load
+   */
+  getTick(tick: number): Promise<{
+    liquidityNet: BigintIsh;
+  }>;
+  /**
+   * Return the next tick that is initialized within a single word
+   * @param tick The current tick
+   * @param lte Whether the next tick should be lte the current tick
+   * @param tickSpacing The tick spacing of the pool
+   */
+  nextInitializedTickWithinOneWord(tick: number, lte: boolean, tickSpacing: number): Promise<[number, boolean]>;
+}
+//#endregion
+//#region node_modules/@uniswap/v3-sdk/dist/entities/pool.d.ts
+/**
+ * Represents a V3 pool
+ */
+declare class Pool {
+  readonly token0: Token;
+  readonly token1: Token;
+  readonly fee: FeeAmount;
+  readonly sqrtRatioX96: JSBI;
+  readonly liquidity: JSBI;
+  readonly tickCurrent: number;
+  readonly tickDataProvider: TickDataProvider;
+  private _token0Price?;
+  private _token1Price?;
+  static getAddress(tokenA: Token, tokenB: Token, fee: FeeAmount, initCodeHashManualOverride?: string, factoryAddressOverride?: string): string;
+  /**
+   * Construct a pool
+   * @param tokenA One of the tokens in the pool
+   * @param tokenB The other token in the pool
+   * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+   * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
+   * @param liquidity The current value of in range liquidity
+   * @param tickCurrent The current tick of the pool
+   * @param ticks The current state of the pool ticks or a data provider that can return tick data
+   */
+  constructor(tokenA: Token, tokenB: Token, fee: FeeAmount, sqrtRatioX96: BigintIsh, liquidity: BigintIsh, tickCurrent: number, ticks?: TickDataProvider | (Tick | TickConstructorArgs)[]);
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token The token to check
+   * @returns True if token is either token0 or token
+   */
+  involvesToken(token: Token): boolean;
+  /**
+   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+   */
+  get token0Price(): Price<Token, Token>;
+  /**
+   * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+   */
+  get token1Price(): Price<Token, Token>;
+  /**
+   * Return the price of the given token in terms of the other token in the pool.
+   * @param token The token to return price of
+   * @returns The price of the given token, in terms of the other.
+   */
+  priceOf(token: Token): Price<Token, Token>;
+  /**
+   * Returns the chain ID of the tokens in the pool.
+   */
+  get chainId(): number;
+  /**
+   * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+   * @param inputAmount The input amount for which to quote the output amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+   * @returns The output amount and the pool with updated state
+   */
+  getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+  /**
+   * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+   * @param outputAmount the output amount for which to quote the input amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns The input amount and the pool with updated state
+   */
+  getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+  /**
+   * Executes a swap
+   * @param zeroForOne Whether the amount in is token0 or token1
+   * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns amountCalculated
+   * @returns sqrtRatioX96
+   * @returns liquidity
+   * @returns tickCurrent
+   */
+  private swap;
+  get tickSpacing(): number;
+}
+//#endregion
 //#region src/base/SubgraphClient.d.ts
 declare abstract class SubgraphClient {
   protected readonly client: Client;