@alephium/powfi-sdk 0.0.1-rc.1

package/src/clmm/types.ts

@@ -0,0 +1,155 @@
+import type { TokenInfo } from '@alephium/token-list';
+import { Pool } from 'clmm/artifacts/ts/Pool';
+import { PositionInfo } from 'clmm/artifacts/ts/types';
+
+export interface ClmmConfig {
+  groupIndex: number;
+  factoryId: string;
+  positionManagerId: string;
+  defaultConfigIndex: bigint;
+  accountRoot: string;
+}
+
+export interface ClmmSwapParams {
+  token0: string;
+  token1: string;
+  amount: bigint;
+  slippage: bigint;
+  routePlan: bigint[];
+}
+
+export interface SimulateSwap {
+  configIndex: bigint;
+  token0: string;
+  token1: string;
+  zeroForOne: boolean;
+  amount: bigint;
+}
+
+export interface LiquidityForPrice {
+  liquidity: bigint;
+  sqrtPriceX96: bigint;
+}
+
+export interface LiquidityDistribution {
+  baseSqrtPriceX96: bigint;
+  sqrtPriceX96: bigint;
+  liquidity: bigint;
+  fee: bigint;
+  rows: Array<LiquidityForPrice>;
+}
+
+export interface AddLiquidity {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  owner?: string;
+  tickLower: bigint;
+  tickUpper: bigint;
+  slippage: bigint;
+  amount0: bigint;
+  amount1: bigint;
+  existingPosition?: boolean;
+}
+
+export interface RemoveLiquidity {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  owner: string;
+  tickLower: bigint;
+  tickUpper: bigint;
+  liquidity: bigint;
+  base: 'token0' | 'token1';
+  baseAmount: bigint;
+  otherAmountMax: bigint;
+}
+
+export interface CollectTokens {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  owner: string;
+  recipient: string;
+  tickLower: bigint;
+  tickUpper: bigint;
+  liquidity: bigint; // != 0 if also remove liquidity
+  amount0Max: bigint;
+  amount1Max: bigint;
+}
+
+export interface PositionPath {
+  poolId: string;
+  owner: string;
+  tickLower: bigint;
+  tickUpper: bigint;
+  acc: bigint;
+  iacc0: bigint;
+  iacc1: bigint;
+  t0: bigint;
+  acct0: bigint;
+}
+
+export interface CollectProtocolFees {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  recipient: string;
+}
+
+export interface SetRewardParams {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  rewardToken: string;
+  payer: string;
+  amount: bigint;
+  openTime: bigint;
+  endTime: bigint;
+}
+
+export interface ExtendRewards {
+  token0: string;
+  token1: string;
+  configIndex: bigint;
+  rewardToken: string;
+  payer: string;
+  amount: bigint;
+}
+
+export interface ClmmPoolContractState extends ClmmPoolConfig {
+  poolId: string;
+  token0Info: TokenInfo;
+  token1Info: TokenInfo;
+  liquidity: bigint;
+  sqrtPriceX96: bigint;
+  tick: bigint;
+}
+
+export interface ClmmPoolConfig {
+  configIndex: bigint;
+  tickSpacing: bigint;
+  tradingFee: bigint;
+  protocolFee: bigint;
+}
+
+export const MAX_PIPS = Pool.consts.MAX_PIPS;
+
+
+export type ClmmPositionInfo = PositionInfo
+
+export interface GetPositionAmountsFromPriceProps {
+  sqrtRatioX96: bigint;
+  tokenBaseId: string;
+  tokenQuoteId: string;
+  lowerTick: bigint;
+  upperTick: bigint;
+  amountBase: bigint;
+  amountQuote: bigint;
+}
+
+export interface GetPositionAmountsFromPriceReturn {
+  newAmountBase: bigint;
+  newAmountQuote: bigint;
+  liquidity: bigint;
+}

package/src/common/constants.ts

@@ -0,0 +1 @@
+export const BPS = 10_000n; // basis points denominator

