@steerprotocol/sdk 1.23.1 → 1.25.0

package/dist/esm/base/FeeManagerClient.js

@@ -0,0 +1,522 @@
+import { isAddressEqual, } from 'viem';
+import { FEE_MANAGER_ABI } from '../const/abis/feeManager.js';
+import { SubgraphClient } from './SubgraphClient.js';
+export class FeeManagerClient extends SubgraphClient {
+    constructor(feeManagerAddress, publicClient, walletClient) {
+        super(publicClient);
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.feeManagerAddress = feeManagerAddress;
+    }
+    async getFees(vault) {
+        try {
+            const fees = await this.publicClient.readContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'getFees',
+                args: [vault],
+            });
+            return {
+                data: fees,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async getTotalFees(vault) {
+        try {
+            const totalFees = await this.publicClient.readContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'vaultTotalFees',
+                args: [vault],
+            });
+            return {
+                data: totalFees,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async getWithdrawer(vault, feeIdentifier) {
+        try {
+            const withdrawer = await this.publicClient.readContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'withdrawalPermissions',
+                args: [vault, feeIdentifier],
+            });
+            return {
+                data: withdrawer,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async validateAdminPermission() {
+        try {
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const owner = await this.publicClient.readContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'owner',
+            });
+            return {
+                data: isAddressEqual(owner, accounts[0]),
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async validateWithdrawerPermission(vault, feeIdentifier) {
+        try {
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const withdrawer = await this.publicClient.readContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'withdrawalPermissions',
+                args: [vault, feeIdentifier],
+            });
+            return {
+                data: isAddressEqual(withdrawer, accounts[0]),
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async setFeeAndWithdrawalPermission(params) {
+        try {
+            if (params.feeIdentifiers.length !== params.feeValues.length ||
+                params.feeIdentifiers.length !== params.withdrawers.length) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'feeIdentifiers, feeValues, and withdrawers must have the same length',
+                };
+            }
+            const isAdmin = await this.validateAdminPermission();
+            if (!isAdmin.success) {
+                throw new Error(isAdmin.error ?? 'Unknown error occurred');
+            }
+            if (!isAdmin.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not FeeManager owner',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'setFeeAndWithdrawalPermission',
+                args: [params.vault, params.feeIdentifiers, params.feeValues, params.withdrawers],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async setDefaultFeeAndWithdrawalPermission(params) {
+        try {
+            if (params.feeIdentifiers.length !== params.feeValues.length ||
+                params.feeIdentifiers.length !== params.withdrawers.length) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'feeIdentifiers, feeValues, and withdrawers must have the same length',
+                };
+            }
+            const isAdmin = await this.validateAdminPermission();
+            if (!isAdmin.success) {
+                throw new Error(isAdmin.error ?? 'Unknown error occurred');
+            }
+            if (!isAdmin.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not FeeManager owner',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'setDefaultFeeAndWithdrawalPermission',
+                args: [
+                    params.vault,
+                    params.totalVaultFees,
+                    params.feeIdentifiers,
+                    params.feeValues,
+                    params.withdrawers,
+                ],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async setMigratedVaultFeeAndWithdrawalPermission() {
+        try {
+            const isAdmin = await this.validateAdminPermission();
+            if (!isAdmin.success) {
+                throw new Error(isAdmin.error ?? 'Unknown error occurred');
+            }
+            if (!isAdmin.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not FeeManager owner',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'setMigratedVaultFeeAndWithdrawalPermission',
+                args: [],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async setTotalFees(vault, newTotalFees) {
+        try {
+            const isAdmin = await this.validateAdminPermission();
+            if (!isAdmin.success) {
+                throw new Error(isAdmin.error ?? 'Unknown error occurred');
+            }
+            if (!isAdmin.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not FeeManager owner',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'setTotalFees',
+                args: [vault, newTotalFees],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async changeFeeWithdrawer(vault, feeIdentifier, newWithdrawer) {
+        try {
+            const isAdmin = await this.validateAdminPermission();
+            if (!isAdmin.success) {
+                throw new Error(isAdmin.error ?? 'Unknown error occurred');
+            }
+            if (!isAdmin.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not FeeManager owner',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'changeFeeWithdrawer',
+                args: [vault, feeIdentifier, newWithdrawer],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async withdrawFee(params) {
+        try {
+            const canWithdraw = await this.validateWithdrawerPermission(params.vault, params.feeIdentifier);
+            if (!canWithdraw.success) {
+                throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+            }
+            if (!canWithdraw.data) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'Caller is not authorized withdrawer',
+                };
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'withdrawFee',
+                args: [params.vault, params.feeIdentifier, params.amount0, params.amount1],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async withdrawMultipleFees(params) {
+        try {
+            if (params.feeIdentifiers.length !== params.amounts0.length ||
+                params.feeIdentifiers.length !== params.amounts1.length) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'feeIdentifiers, amounts0, and amounts1 must have the same length',
+                };
+            }
+            for (const feeIdentifier of params.feeIdentifiers) {
+                const canWithdraw = await this.validateWithdrawerPermission(params.vault, feeIdentifier);
+                if (!canWithdraw.success) {
+                    throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+                }
+                if (!canWithdraw.data) {
+                    return {
+                        data: null,
+                        status: 400,
+                        success: false,
+                        error: `Caller is not authorized withdrawer for ${feeIdentifier}`,
+                    };
+                }
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'withdrawMultipleFees',
+                args: [params.vault, params.feeIdentifiers, params.amounts0, params.amounts1],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async withdrawFeesFromMultipleVaults(params) {
+        try {
+            if (params.vaults.length !== params.feeIdentifiers.length ||
+                params.vaults.length !== params.amounts0.length ||
+                params.vaults.length !== params.amounts1.length) {
+                return {
+                    data: null,
+                    status: 400,
+                    success: false,
+                    error: 'vaults, feeIdentifiers, amounts0, and amounts1 must have the same length',
+                };
+            }
+            for (let i = 0; i < params.vaults.length; i++) {
+                const vault = params.vaults[i];
+                const identifiers = params.feeIdentifiers[i];
+                const amount0 = params.amounts0[i];
+                const amount1 = params.amounts1[i];
+                if (identifiers.length !== amount0.length || identifiers.length !== amount1.length) {
+                    return {
+                        data: null,
+                        status: 400,
+                        success: false,
+                        error: 'feeIdentifiers[i], amounts0[i], and amounts1[i] must have the same length',
+                    };
+                }
+                for (const feeIdentifier of identifiers) {
+                    const canWithdraw = await this.validateWithdrawerPermission(vault, feeIdentifier);
+                    if (!canWithdraw.success) {
+                        throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+                    }
+                    if (!canWithdraw.data) {
+                        return {
+                            data: null,
+                            status: 400,
+                            success: false,
+                            error: `Caller is not authorized withdrawer for ${feeIdentifier}`,
+                        };
+                    }
+                }
+            }
+            const accounts = await this.walletClient.getAddresses();
+            if (!accounts[0]) {
+                throw new Error('No account found');
+            }
+            const { request } = await this.publicClient.simulateContract({
+                address: this.feeManagerAddress,
+                abi: FEE_MANAGER_ABI,
+                functionName: 'withdrawFeesFromMultipleVaults',
+                args: [params.vaults, params.feeIdentifiers, params.amounts0, params.amounts1],
+                account: accounts[0],
+            });
+            const hash = await this.walletClient.writeContract(request);
+            return {
+                data: hash,
+                status: 200,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                status: 500,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}

package/dist/esm/base/PoolClient.js

@@ -448,4 +448,3 @@ export class PoolClient extends SubgraphClient {
         });
     }
 }
-//# sourceMappingURL=PoolClient.js.map

package/dist/esm/base/SmartRewardClient.js

@@ -48,4 +48,3 @@ export class SmartRewardsClient extends SmartRewards {
         super(apiClient, publicClient, walletClient);
     }
 }
-//# sourceMappingURL=SmartRewardClient.js.map

package/dist/esm/base/SmartRewards.js

@@ -553,4 +553,3 @@ export class SmartRewards {
         return getSubgraphUrlByChainId(chainId) !== undefined;
     }
 }
-//# sourceMappingURL=SmartRewards.js.map

package/dist/esm/base/StakingClient.js

@@ -656,4 +656,3 @@ export class StakingClient extends SubgraphClient {
         }
     }
 }
-//# sourceMappingURL=StakingClient.js.map

package/dist/esm/base/SubgraphClient.js

@@ -72,4 +72,3 @@ export class SubgraphClient {
         return getSubgraphUrlByChainId(chainId) !== undefined;
     }
 }
-//# sourceMappingURL=SubgraphClient.js.map

package/dist/esm/base/VaultClient.js

@@ -1245,4 +1245,3 @@ export class VaultClient extends SubgraphClient {
         }
     }
 }
-//# sourceMappingURL=VaultClient.js.map

package/dist/esm/base/vault/deposit/index.js

@@ -587,4 +587,3 @@ export class VaultDepositClient {
         }
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/esm/base/vault/deposit/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/base/vault/single-asset/calculateLimitPrice.js

@@ -221,4 +221,3 @@ export async function getPoolSlot0(publicClient, poolAddress, ammType) {
         };
     }
 }
-//# sourceMappingURL=calculateLimitPrice.js.map

package/dist/esm/base/vault/single-asset/calculateSwapAmount.js

@@ -62,4 +62,3 @@ export async function calculateSwapAmount(publicClient, params) {
         };
     }
 }
-//# sourceMappingURL=calculateSwapAmount.js.map

package/dist/esm/base/vault/single-asset/estimateLpTokens.js

@@ -347,4 +347,3 @@ export async function getVaultReserves(publicClient, vaultAddress) {
         };
     }
 }
-//# sourceMappingURL=estimateLpTokens.js.map

package/dist/esm/base/vault/single-asset/index.js

@@ -80,4 +80,3 @@ export { SingleAssetDepositClient } from './singleAssetDeposit.js';
  * });
  * ```
  */ 
-//# sourceMappingURL=index.js.map

package/dist/esm/base/vault/single-asset/simulateSwap.js

@@ -327,4 +327,3 @@ function validateSwapWithSlippageParams(params) {
         throw new Error('Pool fee must be greater than 0');
     }
 }
-//# sourceMappingURL=simulateSwap.js.map

package/dist/esm/base/vault/single-asset/singleAssetDeposit.js

@@ -348,4 +348,3 @@ export class SingleAssetDepositClient {
         }
     }
 }
-//# sourceMappingURL=singleAssetDeposit.js.map

package/dist/esm/base/vault/single-asset/types.js

@@ -10,4 +10,3 @@ export var AMMType;
     AMMType[AMMType["AlgebraIntegral"] = 4] = "AlgebraIntegral";
     AMMType[AMMType["Aerodrome"] = 5] = "Aerodrome";
 })(AMMType || (AMMType = {}));
-//# sourceMappingURL=types.js.map

package/dist/esm/base/vault/utils.js

@@ -571,4 +571,3 @@ export async function getPoolStateWithPrice(publicClient, params) {
         };
     }
 }
-//# sourceMappingURL=utils.js.map

package/dist/esm/base/vault/withdraw/index.js

@@ -150,4 +150,3 @@ export class VaultWithdrawClient {
         }
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/esm/base/vault/withdraw/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/client.js

@@ -119,4 +119,3 @@ export class SteerClient extends SubgraphClient {
         };
     }
 }
-//# sourceMappingURL=client.js.map