@alephium/powfi-sdk 0.0.1-rc.2 → 0.0.1-rc.21

package/lib/index.d.ts

@@ -3,6 +3,9 @@ import { ExecuteScriptResult, NetworkId, SignerProvider, Val, Address, HexString
 import { TokenInfo } from '@alephium/token-list';
 import Decimal from 'decimal.js';
 
+type CpmmTokenId = string;
+type CpmmSlippageBps = bigint;
+type CpmmInputType = 'TokenA' | 'TokenB';
 interface CpmmConfig {
     groupIndex: number;
     factoryId: string;
@@ -18,16 +21,24 @@ interface CpmmPoolContractState {
     totalSupply: bigint;
     dexAccount: string;
 }
-interface SwapParams$1 {
-    tokenIn: TokenInfo;
-    tokenOut: TokenInfo;
+interface CpmmSwapRequest {
+    tokenInId: CpmmTokenId;
+    tokenOutId: CpmmTokenId;
     amountIn?: bigint;
     amountOut?: bigint;
-    slippage: bigint;
+    slippageBps: CpmmSlippageBps;
     sender: string;
-    ttl?: number;
+    ttlMinutes?: number;
+}
+interface CpmmSwapQuoteParams {
+    state: CpmmPoolContractState;
+    tokenInId: CpmmTokenId;
+    tokenOutId: CpmmTokenId;
+    amountIn?: bigint;
+    amountOut?: bigint;
+    slippageBps: CpmmSlippageBps;
 }
-interface SwapDetails {
+interface CpmmSwapQuote {
     swapType: 'ExactIn' | 'ExactOut';
     state: CpmmPoolContractState;
     tokenInInfo: TokenInfo;
@@ -38,17 +49,25 @@ interface SwapDetails {
     minimalTokenOutAmount: bigint | undefined;
     priceImpact: number;
 }
-interface AddLiquidityParams {
-    cpmmPoolState: CpmmPoolContractState;
-    tokenA: TokenInfo;
-    tokenB: TokenInfo;
+interface CpmmAddLiquidityRequest {
+    poolState: CpmmPoolContractState;
+    tokenAId: CpmmTokenId;
+    tokenBId: CpmmTokenId;
     amountA: bigint;
     amountB: bigint;
-    slippage: bigint;
+    slippageBps: CpmmSlippageBps;
     sender: string;
-    ttl?: number;
+    ttlMinutes?: number;
+}
+interface CpmmAddLiquidityQuoteParams {
+    poolState?: CpmmPoolContractState;
+    tokenAId: CpmmTokenId;
+    tokenBId: CpmmTokenId;
+    amountA?: bigint;
+    amountB?: bigint;
+    inputType?: CpmmInputType;
 }
-interface AddLiquidityDetails {
+interface CpmmAddLiquidityQuote {
     state?: CpmmPoolContractState;
     tokenAId: string;
     tokenBId: string;
@@ -57,15 +76,15 @@ interface AddLiquidityDetails {
     shareAmount: bigint;
     sharePercentage: number;
 }
-interface RemoveLiquidityParams {
-    state: CpmmPoolContractState;
+interface CpmmRemoveLiquidityRequest {
+    poolState: CpmmPoolContractState;
     liquidity: bigint;
     totalLiquidityAmount?: bigint;
-    slippage: bigint;
+    slippageBps: CpmmSlippageBps;
     sender: string;
-    ttl?: number;
+    ttlMinutes?: number;
 }
-interface RemoveLiquidityDetails {
+interface CpmmRemoveLiquidityQuote {
     state: CpmmPoolContractState;
     token0: TokenInfo;
     amount0: bigint;
@@ -74,34 +93,20 @@ interface RemoveLiquidityDetails {
     remainShareAmount: bigint;
     remainSharePercentage: number;
 }
-interface ClaimableAmounts {
+interface CpmmClaimableAmounts {
     token0: TokenInfo;
     amount0: bigint;
     token1: TokenInfo;
     amount1: bigint;
 }
-interface CreatePoolParams {
-    tokenA: TokenInfo;
-    tokenB: TokenInfo;
+interface CpmmCreatePoolRequest {
+    tokenAId: CpmmTokenId;
+    tokenBId: CpmmTokenId;
     sender: string;
-    tokenAAmount?: bigint;
-    tokenBAmount?: bigint;
-}
-interface ComputeSwapParams {
-    state: CpmmPoolContractState;
-    tokenIn: TokenInfo;
-    tokenOut: TokenInfo;
-    amountIn?: bigint;
-    amountOut?: bigint;
-    slippage: bigint;
-}
-interface ComputeLiquidityParams {
-    state?: CpmmPoolContractState;
-    tokenA: TokenInfo;
-    tokenB: TokenInfo;
-    amountA?: bigint;
-    amountB?: bigint;
-    inputType?: 'TokenA' | 'TokenB';
+    initialLiquidity?: {
+        tokenAAmount: bigint;
+        tokenBAmount: bigint;
+    };
 }
 
 declare enum LogLevel {
@@ -131,11 +136,11 @@ declare function createLogger(moduleName: string): Logger;
 declare function setLoggerLevel(moduleName: string, level: LogLevel): void;
 
 interface ModuleBaseProps {
-    scope: Zeta;
+    scope: Powfi;
     moduleName: string;
 }
 declare class ModuleBase {
-    scope: Zeta;
+    scope: Powfi;
     private disabled;
     protected logger: Logger;
     constructor({ scope, moduleName }: ModuleBaseProps);
@@ -149,46 +154,32 @@ declare class ModuleBase {
 
 declare class CpmmModule extends ModuleBase {
     private config;
-    constructor(scope: Zeta);
+    constructor(scope: Powfi);
     getPoolId(tokenA: string, tokenB: string): string;
     getPoolAddress(tokenA: string, tokenB: string): string;
     getPoolState(tokenA: string, tokenB: string): Promise<CpmmPoolContractState>;
     poolExists(tokenA: string, tokenB: string): Promise<boolean>;
-    swap(params: SwapParams$1, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
-    addLiquidity(params: AddLiquidityParams, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
-    removeLiquidity(params: RemoveLiquidityParams): Promise<ExecuteScriptResult>;
-    computeClaimableAmounts(tokenAId: string, tokenBId: string, liquidityBalance: bigint): Promise<ClaimableAmounts>;
-    createPool(params: CreatePoolParams): Promise<ExecuteScriptResult & {
+    swap(params: CpmmSwapRequest, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
+    addLiquidity(params: CpmmAddLiquidityRequest, balances?: Map<string, bigint>): Promise<ExecuteScriptResult>;
+    removeLiquidity(params: CpmmRemoveLiquidityRequest): Promise<ExecuteScriptResult>;
+    computeClaimableAmounts(tokenAId: string, tokenBId: string, liquidityBalance: bigint): Promise<CpmmClaimableAmounts>;
+    createPool(params: CpmmCreatePoolRequest): Promise<ExecuteScriptResult & {
         poolId: string;
     }>;
     getCpmmConfig(): CpmmConfig;
-    static computeSwapAmount(params: ComputeSwapParams): SwapDetails;
-    static computeLiquidityAmounts(params: ComputeLiquidityParams): AddLiquidityDetails;
-    static computeRemoveLiquidityAmounts(state: CpmmPoolContractState, totalLiquidity: bigint, liquidityToRemove: bigint): RemoveLiquidityDetails;
-    static computeClaimableAmounts(state: CpmmPoolContractState, liquidityBalance: bigint): RemoveLiquidityDetails;
+    static computeSwapAmount(params: CpmmSwapQuoteParams): CpmmSwapQuote;
+    static computeLiquidityAmounts(params: CpmmAddLiquidityQuoteParams): CpmmAddLiquidityQuote;
+    static computeRemoveLiquidityAmounts(state: CpmmPoolContractState, totalLiquidity: bigint, liquidityToRemove: bigint): CpmmRemoveLiquidityQuote;
+    static computeClaimableAmounts(state: CpmmPoolContractState, liquidityBalance: bigint): CpmmRemoveLiquidityQuote;
     static minimalAmount(amount: bigint, slippage: bigint): bigint;
     static maximalAmount(amount: bigint, slippage: bigint): bigint;
     private static assertSlippageInRange;
     static calcPriceImpact(reserve0: bigint, reserve1: bigint, tokenInId: string, token0Id: string, amountIn: bigint, amountOut: bigint): number;
-    static getLiquidityDetails(state: CpmmPoolContractState, inputTokenId: string, inputAmount: bigint, inputType: 'TokenA' | 'TokenB'): {
-        state: CpmmPoolContractState;
-        tokenAId: string;
-        tokenBId: string;
-        amountA: bigint;
-        amountB: bigint;
-        shareAmount: bigint;
-        sharePercentage: number;
-    };
+    static getLiquidityDetails(state: CpmmPoolContractState, inputTokenId: string, inputAmount: bigint, inputType: 'TokenA' | 'TokenB'): CpmmAddLiquidityQuote;
     static getAmountIn(state: CpmmPoolContractState, tokenOutId: string, amountOut: bigint): bigint;
     static getAmountOut(state: CpmmPoolContractState, tokenInId: string, amountIn: bigint): bigint;
-    static getInitLiquidityDetails(tokenAId: string, tokenBId: string, amountA: bigint, amountB: bigint): {
-        tokenAId: string;
-        tokenBId: string;
-        amountA: bigint;
-        amountB: bigint;
-        shareAmount: bigint;
-        sharePercentage: number;
-    };
+    static getInitLiquidityDetails(tokenAId: string, tokenBId: string, amountA: bigint, amountB: bigint): CpmmAddLiquidityQuote;
+    private static getTokenInfoFromPoolState;
     private static _getAmountOut;
     private getExtraAlphAmount;
 }
@@ -212,7 +203,7 @@ declare const DEVNET: {
 };
 declare const defaultNetworks: Network[];
 type NetworkOverrides = Partial<Omit<Network, 'id'>>;
-interface ZetaLoadParams {
+interface PowfiLoadParams {
     networkId: NetworkId;
     signer?: SignerProvider;
     networkOverrides?: NetworkOverrides;
@@ -302,14 +293,15 @@ interface ClmmConfig {
     defaultConfigIndex: bigint;
     accountRoot: string;
 }
-interface ClmmSwapParams {
+interface ClmmSwapRequest {
     token0: string;
     token1: string;
     amount: bigint;
+    amountIn: bigint;
     slippage: bigint;
     routePlan: bigint[];
 }
-interface SimulateSwap {
+interface ClmmSimulateSwapParams {
     configIndex: bigint;
     token0: string;
     token1: string;
@@ -320,14 +312,14 @@ interface LiquidityForPrice {
     liquidity: bigint;
     sqrtPriceX96: bigint;
 }
-interface LiquidityDistribution {
+interface ClmmSimulateSwapQuote {
     baseSqrtPriceX96: bigint;
     sqrtPriceX96: bigint;
     liquidity: bigint;
     fee: bigint;
     rows: Array<LiquidityForPrice>;
 }
-interface AddLiquidity$1 {
+interface ClmmAddLiquidityRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
@@ -339,7 +331,7 @@ interface AddLiquidity$1 {
     amount1: bigint;
     existingPosition?: boolean;
 }
-interface RemoveLiquidity$1 {
+interface ClmmRemoveLiquidityRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
@@ -351,7 +343,7 @@ interface RemoveLiquidity$1 {
     baseAmount: bigint;
     otherAmountMax: bigint;
 }
-interface CollectTokens {
+interface ClmmCollectTokensRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
@@ -363,7 +355,7 @@ interface CollectTokens {
     amount0Max: bigint;
     amount1Max: bigint;
 }
-interface PositionPath {
+interface ClmmPositionInfoRequest {
     poolId: string;
     owner: string;
     tickLower: bigint;
@@ -374,13 +366,13 @@ interface PositionPath {
     t0: bigint;
     acct0: bigint;
 }
-interface CollectProtocolFees {
+interface ClmmCollectProtocolFeesRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
     recipient: string;
 }
-interface SetRewardParams {
+interface ClmmSetRewardParamsRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
@@ -390,7 +382,7 @@ interface SetRewardParams {
     openTime: bigint;
     endTime: bigint;
 }
-interface ExtendRewards {
+interface ClmmExtendRewardsRequest {
     token0: string;
     token1: string;
     configIndex: bigint;
@@ -1731,8 +1723,11 @@ declare namespace PoolTypes {
         };
         withdraw: {
             params: CallContractParams<{
+                position: HexString;
+                operator: Address;
                 recipient: Address;
                 amounts: [bigint, bigint, bigint];
+                toDestroy: boolean;
             }>;
             result: CallContractResult<null>;
         };
@@ -2157,8 +2152,11 @@ declare namespace PoolTypes {
         };
         withdraw: {
             params: SignExecuteContractMethodParams<{
+                position: HexString;
+                operator: Address;
                 recipient: Address;
                 amounts: [bigint, bigint, bigint];
+                toDestroy: boolean;
             }>;
             result: SignExecuteScriptTxResult;
         };
@@ -2513,8 +2511,11 @@ declare class Factory$r extends ContractFactory<PoolInstance, PoolTypes.Fields>
             maxAmounts: [bigint, bigint, bigint];
         }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
         withdraw: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
+            position: HexString;
+            operator: Address;
             recipient: Address;
             amounts: [bigint, bigint, bigint];
+            toDestroy: boolean;
         }>) => Promise<TestContractResultWithoutMaps<null>>;
         simulateSwap: (params: TestContractParamsWithoutMaps<PoolTypes.Fields, {
             zeroForOne: boolean;
@@ -3224,7 +3225,13 @@ declare namespace PositionTypes {
             params: CallContractParams<{
                 maxAmounts: [bigint, bigint, bigint];
             }>;
-            result: CallContractResult<[bigint, bigint, bigint]>;
+            result: CallContractResult<[[bigint, bigint, bigint], boolean]>;
+        };
+        destroy: {
+            params: CallContractParams<{
+                recipient: Address;
+            }>;
+            result: CallContractResult<null>;
         };
         getState: {
             params: Omit<CallContractParams<{}>, "args">;
@@ -3287,6 +3294,12 @@ declare namespace PositionTypes {
             }>;
             result: SignExecuteScriptTxResult;
         };
+        destroy: {
+            params: SignExecuteContractMethodParams<{
+                recipient: Address;
+            }>;
+            result: SignExecuteScriptTxResult;
+        };
         getState: {
             params: Omit<SignExecuteContractMethodParams<{}>, "args">;
             result: SignExecuteScriptTxResult;
@@ -3332,7 +3345,10 @@ declare class Factory$n extends ContractFactory<PositionInstance, PositionTypes.
         }>) => Promise<TestContractResultWithoutMaps<null>>;
         collect: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
             maxAmounts: [bigint, bigint, bigint];
-        }>) => Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>>;
+        }>) => Promise<TestContractResultWithoutMaps<[[bigint, bigint, bigint], boolean]>>;
+        destroy: (params: TestContractParamsWithoutMaps<PositionTypes.Fields, {
+            recipient: Address;
+        }>) => Promise<TestContractResultWithoutMaps<null>>;
         getState: (params: Omit<TestContractParamsWithoutMaps<PositionTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[bigint, [bigint, bigint, bigint]]>>;
     };
     stateForTest(initFields: PositionTypes.Fields, asset?: Asset, address?: string): ContractState<PositionTypes.Fields> | _alephium_web3.ContractStateWithMaps<PositionTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
@@ -3349,6 +3365,7 @@ declare class PositionInstance extends ContractInstance {
         update: (params: PositionTypes.CallMethodParams<"update">) => Promise<PositionTypes.CallMethodResult<"update">>;
         deposit: (params: PositionTypes.CallMethodParams<"deposit">) => Promise<PositionTypes.CallMethodResult<"deposit">>;
         collect: (params: PositionTypes.CallMethodParams<"collect">) => Promise<PositionTypes.CallMethodResult<"collect">>;
+        destroy: (params: PositionTypes.CallMethodParams<"destroy">) => Promise<PositionTypes.CallMethodResult<"destroy">>;
         getState: (params?: PositionTypes.CallMethodParams<"getState">) => Promise<PositionTypes.CallMethodResult<"getState">>;
     };
     transact: {
@@ -3359,6 +3376,7 @@ declare class PositionInstance extends ContractInstance {
         update: (params: PositionTypes.SignExecuteMethodParams<"update">) => Promise<PositionTypes.SignExecuteMethodResult<"update">>;
         deposit: (params: PositionTypes.SignExecuteMethodParams<"deposit">) => Promise<PositionTypes.SignExecuteMethodResult<"deposit">>;
         collect: (params: PositionTypes.SignExecuteMethodParams<"collect">) => Promise<PositionTypes.SignExecuteMethodResult<"collect">>;
+        destroy: (params: PositionTypes.SignExecuteMethodParams<"destroy">) => Promise<PositionTypes.SignExecuteMethodResult<"destroy">>;
         getState: (params: PositionTypes.SignExecuteMethodParams<"getState">) => Promise<PositionTypes.SignExecuteMethodResult<"getState">>;
     };
     multicall<Calls extends PositionTypes.MultiCallParams>(calls: Calls): Promise<PositionTypes.MultiCallResults<Calls>>;
@@ -4399,7 +4417,7 @@ declare namespace index$2 {
 declare class ClmmModule extends ModuleBase {
     private config;
     private configsByIndex;
-    constructor(scope: Zeta);
+    constructor(scope: Powfi);
     setConfig(config: ClmmConfig): void;
     getClmmConfig(): ClmmConfig;
     getPoolConfigId(configIndex: bigint): string;
@@ -4420,25 +4438,31 @@ declare class ClmmModule extends ModuleBase {
         poolAddress: string;
         result: SignExecuteScriptTxResult;
     }>;
-    addLiquidity(p: AddLiquidity$1): Promise<{
+    addLiquidity(p: ClmmAddLiquidityRequest): Promise<{
         positionId: string;
         result: SignExecuteScriptTxResult;
     }>;
-    removeLiquidity(p: RemoveLiquidity$1): Promise<{
+    getAddLiquidityParams(p: ClmmAddLiquidityRequest): Promise<[string, PositionManagerInstance, PositionManagerTypes.SignExecuteMethodParams<'addLiquidity'>]>;
+    addLiquidityFromParams(positionId: string, positionManager: PositionManagerInstance, params: PositionManagerTypes.SignExecuteMethodParams<'addLiquidity'>): Promise<{
         positionId: string;
         result: SignExecuteScriptTxResult;
     }>;
-    positionInfo({ poolId, ...args }: PositionPath): Promise<ClmmPositionInfo>;
-    collectTokens(p: CollectTokens): Promise<{
+    removeLiquidity(p: ClmmRemoveLiquidityRequest): Promise<{
+        positionId: string;
+        result: SignExecuteScriptTxResult;
+    }>;
+    positionInfo({ poolId, ...args }: ClmmPositionInfoRequest): Promise<ClmmPositionInfo>;
+    collectTokens(p: ClmmCollectTokensRequest): Promise<{
         positionId: string;
         result: SignExecuteScriptTxResult;
     }>;
     findBestRoute(token0: string, token1: string): Promise<bigint>;
-    simulateSwap(p: SimulateSwap): Promise<LiquidityDistribution>;
-    swap(p: ClmmSwapParams): Promise<SignExecuteScriptTxResult>;
-    collectProtocolFees(p: CollectProtocolFees): Promise<SignExecuteScriptTxResult>;
-    setRewardParams(p: SetRewardParams): Promise<SignExecuteScriptTxResult>;
-    extendRewards(p: ExtendRewards): Promise<SignExecuteScriptTxResult>;
+    simulateSwap(p: ClmmSimulateSwapParams): Promise<ClmmSimulateSwapQuote>;
+    swap(p: ClmmSwapRequest): Promise<SignExecuteScriptTxResult>;
+    collectProtocolFees(p: ClmmCollectProtocolFeesRequest): Promise<SignExecuteScriptTxResult>;
+    setRewardParams(p: ClmmSetRewardParamsRequest): Promise<SignExecuteScriptTxResult>;
+    extendRewards(p: ClmmExtendRewardsRequest): Promise<SignExecuteScriptTxResult>;
+    private getAddLiquidityAttoAlphAmount;
     private _getClmmConfig;
 }
 
@@ -4446,7 +4470,7 @@ declare class TokenModule extends ModuleBase {
     private readonly cacheTimeDays;
     private cache?;
     private readonly cacheTimeMs;
-    constructor(scope: Zeta, cacheTimeDays?: number);
+    constructor(scope: Powfi, cacheTimeDays?: number);
     getTokens(): Promise<TokenInfo[]>;
     getTokenById(id: string): Promise<TokenInfo>;
     getTokenBySymbol(symbol: string): Promise<TokenInfo>;
@@ -4491,6 +4515,10 @@ declare namespace AlphUnstakeVaultTypes {
             }>;
             result: CallContractResult<boolean>;
         };
+        cancelAndReturn: {
+            params: Omit<CallContractParams<{}>, "args">;
+            result: CallContractResult<[bigint, bigint]>;
+        };
         destroy: {
             params: Omit<CallContractParams<{}>, "args">;
             result: CallContractResult<null>;
@@ -4530,6 +4558,10 @@ declare namespace AlphUnstakeVaultTypes {
             }>;
             result: SignExecuteScriptTxResult;
         };
+        cancelAndReturn: {
+            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+            result: SignExecuteScriptTxResult;
+        };
         destroy: {
             params: Omit<SignExecuteContractMethodParams<{}>, "args">;
             result: SignExecuteScriptTxResult;
@@ -4567,6 +4599,7 @@ declare class Factory$i extends ContractFactory<AlphUnstakeVaultInstance, AlphUn
         claim: (params: TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, {
             amount: bigint;
         }>) => Promise<TestContractResultWithoutMaps<boolean>>;
+        cancelAndReturn: (params: Omit<TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<[bigint, bigint]>>;
         destroy: (params: Omit<TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>, "args">) => Promise<TestContractResultWithoutMaps<null>>;
     };
     stateForTest(initFields: AlphUnstakeVaultTypes.Fields, asset?: Asset, address?: string): ContractState<AlphUnstakeVaultTypes.Fields> | _alephium_web3.ContractStateWithMaps<AlphUnstakeVaultTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
@@ -4580,6 +4613,7 @@ declare class AlphUnstakeVaultInstance extends ContractInstance {
         getTotalUnstakeAmount: (params?: AlphUnstakeVaultTypes.CallMethodParams<"getTotalUnstakeAmount">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"getTotalUnstakeAmount">>;
         getClaimableAmount: (params?: AlphUnstakeVaultTypes.CallMethodParams<"getClaimableAmount">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"getClaimableAmount">>;
         claim: (params: AlphUnstakeVaultTypes.CallMethodParams<"claim">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"claim">>;
+        cancelAndReturn: (params?: AlphUnstakeVaultTypes.CallMethodParams<"cancelAndReturn">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"cancelAndReturn">>;
         destroy: (params?: AlphUnstakeVaultTypes.CallMethodParams<"destroy">) => Promise<AlphUnstakeVaultTypes.CallMethodResult<"destroy">>;
     };
     transact: {
@@ -4587,6 +4621,7 @@ declare class AlphUnstakeVaultInstance extends ContractInstance {
         getTotalUnstakeAmount: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getTotalUnstakeAmount">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"getTotalUnstakeAmount">>;
         getClaimableAmount: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getClaimableAmount">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"getClaimableAmount">>;
         claim: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"claim">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"claim">>;
+        cancelAndReturn: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"cancelAndReturn">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"cancelAndReturn">>;
         destroy: (params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"destroy">) => Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"destroy">>;
     };
     multicall<Calls extends AlphUnstakeVaultTypes.MultiCallParams>(calls: Calls): Promise<AlphUnstakeVaultTypes.MultiCallResults<Calls>>;
@@ -6197,16 +6232,29 @@ declare namespace XAlphTokenTypes {
         unstakeVaultTemplateId: HexString;
         maxActiveUnstakeRequestsPerUser: bigint;
         unstakeDuration: bigint;
-        totalStaked: bigint;
+        totalDepositedAlph: bigint;
+        totalXAlphSupply: bigint;
         lastUnstakeVaultIndex: bigint;
     };
     type State = ContractState<Fields>;
     type StakedEvent = ContractEvent<{
         to: Address;
-        amount: bigint;
+        alphAmount: bigint;
+        xAlphAmount: bigint;
     }>;
     type UnstakeScheduledEvent = ContractEvent<{
         to: Address;
+        xAlphAmount: bigint;
+        alphAmount: bigint;
+    }>;
+    type UnstakeCancelledEvent = ContractEvent<{
+        to: Address;
+        xAlphAmount: bigint;
+        claimedAlphAmount: bigint;
+        restakedAlphAmount: bigint;
+    }>;
+    type RewardDepositedEvent = ContractEvent<{
+        from: Address;
         amount: bigint;
     }>;
     interface CallMethodTable {
@@ -6280,11 +6328,23 @@ declare namespace XAlphTokenTypes {
             params: Omit<CallContractParams<{}>, "args">;
             result: CallContractResult<HexString>;
         };
+        mulDiv: {
+            params: CallContractParams<{
+                a: bigint;
+                b: bigint;
+                denominator: bigint;
+            }>;
+            result: CallContractResult<bigint>;
+        };
+        getTotalDepositedAlph: {
+            params: Omit<CallContractParams<{}>, "args">;
+            result: CallContractResult<bigint>;
+        };
         stake: {
             params: CallContractParams<{
                 amount: bigint;
             }>;
-            result: CallContractResult<null>;
+            result: CallContractResult<bigint>;
         };
         startUnstake: {
             params: CallContractParams<{
@@ -6292,6 +6352,12 @@ declare namespace XAlphTokenTypes {
             }>;
             result: CallContractResult<HexString>;
         };
+        depositReward: {
+            params: CallContractParams<{
+                amount: bigint;
+            }>;
+            result: CallContractResult<null>;
+        };
         getActiveUnstakeVaultIndexes: {
             params: CallContractParams<{
                 caller: Address;
@@ -6312,6 +6378,12 @@ declare namespace XAlphTokenTypes {
             }>;
             result: CallContractResult<null>;
         };
+        cancelUnstake: {
+            params: CallContractParams<{
+                vaultIndex: bigint;
+            }>;
+            result: CallContractResult<bigint>;
+        };
     }
     type CallMethodParams<T extends keyof CallMethodTable> = CallMethodTable[T]["params"];
     type CallMethodResult<T extends keyof CallMethodTable> = CallMethodTable[T]["result"];
@@ -6395,6 +6467,18 @@ declare namespace XAlphTokenTypes {
             params: Omit<SignExecuteContractMethodParams<{}>, "args">;
             result: SignExecuteScriptTxResult;
         };
+        mulDiv: {
+            params: SignExecuteContractMethodParams<{
+                a: bigint;
+                b: bigint;
+                denominator: bigint;
+            }>;
+            result: SignExecuteScriptTxResult;
+        };
+        getTotalDepositedAlph: {
+            params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+            result: SignExecuteScriptTxResult;
+        };
         stake: {
             params: SignExecuteContractMethodParams<{
                 amount: bigint;
@@ -6407,6 +6491,12 @@ declare namespace XAlphTokenTypes {
             }>;
             result: SignExecuteScriptTxResult;
         };
+        depositReward: {
+            params: SignExecuteContractMethodParams<{
+                amount: bigint;
+            }>;
+            result: SignExecuteScriptTxResult;
+        };
         getActiveUnstakeVaultIndexes: {
             params: SignExecuteContractMethodParams<{
                 caller: Address;
@@ -6427,6 +6517,12 @@ declare namespace XAlphTokenTypes {
             }>;
             result: SignExecuteScriptTxResult;
         };
+        cancelUnstake: {
+            params: SignExecuteContractMethodParams<{
+                vaultIndex: bigint;
+            }>;
+            result: SignExecuteScriptTxResult;
+        };
     }
     type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["params"];
     type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> = SignExecuteMethodTable[T]["result"];
@@ -6442,6 +6538,8 @@ declare class Factory$a extends ContractFactory<XAlphTokenInstance, XAlphTokenTy
     eventIndex: {
         Staked: number;
         UnstakeScheduled: number;
+        UnstakeCancelled: number;
+        RewardDeposited: number;
     };
     consts: {
         IntByteLength: bigint;
@@ -6450,12 +6548,19 @@ declare class Factory$a extends ContractFactory<XAlphTokenInstance, XAlphTokenTy
             IndexOutOfBound: bigint;
             InvalidByteVecLength: bigint;
         };
+        FullMathError: {
+            DivByZero: bigint;
+            MulDivOverflow: bigint;
+        };
         ErrorCodes: {
             AssetAddressCallerOnly: bigint;
             TooManyActiveUnstakeVaults: bigint;
             InvalidUnstakeDuration: bigint;
             NonExistantUnstakeVault: bigint;
             AmountMustBeGreaterThanZero: bigint;
+            ZeroXAlphOutput: bigint;
+            ZeroAlphOutput: bigint;
+            NoStakers: bigint;
         };
     };
     at(address: string): XAlphTokenInstance;
@@ -6494,12 +6599,21 @@ declare class Factory$a extends ContractFactory<XAlphTokenInstance, XAlphTokenTy
             array: HexString;
         }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
         empty: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
+        mulDiv: (params: TestContractParams<XAlphTokenTypes.Fields, {
+            a: bigint;
+            b: bigint;
+            denominator: bigint;
+        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
+        getTotalDepositedAlph: (params: Omit<TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>, "args">) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
         stake: (params: TestContractParams<XAlphTokenTypes.Fields, {
             amount: bigint;
-        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<null, XAlphTokenTypes.Maps>>;
+        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
         startUnstake: (params: TestContractParams<XAlphTokenTypes.Fields, {
             amount: bigint;
         }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
+        depositReward: (params: TestContractParams<XAlphTokenTypes.Fields, {
+            amount: bigint;
+        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<null, XAlphTokenTypes.Maps>>;
         getActiveUnstakeVaultIndexes: (params: TestContractParams<XAlphTokenTypes.Fields, {
             caller: Address;
         }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>>;
@@ -6511,6 +6625,9 @@ declare class Factory$a extends ContractFactory<XAlphTokenInstance, XAlphTokenTy
             vaultIndex: bigint;
             amount: bigint;
         }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<null, XAlphTokenTypes.Maps>>;
+        cancelUnstake: (params: TestContractParams<XAlphTokenTypes.Fields, {
+            vaultIndex: bigint;
+        }, XAlphTokenTypes.Maps>) => Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>>;
     };
     stateForTest(initFields: XAlphTokenTypes.Fields, asset?: Asset, address?: string, maps?: XAlphTokenTypes.Maps): ContractState<XAlphTokenTypes.Fields> | _alephium_web3.ContractStateWithMaps<XAlphTokenTypes.Fields, Record<string, Map<_alephium_web3.Val, _alephium_web3.Val>>>;
 }
@@ -6524,7 +6641,9 @@ declare class XAlphTokenInstance extends ContractInstance {
     getContractEventsCurrentCount(): Promise<number>;
     subscribeStakedEvent(options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent>, fromCount?: number): EventSubscription;
     subscribeUnstakeScheduledEvent(options: EventSubscribeOptions<XAlphTokenTypes.UnstakeScheduledEvent>, fromCount?: number): EventSubscription;
-    subscribeAllEvents(options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent | XAlphTokenTypes.UnstakeScheduledEvent>, fromCount?: number): EventSubscription;
+    subscribeUnstakeCancelledEvent(options: EventSubscribeOptions<XAlphTokenTypes.UnstakeCancelledEvent>, fromCount?: number): EventSubscription;
+    subscribeRewardDepositedEvent(options: EventSubscribeOptions<XAlphTokenTypes.RewardDepositedEvent>, fromCount?: number): EventSubscription;
+    subscribeAllEvents(options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent | XAlphTokenTypes.UnstakeScheduledEvent | XAlphTokenTypes.UnstakeCancelledEvent | XAlphTokenTypes.RewardDepositedEvent>, fromCount?: number): EventSubscription;
     view: {
         getSymbol: (params?: XAlphTokenTypes.CallMethodParams<"getSymbol">) => Promise<XAlphTokenTypes.CallMethodResult<"getSymbol">>;
         getName: (params?: XAlphTokenTypes.CallMethodParams<"getName">) => Promise<XAlphTokenTypes.CallMethodResult<"getName">>;
@@ -6538,11 +6657,15 @@ declare class XAlphTokenInstance extends ContractInstance {
         removeAt: (params: XAlphTokenTypes.CallMethodParams<"removeAt">) => Promise<XAlphTokenTypes.CallMethodResult<"removeAt">>;
         size: (params: XAlphTokenTypes.CallMethodParams<"size">) => Promise<XAlphTokenTypes.CallMethodResult<"size">>;
         empty: (params?: XAlphTokenTypes.CallMethodParams<"empty">) => Promise<XAlphTokenTypes.CallMethodResult<"empty">>;
+        mulDiv: (params: XAlphTokenTypes.CallMethodParams<"mulDiv">) => Promise<XAlphTokenTypes.CallMethodResult<"mulDiv">>;
+        getTotalDepositedAlph: (params?: XAlphTokenTypes.CallMethodParams<"getTotalDepositedAlph">) => Promise<XAlphTokenTypes.CallMethodResult<"getTotalDepositedAlph">>;
         stake: (params: XAlphTokenTypes.CallMethodParams<"stake">) => Promise<XAlphTokenTypes.CallMethodResult<"stake">>;
         startUnstake: (params: XAlphTokenTypes.CallMethodParams<"startUnstake">) => Promise<XAlphTokenTypes.CallMethodResult<"startUnstake">>;
+        depositReward: (params: XAlphTokenTypes.CallMethodParams<"depositReward">) => Promise<XAlphTokenTypes.CallMethodResult<"depositReward">>;
         getActiveUnstakeVaultIndexes: (params: XAlphTokenTypes.CallMethodParams<"getActiveUnstakeVaultIndexes">) => Promise<XAlphTokenTypes.CallMethodResult<"getActiveUnstakeVaultIndexes">>;
         getClaimableAmount: (params: XAlphTokenTypes.CallMethodParams<"getClaimableAmount">) => Promise<XAlphTokenTypes.CallMethodResult<"getClaimableAmount">>;
         claimUnstaked: (params: XAlphTokenTypes.CallMethodParams<"claimUnstaked">) => Promise<XAlphTokenTypes.CallMethodResult<"claimUnstaked">>;
+        cancelUnstake: (params: XAlphTokenTypes.CallMethodParams<"cancelUnstake">) => Promise<XAlphTokenTypes.CallMethodResult<"cancelUnstake">>;
     };
     transact: {
         getSymbol: (params: XAlphTokenTypes.SignExecuteMethodParams<"getSymbol">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getSymbol">>;
@@ -6557,11 +6680,15 @@ declare class XAlphTokenInstance extends ContractInstance {
         removeAt: (params: XAlphTokenTypes.SignExecuteMethodParams<"removeAt">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"removeAt">>;
         size: (params: XAlphTokenTypes.SignExecuteMethodParams<"size">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"size">>;
         empty: (params: XAlphTokenTypes.SignExecuteMethodParams<"empty">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"empty">>;
+        mulDiv: (params: XAlphTokenTypes.SignExecuteMethodParams<"mulDiv">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"mulDiv">>;
+        getTotalDepositedAlph: (params: XAlphTokenTypes.SignExecuteMethodParams<"getTotalDepositedAlph">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getTotalDepositedAlph">>;
         stake: (params: XAlphTokenTypes.SignExecuteMethodParams<"stake">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"stake">>;
         startUnstake: (params: XAlphTokenTypes.SignExecuteMethodParams<"startUnstake">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"startUnstake">>;
+        depositReward: (params: XAlphTokenTypes.SignExecuteMethodParams<"depositReward">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"depositReward">>;
         getActiveUnstakeVaultIndexes: (params: XAlphTokenTypes.SignExecuteMethodParams<"getActiveUnstakeVaultIndexes">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getActiveUnstakeVaultIndexes">>;
         getClaimableAmount: (params: XAlphTokenTypes.SignExecuteMethodParams<"getClaimableAmount">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"getClaimableAmount">>;
         claimUnstaked: (params: XAlphTokenTypes.SignExecuteMethodParams<"claimUnstaked">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"claimUnstaked">>;
+        cancelUnstake: (params: XAlphTokenTypes.SignExecuteMethodParams<"cancelUnstake">) => Promise<XAlphTokenTypes.SignExecuteMethodResult<"cancelUnstake">>;
     };
     multicall<Calls extends XAlphTokenTypes.MultiCallParams>(calls: Calls): Promise<XAlphTokenTypes.MultiCallResults<Calls>>;
     multicall<Callss extends XAlphTokenTypes.MultiCallParams[]>(callss: Narrow<Callss>): Promise<XAlphTokenTypes.MulticallReturnType<Callss>>;
@@ -6571,18 +6698,12 @@ declare function getAllContracts$1(): ContractFactory<any>[];
 declare function registerContract$1(factory: ContractFactory<any>): void;
 declare function getContractByCodeHash$1(codeHash: string): Contract;
 
-declare const AlphStakeAndLock: ExecutableScript<{
-    xAlphToken: HexString;
-    xAlphStakeVault: HexString;
-    amount: bigint;
-}, null>;
 declare const XAlphUnlockAndStartUnstake: ExecutableScript<{
     xAlphToken: HexString;
     xAlphStakeVault: HexString;
     amount: bigint;
 }, null>;
 
-declare const index$1_AlphStakeAndLock: typeof AlphStakeAndLock;
 declare const index$1_AlphUnstakeVault: typeof AlphUnstakeVault;
 type index$1_AlphUnstakeVaultInstance = AlphUnstakeVaultInstance;
 declare const index$1_AlphUnstakeVaultInstance: typeof AlphUnstakeVaultInstance;
@@ -6617,7 +6738,7 @@ declare const index$1_XAlphTokenInstance: typeof XAlphTokenInstance;
 declare const index$1_XAlphTokenTypes: typeof XAlphTokenTypes;
 declare const index$1_XAlphUnlockAndStartUnstake: typeof XAlphUnlockAndStartUnstake;
 declare namespace index$1 {
-  export { index$1_AlphStakeAndLock as AlphStakeAndLock, index$1_AlphUnstakeVault as AlphUnstakeVault, index$1_AlphUnstakeVaultInstance as AlphUnstakeVaultInstance, index$1_AlphUnstakeVaultTypes as AlphUnstakeVaultTypes, FullMathTest$1 as FullMathTest, FullMathTestInstance$1 as FullMathTestInstance, FullMathTestTypes$1 as FullMathTestTypes, index$1_GovernanceDemo as GovernanceDemo, index$1_GovernanceDemoInstance as GovernanceDemoInstance, index$1_GovernanceDemoTypes as GovernanceDemoTypes, index$1_RewardSharingVault as RewardSharingVault, index$1_RewardSharingVaultInstance as RewardSharingVaultInstance, index$1_RewardSharingVaultTypes as RewardSharingVaultTypes, index$1_TestDynamicArrayByteVec32 as TestDynamicArrayByteVec32, index$1_TestDynamicArrayByteVec32Instance as TestDynamicArrayByteVec32Instance, index$1_TestDynamicArrayByteVec32Types as TestDynamicArrayByteVec32Types, index$1_TestDynamicSortedArrayForU256 as TestDynamicSortedArrayForU256, index$1_TestDynamicSortedArrayForU256Instance as TestDynamicSortedArrayForU256Instance, index$1_TestDynamicSortedArrayForU256Types as TestDynamicSortedArrayForU256Types, index$1_TestMerkleProof as TestMerkleProof, index$1_TestMerkleProofInstance as TestMerkleProofInstance, index$1_TestMerkleProofTypes as TestMerkleProofTypes, index$1_XAlphStakeVault as XAlphStakeVault, index$1_XAlphStakeVaultInstance as XAlphStakeVaultInstance, index$1_XAlphStakeVaultTypes as XAlphStakeVaultTypes, index$1_XAlphToken as XAlphToken, index$1_XAlphTokenInstance as XAlphTokenInstance, index$1_XAlphTokenTypes as XAlphTokenTypes, index$1_XAlphUnlockAndStartUnstake as XAlphUnlockAndStartUnstake, getAllContracts$1 as getAllContracts, getContractByCodeHash$1 as getContractByCodeHash, registerContract$1 as registerContract };
+  export { index$1_AlphUnstakeVault as AlphUnstakeVault, index$1_AlphUnstakeVaultInstance as AlphUnstakeVaultInstance, index$1_AlphUnstakeVaultTypes as AlphUnstakeVaultTypes, FullMathTest$1 as FullMathTest, FullMathTestInstance$1 as FullMathTestInstance, FullMathTestTypes$1 as FullMathTestTypes, index$1_GovernanceDemo as GovernanceDemo, index$1_GovernanceDemoInstance as GovernanceDemoInstance, index$1_GovernanceDemoTypes as GovernanceDemoTypes, index$1_RewardSharingVault as RewardSharingVault, index$1_RewardSharingVaultInstance as RewardSharingVaultInstance, index$1_RewardSharingVaultTypes as RewardSharingVaultTypes, index$1_TestDynamicArrayByteVec32 as TestDynamicArrayByteVec32, index$1_TestDynamicArrayByteVec32Instance as TestDynamicArrayByteVec32Instance, index$1_TestDynamicArrayByteVec32Types as TestDynamicArrayByteVec32Types, index$1_TestDynamicSortedArrayForU256 as TestDynamicSortedArrayForU256, index$1_TestDynamicSortedArrayForU256Instance as TestDynamicSortedArrayForU256Instance, index$1_TestDynamicSortedArrayForU256Types as TestDynamicSortedArrayForU256Types, index$1_TestMerkleProof as TestMerkleProof, index$1_TestMerkleProofInstance as TestMerkleProofInstance, index$1_TestMerkleProofTypes as TestMerkleProofTypes, index$1_XAlphStakeVault as XAlphStakeVault, index$1_XAlphStakeVaultInstance as XAlphStakeVaultInstance, index$1_XAlphStakeVaultTypes as XAlphStakeVaultTypes, index$1_XAlphToken as XAlphToken, index$1_XAlphTokenInstance as XAlphTokenInstance, index$1_XAlphTokenTypes as XAlphTokenTypes, index$1_XAlphUnlockAndStartUnstake as XAlphUnlockAndStartUnstake, getAllContracts$1 as getAllContracts, getContractByCodeHash$1 as getContractByCodeHash, registerContract$1 as registerContract };
 }
 
 interface StakingConfig {
@@ -6647,7 +6768,7 @@ declare class StakingModule extends ModuleBase {
     private config;
     private xAlphTokenContract;
     private stakeVaultContract;
-    constructor(scope: Zeta);
+    constructor(scope: Powfi);
     setConfig(config: StakingConfig): void;
     getConfig(): StakingConfig;
     getXAlphToken(): XAlphTokenInstance;
@@ -6659,9 +6780,9 @@ declare class StakingModule extends ModuleBase {
     stakeAlph(amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'stake'>>;
     startUnstake(amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'startUnstake'>>;
     claimUnstaked(vaultIndex: bigint, amount: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'claimUnstaked'>>;
+    cancelUnstake(vaultIndex: bigint): Promise<XAlphTokenTypes.SignExecuteMethodResult<'cancelUnstake'>>;
     stakeXAlph(amount: bigint): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'stake'>>;
     unstakeXAlph(amount: bigint): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<'unstake'>>;
-    stakeAndLockAlph(amount: bigint): Promise<ExecuteScriptResult>;
     unlockAndStartUnstake(amount: bigint): Promise<ExecuteScriptResult>;
     getAlphUnstakeVault(userAddress: string, vaultIndex: bigint): AlphUnstakeVaultInstance;
     getAlphUnstakeVaultState(userAddress: string, vaultIndex: bigint): Promise<AlphUnstakeVaultTypes.State>;
@@ -6675,9 +6796,10 @@ declare class StakingModule extends ModuleBase {
     getSettings(): StakingSettings;
     private loadStakingConfig;
     private ensurePositiveAmount;
+    private getStakerAddress;
 }
 
-declare class Zeta {
+declare class Powfi {
     cpmm: CpmmModule;
     clmm: ClmmModule;
     token: TokenModule;
@@ -6688,8 +6810,8 @@ declare class Zeta {
     private _signer?;
     private _account?;
     private _network;
-    constructor(params: ZetaLoadParams);
-    static load(config: ZetaLoadParams): Zeta;
+    constructor(params: PowfiLoadParams);
+    static load(config: PowfiLoadParams): Powfi;
     set signer(signer: SignerProvider);
     set account(account: Account);
     get signer(): SignerProvider;
@@ -6708,22 +6830,22 @@ declare const BPS = 10000n;
 declare function normalizeAddress(address: string, group: number): string;
 declare function sortTokens(tokenAId: string, tokenBId: string): [string, string];
 
-declare class ZetaSDKError extends Error {
+declare class PowfiSDKError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-declare class InsufficientLiquidityError extends ZetaSDKError {
+declare class InsufficientLiquidityError extends PowfiSDKError {
     constructor(message?: string);
 }
-declare class PriceImpactTooHighError extends ZetaSDKError {
+declare class PriceImpactTooHighError extends PowfiSDKError {
     constructor(priceImpact: number, maxPriceImpact: number);
 }
-declare class PoolNotFoundError extends ZetaSDKError {
+declare class PoolNotFoundError extends PowfiSDKError {
     constructor(poolId: string);
 }
-declare class InsufficientBalanceError extends ZetaSDKError {
+declare class InsufficientBalanceError extends PowfiSDKError {
     constructor(token: string, required: string, available: string);
 }
-declare class TokenListFetchError extends ZetaSDKError {
+declare class TokenListFetchError extends PowfiSDKError {
     readonly status?: number;
     constructor(url: string, options?: {
         status?: number;
@@ -6779,9 +6901,9 @@ declare class TickUtils {
         tick: bigint;
         price: number;
     };
-    static getNextSqrtPrice(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint, zeroForOne: boolean): bigint;
     static getNextSqrtPriceFromAmount0(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint): bigint;
     static getNextSqrtPriceFromAmount1(sqrtPriceX96: bigint, liquidity: bigint, amount: bigint): bigint;
+    static getNextSqrtPrice(sqrtPX96: bigint, liquidity: bigint, amount: bigint, zeroForOne: boolean): bigint;
     static getSqrtPriceLimitX96(sqrtPriceX96: bigint, slippage: bigint, zeroForOne: boolean): bigint;
     static getSqrtPriceX96Bounds(sqrtPriceX96: bigint, slippage: bigint): [bigint, bigint];
     private static priceSqrt;
@@ -6796,7 +6918,7 @@ declare const UNLIMITED_AMOUNT: bigint;
 declare class PoolUtils {
     static getPositionId(poolAddress: string, owner: string, tickLower: bigint, tickUpper: bigint): string;
     static computeSwapStep(sqrtPriceX96: bigint, sqrtPriceTargetX96: bigint, liquidity: bigint, amount: bigint, feePips: bigint): [bigint, bigint, bigint, bigint];
-    static offlineSwap(liqDist: LiquidityDistribution, amountSpecified: bigint, sqrtPriceX96: bigint): bigint;
+    static offlineSwap(liqDist: ClmmSimulateSwapQuote, amountSpecified: bigint, sqrtPriceX96: bigint): bigint;
 }
 
 declare class ClmmLiquidityUtils {
@@ -8610,6 +8732,7 @@ declare const CreatePairAndAddLiquidity: ExecutableScript<{
     token1Id: HexString;
     amount0: bigint;
     amount1: bigint;
+    dexAccount: HexString;
 }, null>;
 declare const EnableFeeCollector: ExecutableScript<{
     tokenPairFactory: HexString;
@@ -8798,4 +8921,4 @@ type Deployments = {
 };
 declare function loadDeployments(networkId: NetworkId, deployerAddress?: string): Deployments;
 
-export { type AddLiquidity$1 as AddLiquidity, type AddLiquidityDetails, type AddLiquidityParams, BPS, type ClaimableAmounts, type ClmmConfig, index$2 as ClmmContracts, ClmmLiquidityUtils, ClmmModule, type ClmmPoolConfig, type ClmmPoolContractState, PoolFactoryTypes as ClmmPoolFactoryTypes, PoolTypes as ClmmPoolTypes, type ClmmPositionInfo, PositionManagerTypes as ClmmPositionManagerTypes, scripts$1 as ClmmScripts, type ClmmSwapParams, type CollectProtocolFees, type CollectTokens, type ComputeLiquidityParams, type ComputeSwapParams, type CpmmConfig, index as CpmmContracts, CpmmModule, type CpmmPoolContractState, scripts as CpmmScripts, TokenPairFactoryTypes as CpmmTokenPairFactoryTypes, TokenPairTypes as CpmmTokenPairTypes, type CreatePoolParams, DEVNET, type ExtendRewards, type GetPositionAmountsFromPriceProps, type GetPositionAmountsFromPriceReturn, GovernanceDemoTypes, InsufficientBalanceError, InsufficientLiquidityError, type LiquidityDistribution, type LiquidityForPrice, LogLevel, Logger, MAX_PIPS, MAX_PRICE_IMPACT, MAX_TICK, MINIMUM_LIQUIDITY, MIN_TICK, MathUtil, type Network, type NetworkOverrides, type NumericLike, NumericUtils, PoolNotFoundError, PoolUtils, type PositionPath, PriceImpactTooHighError, type RemoveLiquidity$1 as RemoveLiquidity, type RemoveLiquidityDetails, type RemoveLiquidityParams, RewardSharingVaultTypes, type Rounding, type SetRewardParams, type SimulateSwap, type StakeVaultUserInfo, type StakingConfig, index$1 as StakingContracts, StakingModule, type StakingSettings, type SwapDetails, type SwapParams$1 as SwapParams, TickUtils, TokenListFetchError, TokenModule, U256_MAX, UNLIMITED_AMOUNT, XAlphStakeVaultTypes, XAlphTokenTypes, Zeta, type ZetaLoadParams, ZetaSDKError, createLogger, decodeContractIdList, decodeU256List, defaultNetworks, getStakingSettings, loadDeployments$1 as loadClmmDeployments, loadDeployments$2 as loadCpmmDeployments, loadDeployments as loadStakingDeployments, normalizeAddress, setLoggerLevel, sortTokens, stakingSettingsByNetwork };
+export { BPS, type ClmmAddLiquidityRequest, type ClmmCollectProtocolFeesRequest, type ClmmCollectTokensRequest, type ClmmConfig, index$2 as ClmmContracts, type ClmmExtendRewardsRequest, ClmmLiquidityUtils, ClmmModule, type ClmmPoolConfig, type ClmmPoolContractState, PoolFactoryTypes as ClmmPoolFactoryTypes, PoolTypes as ClmmPoolTypes, type ClmmPositionInfo, type ClmmPositionInfoRequest, PositionManagerTypes as ClmmPositionManagerTypes, type ClmmRemoveLiquidityRequest, scripts$1 as ClmmScripts, type ClmmSetRewardParamsRequest, type ClmmSimulateSwapParams, type ClmmSimulateSwapQuote, type ClmmSwapRequest, type CpmmAddLiquidityQuote, type CpmmAddLiquidityQuoteParams, type CpmmAddLiquidityRequest, type CpmmClaimableAmounts, type CpmmConfig, index as CpmmContracts, type CpmmCreatePoolRequest, type CpmmInputType, CpmmModule, type CpmmPoolContractState, type CpmmRemoveLiquidityQuote, type CpmmRemoveLiquidityRequest, scripts as CpmmScripts, type CpmmSlippageBps, type CpmmSwapQuote, type CpmmSwapQuoteParams, type CpmmSwapRequest, type CpmmTokenId, TokenPairFactoryTypes as CpmmTokenPairFactoryTypes, TokenPairTypes as CpmmTokenPairTypes, DEVNET, type GetPositionAmountsFromPriceProps, type GetPositionAmountsFromPriceReturn, GovernanceDemoTypes, InsufficientBalanceError, InsufficientLiquidityError, type LiquidityForPrice, LogLevel, Logger, MAX_PIPS, MAX_PRICE_IMPACT, MAX_TICK, MINIMUM_LIQUIDITY, MIN_TICK, MathUtil, type Network, type NetworkOverrides, type NumericLike, NumericUtils, PoolNotFoundError, PoolUtils, Powfi, type PowfiLoadParams, PowfiSDKError, PriceImpactTooHighError, RewardSharingVaultTypes, type Rounding, type StakeVaultUserInfo, type StakingConfig, index$1 as StakingContracts, StakingModule, type StakingSettings, TickUtils, TokenListFetchError, TokenModule, U256_MAX, UNLIMITED_AMOUNT, XAlphStakeVaultTypes, XAlphTokenTypes, createLogger, decodeContractIdList, decodeU256List, defaultNetworks, getStakingSettings, loadDeployments$1 as loadClmmDeployments, loadDeployments$2 as loadCpmmDeployments, loadDeployments as loadStakingDeployments, normalizeAddress, setLoggerLevel, sortTokens, stakingSettingsByNetwork };