package/src/common/error.ts

@@ -0,0 +1,46 @@
+export class ZetaSDKError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = 'ZetaSDKError';
+  }
+}
+
+export class InsufficientLiquidityError extends ZetaSDKError {
+  constructor(message: string = 'Insufficient liquidity') {
+    super(message);
+    this.name = 'InsufficientLiquidityError';
+  }
+}
+
+export class PriceImpactTooHighError extends ZetaSDKError {
+  constructor(priceImpact: number, maxPriceImpact: number) {
+    super(`Price impact too high: ${priceImpact.toFixed(2)}% > ${maxPriceImpact}%`);
+    this.name = 'PriceImpactTooHighError';
+  }
+}
+
+export class PoolNotFoundError extends ZetaSDKError {
+  constructor(poolId: string) {
+    super(`Pool does not exist for ${poolId}`);
+    this.name = 'PoolNotFoundError';
+  }
+}
+
+export class InsufficientBalanceError extends ZetaSDKError {
+  constructor(token: string, required: string, available: string) {
+    super(`Not enough ${token} balance. Required: ${required}, Available: ${available}`);
+    this.name = 'InsufficientBalanceError';
+  }
+}
+
+export class TokenListFetchError extends ZetaSDKError {
+  public readonly status?: number;
+
+  constructor(url: string, options?: { status?: number; cause?: unknown }) {
+    const statusPart = options?.status !== undefined ? ` (status ${options.status})` : '';
+    const errorOptions = options?.cause !== undefined ? { cause: options.cause } : undefined;
+    super(`Failed to fetch token list from ${url}${statusPart}`, errorOptions);
+    this.name = 'TokenListFetchError';
+    this.status = options?.status;
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './constants';
+export * from './utils';
+export * from './error';
+export * from './logger';
+export * from './math';
+export * from './numeric';

package/src/common/logger.ts

@@ -0,0 +1,82 @@
+export enum LogLevel {
+  Error,
+  Warning,
+  Info,
+  Debug,
+}
+
+export class Logger {
+  private logLevel: LogLevel;
+  private name: string;
+
+  constructor(params: { name: string; logLevel?: LogLevel }) {
+    this.logLevel = params.logLevel !== undefined ? params.logLevel : LogLevel.Error;
+    this.name = params.name;
+  }
+
+  set level(logLevel: LogLevel) {
+    this.logLevel = logLevel;
+  }
+
+  get time(): string {
+    return new Date().toISOString();
+  }
+
+  get moduleName(): string {
+    return this.name;
+  }
+
+  private isLogLevel(level: LogLevel): boolean {
+    return level <= this.logLevel;
+  }
+
+  public error(...props: unknown[]): Logger {
+    if (!this.isLogLevel(LogLevel.Error)) return this;
+    console.error(this.time, this.name, 'error', ...props);
+    return this;
+  }
+
+  public logWithError(...props: unknown[]): Logger {
+    const msg = props
+      .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : arg))
+      .join(', ');
+    throw new Error(msg);
+  }
+
+  public warning(...props: unknown[]): Logger {
+    if (!this.isLogLevel(LogLevel.Warning)) return this;
+    console.warn(this.time, this.name, 'warning', ...props);
+    return this;
+  }
+
+  public info(...props: unknown[]): Logger {
+    if (!this.isLogLevel(LogLevel.Info)) return this;
+    console.info(this.time, this.name, 'info', ...props);
+    return this;
+  }
+
+  public debug(...props: unknown[]): Logger {
+    if (!this.isLogLevel(LogLevel.Debug)) return this;
+    console.debug(this.time, this.name, 'debug', ...props);
+    return this;
+  }
+}
+
+const moduleLoggers: { [key: string]: Logger } = {};
+const moduleLevels: { [key: string]: LogLevel } = {};
+
+export function createLogger(moduleName: string): Logger {
+  let logger = moduleLoggers[moduleName];
+  if (!logger) {
+    const logLevel = moduleLevels[moduleName];
+    logger = new Logger({ name: moduleName, logLevel });
+    moduleLoggers[moduleName] = logger;
+  }
+  return logger;
+}
+
+export function setLoggerLevel(moduleName: string, level: LogLevel): void {
+  moduleLevels[moduleName] = level;
+  const logger = moduleLoggers[moduleName];
+  if (logger) logger.level = level;
+}

