@fatsolutions/privacy-pools-core-starknet-sdk 0.0.44 → 0.0.46

package/src/contracts/contracts.service.ts

@@ -1,5 +1,16 @@
 import { Hash } from "@0xbow/privacy-pools-core-sdk";
-import { AllowArray, Call, Contract, InvokeFunctionResponse, num, RpcProvider, SimulateTransaction, Account as SNAccount, TypedContractV2, UniversalDetails } from "starknet";
+import {
+  AllowArray,
+  Call,
+  Contract,
+  InvokeFunctionResponse,
+  num,
+  RpcProvider,
+  SimulateTransaction,
+  Account as SNAccount,
+  TypedContractV2,
+  UniversalDetails,
+} from "starknet";
 
 import { EntryPointABI } from "../abis/EntryPoint.abi.js";
 import { ERC20ABI } from "../abis/ERC20.abi.js";
@@ -8,7 +19,7 @@ import { ETH_ADDRESS } from "../constants.js";
 import { SNContractError, SNPoolError, StarknetSDKError } from "../errors/index.js";
 import { AssetConfig, Withdrawal } from "../types/entrypoint.js";
 import { StarknetAddress } from "../types/starknet.js";
-import { castBigInt, toAddress } from "../utils.js";
+import { castBigInt, toAddress, toCairoOption } from "../utils.js";
 import { executeIntent, simulateIntent } from "./transactionHandler.js";
 
 /**
@@ -34,22 +45,28 @@ export const Mode = {
   /** Simulate the transaction without executing it */
   SIMULATE: "simulate",
   /** Execute the transaction on-chain */
-  EXECUTE: "execute"
+  EXECUTE: "execute",
 } as const;
 
-export type Mode = typeof Mode[keyof typeof Mode];
+export type Mode = (typeof Mode)[keyof typeof Mode];
 
 /** Option type for simulation mode */
-export type OptionSimulate = {};
+export type OptionSimulate = object;
 
 /** Option type for execution mode with optional transaction details */
-export type OptionExecute = { details?: UniversalDetails; };
+export type OptionExecute = { details?: UniversalDetails };
 
 /** Option type for simulation mode */
-export type OptionModeSimulate = { mode: typeof Mode.SIMULATE; modeOptions?: OptionSimulate; };
+export type OptionModeSimulate = {
+  mode: typeof Mode.SIMULATE;
+  modeOptions?: OptionSimulate;
+};
 
 /** Option type for execution mode with optional transaction details */
-export type OptionModeExecute = { mode: typeof Mode.EXECUTE; modeOptions?: OptionExecute; };
+export type OptionModeExecute = {
+  mode: typeof Mode.EXECUTE;
+  modeOptions?: OptionExecute;
+};
 
 type OptionModesMap = {
   [Mode.EXECUTE]: OptionExecute;
@@ -60,18 +77,18 @@ type OptionModes = {
   [K in keyof OptionModesMap]: {
     mode: K;
     modeOptions?: OptionModesMap[K];
-  }
+  };
 }[keyof OptionModesMap];
 
 /** Call options including account and execution mode */
-type CallOptions = { account: SNAccount | RpcProvider; } & OptionModes;
+type CallOptions = { account: SNAccount | RpcProvider } & OptionModes;
 
 /** Union type for all possible call results */
