@alephium/powfi-sdk 0.0.1-rc.1

package/src/cpmm/types.ts

@@ -0,0 +1,113 @@
+import type { TokenInfo } from '@alephium/token-list';
+
+export interface CpmmConfig {
+  groupIndex: number;
+  factoryId: string;
+  routerId: string;
+  feeCollectorFactoryId?: string;
+}
+
+export interface CpmmPoolContractState {
+  poolId: string;
+  reserve0: bigint;
+  reserve1: bigint;
+  token0Info: TokenInfo;
+  token1Info: TokenInfo;
+  totalSupply: bigint;
+  dexAccount: string;
+}
+
+export interface SwapParams {
+  tokenIn: TokenInfo;
+  tokenOut: TokenInfo;
+  amountIn?: bigint;
+  amountOut?: bigint;
+  slippage: bigint; // bps
+  sender: string;
+  ttl?: number; // Time to live in minutes, default 60
+}
+
+export interface SwapDetails {
+  swapType: 'ExactIn' | 'ExactOut';
+  state: CpmmPoolContractState;
+  tokenInInfo: TokenInfo;
+  tokenOutInfo: TokenInfo;
+  tokenInAmount: bigint;
+  maximalTokenInAmount: bigint | undefined;
+  tokenOutAmount: bigint;
+  minimalTokenOutAmount: bigint | undefined;
+  priceImpact: number;
+}
+
+export interface AddLiquidityParams {
+  cpmmPoolState: CpmmPoolContractState;
+  tokenA: TokenInfo;
+  tokenB: TokenInfo;
+  amountA: bigint;
+  amountB: bigint;
+  slippage: bigint; // bps
+  sender: string;
+  ttl?: number;
+}
+
+export interface AddLiquidityDetails {
+  state?: CpmmPoolContractState;
+  tokenAId: string;
+  tokenBId: string;
+  amountA: bigint;
+  amountB: bigint;
+  shareAmount: bigint;
+  sharePercentage: number;
+}
+
+export interface RemoveLiquidityParams {
+  state: CpmmPoolContractState;
+  liquidity: bigint;
+  totalLiquidityAmount?: bigint;
+  slippage: bigint; // bps
+  sender: string;
+  ttl?: number;
+}
+
+export interface RemoveLiquidityDetails {
+  state: CpmmPoolContractState;
+  token0: TokenInfo;
+  amount0: bigint;
+  token1: TokenInfo;
+  amount1: bigint;
+  remainShareAmount: bigint;
+  remainSharePercentage: number;
+}
+
+export interface ClaimableAmounts {
+  token0: TokenInfo;
+  amount0: bigint;
+  token1: TokenInfo;
+  amount1: bigint;
+}
+
+export interface CreatePoolParams {
+  tokenA: TokenInfo;
+  tokenB: TokenInfo;
+  sender: string;
+  tokenAAmount?: bigint;
+  tokenBAmount?: bigint;
+}
+
+export interface ComputeSwapParams {
+  state: CpmmPoolContractState;
+  tokenIn: TokenInfo;
+  tokenOut: TokenInfo;
+  amountIn?: bigint;
+  amountOut?: bigint;
+  slippage: bigint; // bps
+}
+
+export interface ComputeLiquidityParams {
+  state?: CpmmPoolContractState;
+  tokenA: TokenInfo;
+  tokenB: TokenInfo;
+  amountA?: bigint;
+  amountB?: bigint;
+  inputType?: 'TokenA' | 'TokenB';
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+export * from './zeta';
+export * from './common';
+export * from './cpmm';
+export * from './clmm';
+export * from './token';
+export * from './staking';
+
+export type { TokenPairTypes as CpmmTokenPairTypes } from 'cpmm/artifacts/ts/TokenPair';
+export type { TokenPairFactoryTypes as CpmmTokenPairFactoryTypes } from 'cpmm/artifacts/ts/TokenPairFactory';
+export type { PoolTypes as ClmmPoolTypes } from 'clmm/artifacts/ts/Pool';
+export type { PoolFactoryTypes as ClmmPoolFactoryTypes } from 'clmm/artifacts/ts/PoolFactory';
+export type { PositionManagerTypes as ClmmPositionManagerTypes } from 'clmm/artifacts/ts/PositionManager';
+export type { XAlphTokenTypes } from 'staking/artifacts/ts/XAlphToken';
+export type { XAlphStakeVaultTypes } from 'staking/artifacts/ts/XAlphStakeVault';
+export type { RewardSharingVaultTypes } from 'staking/artifacts/ts/RewardSharingVault';
+export type { GovernanceDemoTypes } from 'staking/artifacts/ts/GovernanceDemo';
+
+export * as CpmmContracts from 'cpmm/artifacts/ts';
+export * as ClmmContracts from 'clmm/artifacts/ts';
+export * as CpmmScripts from 'cpmm/artifacts/ts/scripts';
+export * as ClmmScripts from 'clmm/artifacts/ts/scripts';
+export * as StakingContracts from 'staking/artifacts/ts';
+export { loadDeployments as loadCpmmDeployments } from 'cpmm/artifacts/ts/deployments';
+export { loadDeployments as loadClmmDeployments } from 'clmm/artifacts/ts/deployments';
+export { loadDeployments as loadStakingDeployments } from 'staking/artifacts/ts/deployments';

package/src/moduleBase.ts

@@ -0,0 +1,64 @@
+import type { Logger } from './common/logger';
+import { createLogger } from './common/logger';
+import type { Zeta } from './zeta';
+
+export interface ModuleBaseProps {
+  scope: Zeta;
+  moduleName: string;
+}
+
+const joinMsg = (...args: unknown[]): string =>
+  args
+    .map((arg) => {
+      if (arg instanceof Error) {
+        const base = arg.message ?? arg.name;
+        return arg.stack ? `${base}\n${arg.stack}` : base;
+      }
+
+      if (typeof arg === 'object' && arg !== null) {
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }
+
+      return String(arg);
+    })
+    .join(', ');
+
+export default class ModuleBase {
+  public scope: Zeta;
+  private disabled = false;
+  protected logger: Logger;
+
+  constructor({ scope, moduleName }: ModuleBaseProps) {
+    this.scope = scope;
+    this.logger = createLogger(moduleName);
+  }
+
+  public logDebug(...args: unknown[]): void {
+    this.logger.debug(joinMsg(...args));
+  }
+
+  public logInfo(...args: unknown[]): void {
+    this.logger.info(joinMsg(...args));
+  }
+
+  public logWarning(...args: unknown[]): void {
+    this.logger.warning(joinMsg(...args));
+  }
+
+  public logError(...args: unknown[]): void {
+    this.logger.error(joinMsg(...args));
+  }
+
+  public logAndThrowError(...args: unknown[]): never {
+    const message = joinMsg(...args);
+    throw new Error(message);
+  }
+
+  public checkDisabled(): void {
+    if (this.disabled || !this.scope) this.logAndThrowError('module not working');
+  }
+}

package/src/staking/index.ts

@@ -0,0 +1,4 @@
+export * from './staking';
+export * from './types';
+export * from './utils';
+export * from './settings';

package/src/staking/settings.ts

@@ -0,0 +1,38 @@
+import type { NetworkId } from '@alephium/web3';
+
+export type StakingSettings = {
+  unstakeDuration: bigint;
+  maxActiveUnstakeRequestsPerUser: bigint;
+  maxConnectedDapps: bigint;
+};
+
+const defaultSettings: StakingSettings = {
+  unstakeDuration: 30n * 24n * 60n * 60n * 1000n, // 30 days in milliseconds
+  maxActiveUnstakeRequestsPerUser: 16n,
+  maxConnectedDapps: 10n,
+};
+
+const networkOverrides: Partial<Record<NetworkId, Partial<StakingSettings>>> = {
+  devnet: {
+    unstakeDuration: 60n * 1000n, // 1 minute
+    maxConnectedDapps: 2n,
+  },
+};
+
+function buildSettings(networkId: NetworkId): StakingSettings {
+  const overrides = networkOverrides[networkId];
+  return {
+    ...defaultSettings,
+    ...(overrides ?? {}),
+  };
+}
+
+export const stakingSettingsByNetwork: Record<NetworkId, StakingSettings> = {
+  mainnet: buildSettings('mainnet'),
+  testnet: buildSettings('testnet'),
+  devnet: buildSettings('devnet'),
+};
+
+export function getStakingSettings(networkId: NetworkId): StakingSettings {
+  return stakingSettingsByNetwork[networkId];
+}

package/src/staking/staking.ts

@@ -0,0 +1,277 @@
+import type { ExecuteScriptResult, HexString } from '@alephium/web3';
+import {
+  MINIMAL_CONTRACT_DEPOSIT,
+  addressFromContractId,
+  addressToBytes,
+  binToHex,
+  codec,
+  groupOfAddress,
+  isGrouplessAddressWithoutGroupIndex,
+  subContractId,
+} from '@alephium/web3';
+import type {
+  AlphUnstakeVaultInstance,
+  AlphUnstakeVaultTypes,
+  GovernanceDemoInstance,
+  RewardSharingVaultInstance,
+  XAlphStakeVaultInstance,
+  XAlphStakeVaultTypes,
+  XAlphTokenInstance,
+  XAlphTokenTypes,
+} from 'staking/artifacts/ts';
+import {
+  AlphStakeAndLock,
+  AlphUnstakeVault,
+  GovernanceDemo,
+  RewardSharingVault,
+  XAlphStakeVault,
+  XAlphToken,
+  XAlphUnlockAndStartUnstake,
+} from 'staking/artifacts/ts';
+import { loadDeployments } from 'staking/artifacts/ts/deployments';
+import ModuleBase from '../moduleBase';
+import type { Zeta } from '../zeta';
+import type { StakeVaultUserInfo, StakingConfig } from './types';
+import { decodeContractIdList, decodeU256List } from './utils';
+import type { StakingSettings } from './settings';
+import { getStakingSettings } from './settings';
+
+export class StakingModule extends ModuleBase {
+  private config: StakingConfig;
+  private xAlphTokenContract: XAlphTokenInstance;
+  private stakeVaultContract: XAlphStakeVaultInstance;
+
+  constructor(scope: Zeta) {
+    super({ scope, moduleName: 'StakingModule' });
+
+    this.config = this.loadStakingConfig();
+    this.xAlphTokenContract = XAlphToken.at(addressFromContractId(this.config.xAlphTokenId));
+    this.stakeVaultContract = XAlphStakeVault.at(
+      addressFromContractId(this.config.xAlphStakeVaultId),
+    );
+  }
+
+  setConfig(config: StakingConfig): void {
+    this.config = config;
+    this.xAlphTokenContract = XAlphToken.at(addressFromContractId(config.xAlphTokenId));
+    this.stakeVaultContract = XAlphStakeVault.at(addressFromContractId(config.xAlphStakeVaultId));
+  }
+
+  getConfig(): StakingConfig {
+    return this.config;
+  }
+
+  getXAlphToken(): XAlphTokenInstance {
+    return this.xAlphTokenContract;
+  }
+
+  getStakeVault(): XAlphStakeVaultInstance {
+    return this.stakeVaultContract;
+  }
+
+  getRewardSharingVault(contractId: string): RewardSharingVaultInstance {
+    return RewardSharingVault.at(addressFromContractId(contractId));
+  }
+
+  getGovernanceContract(contractId: string): GovernanceDemoInstance {
+    return GovernanceDemo.at(addressFromContractId(contractId));
+  }
+
+  async getXAlphTokenState(): Promise<XAlphTokenTypes.State> {
+    return this.xAlphTokenContract.fetchState();
+  }
+
+  async getStakeVaultState(): Promise<XAlphStakeVaultTypes.State> {
+    return this.stakeVaultContract.fetchState();
+  }
+
+  async stakeAlph(amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'stake'>> {
+    this.ensurePositiveAmount(amount, 'Stake amount');
+    return this.xAlphTokenContract.transact.stake({
+      signer: this.scope.signer,
+      args: { amount },
+      attoAlphAmount: amount + MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async startUnstake(
+    amount: bigint,
+  ): Promise<XAlphTokenTypes.SignExecuteMethodResult<'startUnstake'>> {
+    this.ensurePositiveAmount(amount, 'Unstake amount');
+    return this.xAlphTokenContract.transact.startUnstake({
+      signer: this.scope.signer,
+      args: { amount },
+      tokens: [{ id: this.config.xAlphTokenId, amount }],
+    });
+  }
+
+  async claimUnstaked(
+    vaultIndex: bigint,
+    amount: bigint,
+  ): Promise<XAlphTokenTypes.SignExecuteMethodResult<'claimUnstaked'>> {
+    this.ensurePositiveAmount(amount, 'Claim amount');
+    return this.xAlphTokenContract.transact.claimUnstaked({
+      signer: this.scope.signer,
+      args: {
+        vaultIndex,
+        amount,
+      },
+    });
+  }
+
+  async stakeXAlph(amount: bigint): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'stake'>> {
+    this.ensurePositiveAmount(amount, 'Stake amount');
+    return this.stakeVaultContract.transact.stake({
+      signer: this.scope.signer,
+      args: { amount },
+      tokens: [{ id: this.config.xAlphTokenId, amount }],
+      attoAlphAmount: MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async unstakeXAlph(
+    amount: bigint,
+  ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'unstake'>> {
+    this.ensurePositiveAmount(amount, 'Unstake amount');
+    return this.stakeVaultContract.transact.unstake({
+      signer: this.scope.signer,
+      args: { amount },
+      attoAlphAmount: MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async stakeAndLockAlph(amount: bigint): Promise<ExecuteScriptResult> {
+    return AlphStakeAndLock.execute({
+      signer: this.scope.signer,
+      initialFields: {
+        xAlphToken: this.xAlphTokenContract.contractId,
+        xAlphStakeVault: this.stakeVaultContract.contractId,
+        amount,
+      },
+      attoAlphAmount: amount + MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async unlockAndStartUnstake(amount: bigint): Promise<ExecuteScriptResult> {
+    return XAlphUnlockAndStartUnstake.execute({
+      signer: this.scope.signer,
+      initialFields: {
+        xAlphToken: this.xAlphTokenContract.contractId,
+        xAlphStakeVault: this.stakeVaultContract.contractId,
+        amount,
+      },
+      attoAlphAmount: MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  getAlphUnstakeVault(userAddress: string, vaultIndex: bigint): AlphUnstakeVaultInstance {
+    const userHex = binToHex(addressToBytes(userAddress));
+    const indexHex = binToHex(codec.u256Codec.encode(vaultIndex));
+    const contractId = subContractId(
+      this.config.xAlphTokenId,
+      `${userHex}${indexHex}`,
+      groupOfAddress(this.config.xAlphTokenAddress),
+    );
+    return AlphUnstakeVault.at(addressFromContractId(contractId));
+  }
+
+  async getAlphUnstakeVaultState(
+    userAddress: string,
+    vaultIndex: bigint,
+  ): Promise<AlphUnstakeVaultTypes.State> {
+    return this.getAlphUnstakeVault(userAddress, vaultIndex).fetchState();
+  }
+
+  async connectToDapp(
+    contractId: string,
+    merkleProof: HexString,
+  ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'connectToDapp'>> {
+    return this.stakeVaultContract.transact.connectToDapp({
+      signer: this.scope.signer,
+      args: { contractId, merkleProof },
+      attoAlphAmount: MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async disconnectFromDapp(
+    contractId: string,
+  ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'disconnectFromDapp'>> {
+    return this.stakeVaultContract.transact.disconnectFromDapp({
+      signer: this.scope.signer,
+      args: { contractId },
+      attoAlphAmount: MINIMAL_CONTRACT_DEPOSIT,
+    });
+  }
+
+  async getUserStakeVaultInfo(address: string): Promise<StakeVaultUserInfo> {
+    let stakerAddress = address;
+    if (isGrouplessAddressWithoutGroupIndex(address)) {
+      stakerAddress = `${address}:${this.stakeVaultContract.groupIndex}`;
+    }
+    const result = await this.stakeVaultContract.view.getUserStakingInfo({
+      args: { user: stakerAddress },
+    });
+    return {
+      amount: result.returns.amount,
+      connectedDapps: decodeContractIdList(result.returns.connectedDapps),
+    };
+  }
+
+  async isUserStaking(address: string): Promise<boolean> {
+    const result = await this.stakeVaultContract.view.isStaking({ args: { user: address } });
+    return result.returns;
+  }
+
+  async getUserWeight(address: string): Promise<bigint> {
+    const result = await this.stakeVaultContract.view.getWeight({ args: { user: address } });
+    return result.returns;
+  }
+
+  async getActiveUnstakeVaultIndexes(address: string): Promise<bigint[]> {
+    const result = await this.xAlphTokenContract.view.getActiveUnstakeVaultIndexes({
+      args: { caller: address },
+    });
+    return decodeU256List(result.returns);
+  }
+
+  async getClaimableAmount(address: string, vaultIndex: bigint): Promise<bigint> {
+    const result = await this.xAlphTokenContract.view.getClaimableAmount({
+      args: { user: address, vaultIndex },
+    });
+    return result.returns;
+  }
+
+  getSettings(): StakingSettings {
+    return getStakingSettings(this.scope.network.id);
+  }
+
+  private loadStakingConfig(): StakingConfig {
+    const networkId = this.scope.network.id;
+    try {
+      const deployments = loadDeployments(networkId);
+      const alphUnstakeVault = deployments.contracts.AlphUnstakeVault.contractInstance;
+      const xAlphToken = deployments.contracts.XAlphToken.contractInstance;
+      const stakeVault = deployments.contracts.XAlphStakeVault.contractInstance;
+      const rewardVault = deployments.contracts.RewardSharingVault.contractInstance;
+      const governance = deployments.contracts.GovernanceDemo.contractInstance;
+      return {
+        groupIndex: stakeVault.groupIndex,
+        alphUnstakeVaultTemplateId: alphUnstakeVault.contractId,
+        xAlphTokenId: xAlphToken.contractId,
+        xAlphTokenAddress: xAlphToken.address,
+        xAlphStakeVaultId: stakeVault.contractId,
+        xAlphStakeVaultAddress: stakeVault.address,
+        rewardSharingTemplateId: rewardVault.contractId,
+        governanceDemoTemplateId: governance.contractId,
+      };
+    } catch (error) {
+      this.logAndThrowError(`Failed to load staking deployments on ${networkId}`, error);
+    }
+  }
+
+  private ensurePositiveAmount(amount: bigint, label: string): void {
+    if (amount <= 0n) {
+      throw new Error(`${label} must be greater than zero`);
+    }
+  }
+}

package/src/staking/types.ts

@@ -0,0 +1,15 @@
+export interface StakingConfig {
+  groupIndex: number;
+  alphUnstakeVaultTemplateId: string;
+  xAlphTokenId: string;
+  xAlphTokenAddress: string;
+  xAlphStakeVaultId: string;
+  xAlphStakeVaultAddress: string;
+  rewardSharingTemplateId?: string;
+  governanceDemoTemplateId?: string;
+}
+
+export interface StakeVaultUserInfo {
+  amount: bigint;
+  connectedDapps: string[];
+}

package/src/staking/utils.ts

@@ -0,0 +1,25 @@
+const U256_HEX_CHARS = 64;
+const CONTRACT_ID_HEX_CHARS = 64;
+
+const chunkHexString = (hex: string, chunkLength: number): string[] => {
+  if (hex.length === 0) {
+    return [];
+  }
+  if (hex.length % chunkLength !== 0) {
+    throw new Error(`Packed data must be a multiple of ${chunkLength / 2} bytes`);
+  }
+  const chunks: string[] = [];
+  for (let offset = 0; offset < hex.length; offset += chunkLength) {
+    const chunk = hex.slice(offset, offset + chunkLength);
+    chunks.push(chunk);
+  }
+  return chunks;
+};
+
+export const decodeU256List = (str: string): bigint[] => {
+  return chunkHexString(str, U256_HEX_CHARS).map((chunk) => BigInt(`0x${chunk}`));
+};
+
+export const decodeContractIdList = (str: string): string[] => {
+  return chunkHexString(str, CONTRACT_ID_HEX_CHARS);
+};

package/src/token/index.ts

@@ -0,0 +1 @@
+export * from './token';