package/src/common/math.ts

@@ -0,0 +1,88 @@
+export type Rounding = 'floor' | 'ceil';
+
+export class MathUtil {
+  // Copied from https://github.com/Aisse-258/bigint-isqrt/blob/master/main.js
+  static sqrt = function (value: bigint): bigint {
+    if (value < 2n) {
+      return value;
+    }
+
+    if (value < 16n) {
+      return BigInt(Math.sqrt(Number(value)) | 0);
+    }
+
+    let x0, x1;
+    if (value < 4503599627370496n) {
+      //1n<<52n
+      x1 = BigInt(Math.sqrt(Number(value)) | 0) - 3n;
+    } else {
+      const vlen = value.toString().length;
+      if (!(vlen & 1)) {
+        x1 = 10n ** BigInt(vlen / 2);
+      } else {
+        x1 = 4n * 10n ** BigInt((vlen / 2) | 0);
+      }
+    }
+
+    do {
+      x0 = x1;
+      x1 = (value / x0 + x0) >> 1n;
+    } while (x0 !== x1 && x0 !== x1 - 1n);
+
+    return x0;
+  };
+
+  static alphDiv(a: bigint, b: bigint): bigint {
+    const result = a / b;
+    if (a * b < 0n) return result - BigInt(a % b != 0n);
+    return result;
+  }
+
+  static alphCeil(a: bigint, b: bigint): bigint {
+    const result = a / b;
+    const rem = a % b;
+    return result + BigInt(rem != 0n) * BigInt(rem < 0n ? -1n : 1n);
+  }
+
+  static divFloor(a: bigint, b: bigint): bigint {
+    return this.divWithRounding(a, b, 'floor');
+  }
+
+  static divCeil(a: bigint, b: bigint): bigint {
+    return this.divWithRounding(a, b, 'ceil');
+  }
+
+  static mulDivFloor(a: bigint, b: bigint, d: bigint): bigint {
+    if (d === 0n) {
+      throw new Error(`Division by zero in mulDivFloor: ${a} * ${b} / ${d}`);
+    }
+    const product = a * b;
+    return this.divFloor(product, d);
+  }
+
+  static mulDivCeil(a: bigint, b: bigint, d: bigint): bigint {
+    if (d === 0n) {
+      throw new Error(`Division by zero in mulDivCeil: ${a} * ${b} / ${d}`);
+    }
+    const product = a * b;
+    return this.divCeil(product, d);
+  }
+
+  private static divWithRounding = (a: bigint, b: bigint, mode: Rounding): bigint => {
+    if (b === 0n) {
+      throw new Error(`Division by zero: ${a} / ${b}`);
+    }
+
+    const quotient = a / b;
+    const remainder = a % b;
+    if (remainder === 0n) {
+      return quotient;
+    }
+
+    const signsMatch = a >= 0n === b >= 0n;
+    if (mode === 'floor') {
+      return signsMatch ? quotient : quotient - 1n;
+    }
+    return signsMatch ? quotient + 1n : quotient;
+  };
+}

package/src/common/numeric.ts