-type CallResult = AllowArray<Call> | Omit<SimulateTransaction, 'fee_estimation'> | TransactionResponse;
+type CallResult = AllowArray<Call> | Omit<SimulateTransaction, "fee_estimation"> | TransactionResponse;
 
 /** Helper function for asserting instances */
 function _isAccount(x: SNAccount | RpcProvider): x is SNAccount {
-  return ((x as SNAccount).simulateTransaction !== undefined) && ((x as SNAccount).execute !== undefined);
+  return (x as SNAccount).simulateTransaction !== undefined && (x as SNAccount).execute !== undefined;
 }
 
 /**
@@ -85,15 +102,12 @@ function _isAccount(x: SNAccount | RpcProvider): x is SNAccount {
 function _intentOptionWrapper(calls: AllowArray<Call>, options?: CallOptions): Promise<CallResult> {
   if (options === undefined || !_isAccount(options.account)) {
     return Promise.resolve(calls);
-  }
-  else if (options.mode === Mode.SIMULATE) {
+  } else if (options.mode === Mode.SIMULATE) {
     return simulateIntent(options.account, calls);
-  }
-  else if (options.mode === Mode.EXECUTE) {
+  } else if (options.mode === Mode.EXECUTE) {
     const details = options.modeOptions?.details;
     return executeIntent(options.account, calls, details);
-  }
-  else {
+  } else {
     throw StarknetSDKError.unreachable();
   }
 }
@@ -125,7 +139,6 @@ function _intentOptionWrapper(calls: AllowArray<Call>, options?: CallOptions): P
  * ```
  */
 export class SNContractInteractionsService {
-
   /** The typed EntryPoint contract instance */
   entrypoint: EntryPointType;
 
@@ -137,9 +150,13 @@ export class SNContractInteractionsService {
    */
   constructor(
     entrypointAddress: StarknetAddress,
-    readonly providerOrAccount: SNAccount | RpcProvider,
+    readonly providerOrAccount: SNAccount | RpcProvider
   ) {
-    this.entrypoint = new Contract({ abi: EntryPointABI, address: entrypointAddress, providerOrAccount: this.providerOrAccount }).typedv2(EntryPointABI);
+    this.entrypoint = new Contract({
+      abi: EntryPointABI,
+      address: entrypointAddress,
+      providerOrAccount: this.providerOrAccount,
+    }).typedv2(EntryPointABI);
   }
 
   /**
@@ -149,11 +166,19 @@ export class SNContractInteractionsService {
    * @returns A typed contract instance for the PrivacyPool
    */
   pool(address: StarknetAddress): PrivacyPoolType {
-    return new Contract({ abi: PrivacyPoolABI, address, providerOrAccount: this.providerOrAccount }).typedv2(PrivacyPoolABI);
+    return new Contract({
+      abi: PrivacyPoolABI,
+      address,
+      providerOrAccount: this.providerOrAccount,
+    }).typedv2(PrivacyPoolABI);
   }
 
   erc20(address: StarknetAddress): Erc20Type {
-    return new Contract({ abi: ERC20ABI, address, providerOrAccount: this.providerOrAccount }).typedv2(ERC20ABI);
+    return new Contract({
+      abi: ERC20ABI,
+      address,
+      providerOrAccount: this.providerOrAccount,
+    }).typedv2(ERC20ABI);
   }
 
   /**
@@ -174,7 +199,12 @@ export class SNContractInteractionsService {
    * @param options - Simulation options
    * @returns A simulated transaction result
    */
-  depositERC20(asset: StarknetAddress, amount: bigint, precommitment: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
+  depositERC20(
+    asset: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
   /**
    * Deposits an ERC20 token into a privacy pool and executes the transaction.
    *
@@ -184,8 +214,18 @@ export class SNContractInteractionsService {
    * @param options - Execution options with optional transaction details
    * @returns The transaction response
    */
-  depositERC20(asset: StarknetAddress, amount: bigint, precommitment: bigint, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  depositERC20(asset: StarknetAddress, amount: bigint, precommitment: bigint, options?: OptionModes): Promise<CallResult> {
+  depositERC20(
+    asset: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  depositERC20(
+    asset: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options?: OptionModes
+  ): Promise<CallResult> {
     const call = this.entrypoint.populate("deposit", [asset, amount, precommitment]);
     return _intentOptionWrapper(call, options && { ...options, account: this.providerOrAccount });
   }
@@ -239,7 +279,12 @@ export class SNContractInteractionsService {
    * @param options - Simulation options
    * @returns A simulated transaction result
    */
-  withdraw(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options: OptionModeSimulate): Promise<SimulateTransaction>;
+  withdraw(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
   /**
    * Withdraws funds from a privacy pool and executes the transaction.
    *
@@ -249,10 +294,24 @@ export class SNContractInteractionsService {
    * @param options - Execution options with optional transaction details
    * @returns The transaction response
    */
-  withdraw(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  async withdraw(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options?: OptionModes): Promise<CallResult> {
+  withdraw(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  async withdraw(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options?: OptionModes
+  ): Promise<CallResult> {
+    const _withdrawal = {
+      ...withdrawal,
+      auditorData: toCairoOption(withdrawal.auditorData),
+    };
     const { poolAddress } = await this.getScopeData(scope);
-    const call = this.pool(poolAddress).populate("withdraw", [withdrawal, { fullProof: withdrawalProofGaraga }]);
+    const call = this.pool(poolAddress).populate("withdraw", [_withdrawal, { fullProof: withdrawalProofGaraga }]);
     return _intentOptionWrapper(call, options && { ...options, account: this.providerOrAccount });
   }
 
@@ -274,7 +333,12 @@ export class SNContractInteractionsService {
    * @param options - Simulation options
    * @returns A simulated transaction result
    */
-  relay(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options: OptionModeSimulate): Promise<SimulateTransaction>;
+  relay(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
   /**
    * Relays a withdrawal transaction through the EntryPoint contract and executes it.
    *
@@ -284,9 +348,23 @@ export class SNContractInteractionsService {
    * @param options - Execution options with optional transaction details
    * @returns The transaction response
    */
-  relay(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  relay(withdrawal: Withdrawal, withdrawalProofGaraga: bigint[], scope: Hash, options?: OptionModes): Promise<CallResult> {
-    const call = this.entrypoint.populate("relay", [withdrawal, scope, { fullProof: withdrawalProofGaraga }]);
+  relay(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  relay(
+    withdrawal: Withdrawal,
+    withdrawalProofGaraga: bigint[],
+    scope: Hash,
+    options?: OptionModes
+  ): Promise<CallResult> {
+    const _withdrawal = {
+      ...withdrawal,
+      auditorData: toCairoOption(withdrawal.auditorData),
+    };
+    const call = this.entrypoint.populate("relay", [_withdrawal, scope, { fullProof: withdrawalProofGaraga }]);
     return _intentOptionWrapper(call, options && { ...options, account: this.providerOrAccount });
   }
 
@@ -306,7 +384,11 @@ export class SNContractInteractionsService {
    * @param options - Simulation options
    * @returns A simulated transaction result
    */
-  ragequit(ragequitProofGaraga: bigint[], privacyPoolAddress: StarknetAddress, options: OptionModeSimulate): Promise<SimulateTransaction>;
+  ragequit(
+    ragequitProofGaraga: bigint[],
+    privacyPoolAddress: StarknetAddress,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
   /**
    * Performs a ragequit operation to exit a privacy pool and executes the transaction.
    *
@@ -315,8 +397,16 @@ export class SNContractInteractionsService {
    * @param options - Execution options with optional transaction details
    * @returns The transaction response
    */
-  ragequit(ragequitProofGaraga: bigint[], privacyPoolAddress: StarknetAddress, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  ragequit(ragequitProofGaraga: bigint[], privacyPoolAddress: StarknetAddress, options?: OptionModes): Promise<CallResult> {
+  ragequit(
+    ragequitProofGaraga: bigint[],
+    privacyPoolAddress: StarknetAddress,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  ragequit(
+    ragequitProofGaraga: bigint[],
+    privacyPoolAddress: StarknetAddress,
+    options?: OptionModes
+  ): Promise<CallResult> {
     const call = this.pool(privacyPoolAddress).populate("ragequit", [{ fullProof: ragequitProofGaraga }]);
     return _intentOptionWrapper(call, options && { ...options, account: this.providerOrAccount });
   }
@@ -367,16 +457,16 @@ export class SNContractInteractionsService {
    * @param scope - The scope identifier
    * @returns An object containing the pool address and asset address
    */
-  async getScopeData(scope: bigint): Promise<{ poolAddress: StarknetAddress; assetAddress: StarknetAddress; }> {
+  async getScopeData(scope: bigint): Promise<{ poolAddress: StarknetAddress; assetAddress: StarknetAddress }> {
     const poolAddress = num.toHex64(await this.entrypoint.scopeToPool(scope)) as StarknetAddress;
     const assetAddress = num.toHex64(await this.pool(poolAddress).asset()) as StarknetAddress;
     return {
       poolAddress,
-      assetAddress
+      assetAddress,
     };
   }
 
-  async getAssetConfig(asset: StarknetAddress): Promise<AssetConfig & { scope: bigint; }> {
+  async getAssetConfig(asset: StarknetAddress): Promise<AssetConfig & { scope: bigint }> {
     const { pool, maxRelayFeeBPS, minimumDepositAmount, vettingFeeBPS } = await this.entrypoint.assetConfig(asset);
     const scope = await this.getScope(toAddress(pool));
     return {
@@ -407,17 +497,55 @@ export class SNContractInteractionsService {
    * @todo Implement ERC20 approval functionality
    */
   approveERC20(spenderAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint): Promise<Call>;
-  approveERC20(spenderAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  approveERC20(spenderAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, options: OptionModeExecute): Promise<TransactionResponse>;
-  approveERC20(spenderAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, options?: OptionModes): Promise<CallResult> {
+  approveERC20(
+    spenderAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  approveERC20(
+    spenderAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    options: OptionModeExecute
+  ): Promise<TransactionResponse>;
+  approveERC20(
+    spenderAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    options?: OptionModes
+  ): Promise<CallResult> {
     const call = this.erc20(tokenAddress).populate("approve", [spenderAddress, amount]);
     return _intentOptionWrapper(call, options && { ...options, account: this.providerOrAccount });
   }
 
-  approveAndDeposit(entrypointAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, precommitment: bigint): Promise<CallResult>;
-  approveAndDeposit(entrypointAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, precommitment: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  approveAndDeposit(entrypointAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, precommitment: bigint, options: OptionModeExecute): Promise<TransactionResponse>;
-  async approveAndDeposit(entrypointAddress: StarknetAddress, tokenAddress: StarknetAddress, amount: bigint, precommitment: bigint, options?: OptionModes): Promise<CallResult> {
+  approveAndDeposit(
+    entrypointAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint
+  ): Promise<CallResult>;
+  approveAndDeposit(
+    entrypointAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  approveAndDeposit(
+    entrypointAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options: OptionModeExecute
+  ): Promise<TransactionResponse>;
+  async approveAndDeposit(
+    entrypointAddress: StarknetAddress,
+    tokenAddress: StarknetAddress,
+    amount: bigint,
+    precommitment: bigint,
+    options?: OptionModes
+  ): Promise<CallResult> {
     const assetConfig = await this.entrypoint.assetConfig(tokenAddress);
     const minimumDepositAmount = castBigInt(assetConfig.minimumDepositAmount);
     if (amount < minimumDepositAmount) {
@@ -429,13 +557,27 @@ export class SNContractInteractionsService {
   }
 
   transferERC20(tokenAddress: StarknetAddress, to: StarknetAddress, amount: bigint): Promise<CallResult>;
-  transferERC20(tokenAddress: StarknetAddress, to: StarknetAddress, amount: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  transferERC20(tokenAddress: StarknetAddress, to: StarknetAddress, amount: bigint, options: OptionModeExecute): Promise<TransactionResponse>;
-  async transferERC20(tokenAddress: StarknetAddress, to: StarknetAddress, amount: bigint, options?: OptionModes): Promise<CallResult> {
+  transferERC20(
+    tokenAddress: StarknetAddress,
+    to: StarknetAddress,
+    amount: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  transferERC20(
+    tokenAddress: StarknetAddress,
+    to: StarknetAddress,
+    amount: bigint,
+    options: OptionModeExecute
+  ): Promise<TransactionResponse>;
+  async transferERC20(
+    tokenAddress: StarknetAddress,
+    to: StarknetAddress,
+    amount: bigint,
+    options?: OptionModes
+  ): Promise<CallResult> {
     const callTransfer = this.erc20(tokenAddress).populate("transfer", [to, amount]);
     return _intentOptionWrapper([callTransfer], options && { ...options, account: this.providerOrAccount });
   }
-
 }
 
 export class AdminContractInteractions {
@@ -444,12 +586,51 @@ export class AdminContractInteractions {
     this.entrypoint = contractService.entrypoint;
   }
 
-  registerPool(asset: StarknetAddress, pool: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint): Promise<Call>;
-  registerPool(asset: StarknetAddress, pool: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  registerPool(asset: StarknetAddress, pool: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  async registerPool(asset: StarknetAddress, pool: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options?: OptionModes) {
-    const call = this.entrypoint.populate("registerPool", [asset, pool, minimumDepositAmount, vettingFeeBPS, maxRelayFeeBPS]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+  registerPool(
+    asset: StarknetAddress,
+    pool: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint
+  ): Promise<Call>;
+  registerPool(
+    asset: StarknetAddress,
+    pool: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  registerPool(
+    asset: StarknetAddress,
+    pool: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  async registerPool(
+    asset: StarknetAddress,
+    pool: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options?: OptionModes
+  ) {
+    const call = this.entrypoint.populate("registerPool", [
+      asset,
+      pool,
+      minimumDepositAmount,
+      vettingFeeBPS,
+      maxRelayFeeBPS,
+    ]);
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
 
   updateRoot(root: bigint, ipfsCID: string): Promise<Call>;
@@ -458,7 +639,13 @@ export class AdminContractInteractions {
   async updateRoot(root: bigint, ipfsCID: string, options?: OptionModes) {
     _assertIpfsCID(ipfsCID);
     const call = this.entrypoint.populate("updateRoot", [root, ipfsCID]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
 
   removePool(asset: StarknetAddress): Promise<Call>;
@@ -466,15 +653,55 @@ export class AdminContractInteractions {
   removePool(asset: StarknetAddress, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
   async removePool(asset: StarknetAddress, options?: OptionModes) {
     const call = this.entrypoint.populate("removePool", [asset]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
-  }
-
-  updatePoolConfiguration(asset: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint): Promise<Call>;
-  updatePoolConfiguration(asset: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  updatePoolConfiguration(asset: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
-  async updatePoolConfiguration(asset: StarknetAddress, minimumDepositAmount: bigint, vettingFeeBPS: bigint, maxRelayFeeBPS: bigint, options?: OptionModes) {
-    const call = this.entrypoint.populate("updatePoolConfiguration", [asset, minimumDepositAmount, vettingFeeBPS, maxRelayFeeBPS]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
+  }
+
+  updatePoolConfiguration(
+    asset: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint
+  ): Promise<Call>;
+  updatePoolConfiguration(
+    asset: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  updatePoolConfiguration(
+    asset: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
+  async updatePoolConfiguration(
+    asset: StarknetAddress,
+    minimumDepositAmount: bigint,
+    vettingFeeBPS: bigint,
+    maxRelayFeeBPS: bigint,
+    options?: OptionModes
+  ) {
+    const call = this.entrypoint.populate("updatePoolConfiguration", [
+      asset,
+      minimumDepositAmount,
+      vettingFeeBPS,
+      maxRelayFeeBPS,
+    ]);
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
 
   windDownPool(pool: StarknetAddress): Promise<Call>;
@@ -482,15 +709,35 @@ export class AdminContractInteractions {
   windDownPool(pool: StarknetAddress, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
   async windDownPool(pool: StarknetAddress, options?: OptionModes) {
     const call = this.entrypoint.populate("windDownPool", [pool]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
 
   withdrawFees(asset: StarknetAddress, recipient: StarknetAddress): Promise<Call>;
-  withdrawFees(asset: StarknetAddress, recipient: StarknetAddress, options: OptionModeSimulate): Promise<SimulateTransaction>;
-  withdrawFees(asset: StarknetAddress, recipient: StarknetAddress, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
+  withdrawFees(
+    asset: StarknetAddress,
+    recipient: StarknetAddress,
+    options: OptionModeSimulate
+  ): Promise<SimulateTransaction>;
+  withdrawFees(
+    asset: StarknetAddress,
+    recipient: StarknetAddress,
+    options: OptionModeExecute
+  ): Promise<InvokeFunctionResponse>;
   async withdrawFees(asset: StarknetAddress, recipient: StarknetAddress, options?: OptionModes) {
     const call = this.entrypoint.populate("withdrawFees", [asset, recipient]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
 
   upgrade(newClassHash: string): Promise<Call>;
@@ -498,9 +745,14 @@ export class AdminContractInteractions {
   upgrade(newClassHash: string, options: OptionModeExecute): Promise<InvokeFunctionResponse>;
   async upgrade(newClassHash: string, options?: OptionModes) {
     const call = this.entrypoint.populate("upgrade", [newClassHash]);
-    return _intentOptionWrapper(call, options && { ...options, account: this.contractService.providerOrAccount });
+    return _intentOptionWrapper(
+      call,
+      options && {
+        ...options,
+        account: this.contractService.providerOrAccount,
+      }
+    );
   }
-
 }
 
 function _assertIpfsCID(ipfsCID: string) {

package/src/contracts/index.ts

@@ -1,2 +1,2 @@
-export * from "./contracts.service.js"
-export * from "./transactionHandler.js"
+export * from "./contracts.service.js";
+export * from "./transactionHandler.js";

package/src/contracts/transactionHandler.ts

@@ -1,20 +1,29 @@
-import { AllowArray, Call, InvokeFunctionResponse, Account as SNAccount, SimulateTransaction, TransactionType, UniversalDetails } from "starknet";
+import {
+  AllowArray,
+  Call,
+  InvokeFunctionResponse,
+  Account as SNAccount,
+  SimulateTransaction,
+  TransactionType,
+  UniversalDetails,
+} from "starknet";
 import { SNContractError, StarknetSDKError } from "../errors/index.js";
 import { parseContractError } from "../errors/contracts.errors.js";
 
 export async function executeIntent(
-  account: SNAccount, calls: AllowArray<Call>, transactionDetails?: UniversalDetails
+  account: SNAccount,
+  calls: AllowArray<Call>,
+  transactionDetails?: UniversalDetails
 ): Promise<InvokeFunctionResponse> {
   const sim = await simulateIntent(account, calls);
   return account.execute(calls, { ...sim, ...(transactionDetails || {}) });
 }
 
 export async function simulateIntent(
-  account: SNAccount, calls: AllowArray<Call>
-): Promise<Omit<SimulateTransaction, 'fee_estimation'>> {
-  const simRes = await account.simulateTransaction([
-    { type: TransactionType.INVOKE, payload: calls },
-  ]);
+  account: SNAccount,
+  calls: AllowArray<Call>
+): Promise<Omit<SimulateTransaction, "fee_estimation">> {
+  const simRes = await account.simulateTransaction([{ type: TransactionType.INVOKE, payload: calls }]);
 
   const sim = simRes[0];