@@ -0,0 +1,64 @@
+import Decimal from 'decimal.js';
+
+export type NumericLike = Decimal | bigint | number | string | undefined | null;
+
+export class NumericUtils {
+  static decimalFrom(value: NumericLike): Decimal {
+    if (value === undefined || value === null) {
+      return new Decimal(0);
+    }
+    if (Decimal.isDecimal(value)) {
+      return value;
+    }
+    if (typeof value === 'bigint') {
+      return new Decimal(value.toString());
+    }
+    return new Decimal(value);
+  }
+
+  static decimalToString(value: Decimal): string {
+    if (!value.isFinite()) {
+      return value.toString();
+    }
+    return value.toFixed(value.decimalPlaces());
+  }
+
+  static scaleDecimal(value: NumericLike, decimals: number): Decimal {
+    if (decimals < 0) {
+      throw new Error('Decimals must be non-negative');
+    }
+    if (decimals === 0) {
+      return this.decimalFrom(value);
+    }
+    return this.decimalFrom(value).div(new Decimal(10).pow(decimals));
+  }
+
+  static scaleToString(value: NumericLike, decimals: number): string {
+    return this.decimalToString(this.scaleDecimal(value, decimals));
+  }
+
+  static numericToString(value: NumericLike): string {
+    return this.decimalToString(this.decimalFrom(value));
+  }
+
+  static numericToBigInt(value: NumericLike): bigint {
+    if (value === undefined || value === null) {
+      return 0n;
+    }
+    if (typeof value === 'bigint') {
+      return value;
+    }
+
+    const decimalValue = this.decimalFrom(value);
+
+    if (!decimalValue.isFinite()) {
+      throw new Error('Cannot convert non-finite value to bigint');
+    }
+
+    if (!decimalValue.isInteger()) {
+      throw new Error('Cannot convert non-integer value to bigint');
+    }
+
+    return BigInt(decimalValue.toFixed(0));
+  }
+}

package/src/common/types.ts

@@ -0,0 +1,49 @@
+import type { SignerProvider, NetworkId } from '@alephium/web3';
+
+export interface Network {
+  id: NetworkId;
+  name: string;
+  nodeUrl: string;
+  nodeApiKey?: string;
+  explorerApiUrl: string;
+  explorerUrl: string;
+  tokenListUrl: string;
+}
+
+export const DEVNET = {
+  id: 'devnet' as NetworkId,
+  nodeUrl: 'http://127.0.0.1:22973',
+  explorerApiUrl: 'http://localhost:9090',
+  explorerUrl: 'http://localhost:23000',
+  tokenListUrl: 'http://127.0.0.1:4000/token-list/devnet.json', // Temporary solution for devnet
+  name: 'Devnet',
+};
+
+export const defaultNetworks: Network[] = [
+  {
+    id: 'mainnet',
+    nodeUrl: 'https://node.mainnet.alephium.org',
+    explorerApiUrl: 'https://backend.mainnet.alephium.org',
+    explorerUrl: 'https://explorer.alephium.org',
+    tokenListUrl:
+      'https://raw.githubusercontent.com/alephium/token-list/master/tokens/mainnet.json',
+    name: 'Mainnet',
+  },
+  {
+    id: 'testnet',
+    nodeUrl: 'https://node.testnet.alephium.org',
+    explorerApiUrl: 'https://backend.testnet.alephium.org',
+    explorerUrl: 'https://testnet.alephium.org',
+    tokenListUrl:
+      'https://raw.githubusercontent.com/alephium/token-list/master/tokens/testnet.json',
+    name: 'Testnet',
+  },
+  DEVNET,
+];
+export type NetworkOverrides = Partial<Omit<Network, 'id'>>;
+
+export interface ZetaLoadParams {
+  networkId: NetworkId;
+  signer?: SignerProvider;
+  networkOverrides?: NetworkOverrides;
+}

package/src/common/utils.ts

@@ -0,0 +1,3 @@
+export function sortTokens(tokenAId: string, tokenBId: string): [string, string] {
+  return tokenAId < tokenBId ? [tokenAId, tokenBId] : [tokenBId, tokenAId];
+}

package/src/cpmm/constants.ts

@@ -0,0 +1,2 @@
+export const MAX_PRICE_IMPACT = 5; // 5%
+export const MINIMUM_LIQUIDITY = 1000n;