@dripfi/drip-sdk 1.4.28-slot-machine-4 → 1.4.29

package/dist/subpackages/SiloPackage.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const silo_sdk_1 = require("@dripfi/silo-sdk");
+class SiloPackage {
+    siloSdk;
+    constructor(signer) {
+        this.siloSdk = new silo_sdk_1.SiloSdk(signer);
+    }
+    async deposit(assetAmount, vaultAddress) {
+        try {
+            const tx = await this.siloSdk.contracts.deposit(assetAmount, vaultAddress);
+            return tx;
+        }
+        catch (error) {
+            console.error('Error depositing:', error);
+            throw error;
+        }
+    }
+    async withdraw(assetAmount, vaultAddress) {
+        try {
+            const tx = await this.siloSdk.contracts.withdraw(assetAmount, vaultAddress);
+            return tx;
+        }
+        catch (error) {
+            console.error('Error depositing:', error);
+            throw error;
+        }
+    }
+    async redeem(sharesAmount, vaultAddress) {
+        try {
+            const tx = await this.siloSdk.contracts.redeem(sharesAmount, vaultAddress);
+            return tx;
+        }
+        catch (error) {
+            console.error('Error depositing:', error);
+            throw error;
+        }
+    }
+    async getHistoricalTvl() {
+        console.log('getHistoricalTvl to be implemented');
+        return await this.siloSdk.getHistoricalTvl();
+    }
+    async getApy() {
+        console.log('getApy to be implemented');
+        return await this.siloSdk.getApy();
+    }
+    async getEarnedRewards() {
+        console.log('getEarnedRewards to be implemented');
+        return await this.siloSdk.getEarnedRewards();
+    }
+    async getBalanceInShares(vaultAddress) {
+        try {
+            const balance = await this.siloSdk.contracts.getBalance(vaultAddress);
+            return balance;
+        }
+        catch (error) {
+            console.error('Error getting balance:', error);
+            throw error;
+        }
+    }
+    async getBalanceInAssets(vaultAddress) {
+        try {
+            const balance = await this.siloSdk.contracts.getBalanceInAssets(vaultAddress);
+            return balance;
+        }
+        catch (error) {
+            console.error('Error getting balance:', error);
+            throw error;
+        }
+    }
+    async getTotalSupply(vaultAddress) {
+        try {
+            const totalSupply = await this.siloSdk.contracts.getTotalSupply(vaultAddress);
+            return totalSupply;
+        }
+        catch (error) {
+            console.error('Error getting totalSupply:', error);
+            throw error;
+        }
+    }
+    async getTotalAssets(vaultAddress) {
+        try {
+            const totalAssets = await this.siloSdk.contracts.getTotalAssets(vaultAddress);
+            return totalAssets;
+        }
+        catch (error) {
+            console.error('Error getting totalAssets:', error);
+            throw error;
+        }
+    }
+    async convertToShares(assetsAmount, vaultAddress) {
+        try {
+            const shares = await this.siloSdk.contracts.convertToShares(assetsAmount, vaultAddress);
+            return shares;
+        }
+        catch (error) {
+            console.error('Error converting to shares:', error);
+            throw error;
+        }
+    }
+    async convertToAssets(sharesAmount, vaultAddress) {
+        try {
+            const assets = await this.siloSdk.contracts.convertToAssets(sharesAmount, vaultAddress);
+            return assets;
+        }
+        catch (error) {
+            console.error('Error converting to assets:', error);
+            throw error;
+        }
+    }
+}
+exports.default = SiloPackage;

package/dist/subpackages/SiloVaultOperations.d.ts

@@ -0,0 +1,31 @@
+import PerqSdk from '../PerqSdk';
+import { VaultOperationParams } from '../types/VaultOperationParams';
+import { VaultOperations, WithdrawParams } from './VaultHandlerPackage';
+/**
+ * Silo SDK vault operations implementation
+ */
+export declare class SiloVaultOperations implements VaultOperations {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    deposit(params: VaultOperationParams): Promise<string>;
+    withdraw(params: WithdrawParams): Promise<string>;
+    getBalance(vaultAddress: string, tokenAddress: string): Promise<string>;
+    /**
+     * Handles Silo withdraw with automatic full/partial withdraw detection
+     */
+    private handleSiloWithdraw;
+    /**
+     * Handles a full withdraw from a Silo vault
+     */
+    private handleSiloFullWithdraw;
+    /**
+     * Handles a partial withdraw from a Silo vault
+     */
+    private handleSiloPartialWithdraw;
+    /**
+     * Extracts transaction hash from various transaction response formats
+     */
+    private extractTransactionHash;
+}

package/dist/subpackages/SiloVaultOperations.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiloVaultOperations = void 0;
+const ethers_1 = require("ethers");
+/**
+ * Silo SDK vault operations implementation
+ */
+class SiloVaultOperations {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getAllowance(params) {
+        const { sourceTokenAddress, vaultAddress, amount } = params;
+        console.log(`🚀 ~ silo getAllowance called with these params:`, { sourceTokenAddress, vaultAddress, amount });
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        try {
+            // For Silo, we use the standard ERC20 allowance
+            const allowance = await this.perqSdk.tokenUtils.getERC20TokenAllowance(vaultAddress, sourceTokenAddress);
+            console.log('🚀 ~ allowance:', allowance);
+            // Get required amount with correct decimals
+            const requiredAmount = await this.perqSdk.tokenUtils.parseAmountWithDecimals(amount, sourceTokenAddress);
+            console.log('🚀 ~ requiredAmount:', requiredAmount.toString());
+            return allowance.gte(requiredAmount);
+        }
+        catch (error) {
+            console.error('Error checking allowance:', error);
+            return false;
+        }
+    }
+    async approveAllowance(params) {
+        const { sourceTokenAddress, vaultAddress, amount } = params;
+        console.log(`🚀 ~ silo approveAllowance called with these params:`, { sourceTokenAddress, vaultAddress, amount });
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        // For Silo, we use the standard ERC20 approval
+        return await this.perqSdk.tokenUtils.approveAllowance(sourceTokenAddress, amount, vaultAddress);
+    }
+    async deposit(params) {
+        const { amount, vaultAddress, sourceTokenAddress } = params;
+        console.log(`🚀 ~ silo deposit called with these params:`, { amount, vaultAddress });
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        const parsedAmount = await this.perqSdk.tokenUtils.parseAmountWithDecimals(amount, sourceTokenAddress);
+        console.log('🚀 ~ parsedAmount:', parsedAmount.toString());
+        const tx = await this.perqSdk.siloPackage.deposit(parsedAmount.toString(), vaultAddress);
+        return this.extractTransactionHash(tx);
+    }
+    async withdraw(params) {
+        const { amount, vaultAddress, tokenAddress } = params;
+        console.log(`🚀 ~ silo withdraw called with these params:`, { amount, vaultAddress, tokenAddress });
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        const parsedAmount = await this.perqSdk.tokenUtils.parseAmountWithDecimals(amount, tokenAddress);
+        console.log('🚀 ~ parsedAmount:', parsedAmount.toString());
+        return await this.handleSiloWithdraw(tokenAddress, vaultAddress, parsedAmount.toString());
+    }
+    async getBalance(vaultAddress, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw new Error('Signer not initialized');
+        }
+        const balance = await this.perqSdk.siloPackage.getBalanceInAssets(vaultAddress);
+        console.log('🚀 ~ balance:', balance);
+        const formattedBalance = await this.perqSdk.tokenUtils.formatAmountWithDecimals(balance, tokenAddress);
+        console.log('🚀 ~ formattedBalance:', formattedBalance);
+        return formattedBalance;
+    }
+    /**
+     * Handles Silo withdraw with automatic full/partial withdraw detection
+     */
+    async handleSiloWithdraw(tokenAddress, vaultAddress, amount) {
+        console.log(`🚀 ~ silo handleSiloWithdraw called with these params:`, { tokenAddress, vaultAddress, amount });
+        let userBalance = ethers_1.BigNumber.from(0);
+        try {
+            userBalance = await this.perqSdk.siloPackage.getBalanceInAssets(vaultAddress);
+            console.log('🚀 ~ userBalance:', userBalance.toString());
+        }
+        catch (error) {
+            console.error('Error getting user balance for silo withdraw: ', error);
+        }
+        const withdrawAmount = ethers_1.BigNumber.from(amount);
+        try {
+            if (withdrawAmount.gte(userBalance)) {
+                return await this.handleSiloFullWithdraw(vaultAddress);
+            }
+            else {
+                return await this.handleSiloPartialWithdraw(vaultAddress, withdrawAmount);
+            }
+        }
+        catch (error) {
+            console.error('Error handling silo withdraw: ', error);
+            throw error;
+        }
+    }
+    /**
+     * Handles a full withdraw from a Silo vault
+     */
+    async handleSiloFullWithdraw(vaultAddress) {
+        const balanceInShares = await this.perqSdk.siloPackage.getBalanceInShares(vaultAddress);
+        console.log('🚀 ~ balanceInShares:', balanceInShares);
+        console.log('🚀 ~ perqSdk.siloPackage!.redeem:', { balanceInShares: balanceInShares.toString(), vaultAddress });
+        const tx = await this.perqSdk.siloPackage.redeem(balanceInShares.toString(), vaultAddress);
+        return this.extractTransactionHash(tx);
+    }
+    /**
+     * Handles a partial withdraw from a Silo vault
+     */
+    async handleSiloPartialWithdraw(vaultAddress, parsedWithdrawAmount) {
+        console.log('🚀 ~ perqSdk.siloPackage!.withdraw:', {
+            parsedWithdrawAmount: parsedWithdrawAmount.toString(),
+            vaultAddress,
+        });
+        const tx = await this.perqSdk.siloPackage.withdraw(parsedWithdrawAmount.toString(), vaultAddress);
+        return this.extractTransactionHash(tx);
+    }
+    /**
+     * Extracts transaction hash from various transaction response formats
+     */
+    extractTransactionHash(tx) {
+        console.log('🚀 ~ extractTransactionHash called with tx:', tx);
+        if (typeof tx === 'string') {
+            return tx;
+        }
+        if (tx?.hash) {
+            return tx.hash;
+        }
+        if (tx?.transactionHash) {
+            return tx.transactionHash;
+        }
+        throw new Error('Unable to extract transaction hash from response');
+    }
+}
+exports.SiloVaultOperations = SiloVaultOperations;

package/dist/subpackages/TokenUtilsPackage.d.ts

@@ -3,6 +3,20 @@ import PerqSdk from '../PerqSdk';
 export default class TokenUtilsPackage {
     private perqSdk;
     constructor(perqSdk: PerqSdk);
+    /**
+     * Helper method to parse amount with correct token decimals
+     * @param amount - The amount as a string
+     * @param tokenAddress - The token contract address
+     * @returns Promise<BigNumber> - The parsed amount with correct decimals
+     */
+    parseAmountWithDecimals(amount: string, tokenAddress: string): Promise<BigNumber>;
+    /**
+     * Helper method to format amount from token decimals to human-readable string
+     * @param amount - The amount as BigNumber with token decimals
+     * @param tokenAddress - The token contract address
+     * @returns Promise<string> - The formatted amount as human-readable string
+     */
+    formatAmountWithDecimals(amount: BigNumber, tokenAddress: string): Promise<string>;
     getTokenPrice(tokenName: string): Promise<number>;
     getAllowance(tokenAddress: string, spender: string): Promise<string>;
     approveAllowance(tokenAddress: string, amount: string, spenderAddress: string): Promise<string>;

package/dist/subpackages/TokenUtilsPackage.js

@@ -11,6 +11,34 @@ class TokenUtilsPackage {
     constructor(perqSdk) {
         this.perqSdk = perqSdk;
     }
+    /**
+     * Helper method to parse amount with correct token decimals
+     * @param amount - The amount as a string
+     * @param tokenAddress - The token contract address
+     * @returns Promise<BigNumber> - The parsed amount with correct decimals
+     */
+    async parseAmountWithDecimals(amount, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw new Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        return ethers_1.ethers.utils.parseUnits(amount, decimals);
+    }
+    /**
+     * Helper method to format amount from token decimals to human-readable string
+     * @param amount - The amount as BigNumber with token decimals
+     * @param tokenAddress - The token contract address
+     * @returns Promise<string> - The formatted amount as human-readable string
+     */
+    async formatAmountWithDecimals(amount, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw new Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        return ethers_1.ethers.utils.formatUnits(amount, decimals);
+    }
     async getTokenPrice(tokenName) {
         return this.perqSdk.perqApi.fetchTokenPrice(tokenName);
     }
@@ -27,8 +55,7 @@ class TokenUtilsPackage {
             throw Error('No signer provided');
         }
         const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
-        const decimals = await tokenContract.getPrecission();
-        const parsedAmount = ethers_1.ethers.utils.parseUnits(parseFloat(amount).toFixed(decimals), decimals);
+        const parsedAmount = await this.parseAmountWithDecimals(amount, tokenAddress);
         return await tokenContract.approveToken(spenderAddress, parsedAmount.toString());
     }
     async transferErc20Token(tokenAddress, amount, receiver) {
@@ -36,8 +63,8 @@ class TokenUtilsPackage {
             throw Error('No signer provided');
         }
         const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
-        const decimals = await tokenContract.getPrecission();
-        const txHash = await tokenContract.transfer(receiver, ethers_1.ethers.utils.parseUnits(amount, decimals).toString());
+        const parsedAmount = await this.parseAmountWithDecimals(amount, tokenAddress);
+        const txHash = await tokenContract.transfer(receiver, parsedAmount.toString());
         return txHash;
     }
     async wrapEther(amount, tokenAddress) {

package/dist/subpackages/VaultHandlerPackage.d.ts

@@ -0,0 +1,54 @@
+import PerqSdk from '../PerqSdk';
+import SdkType from '../types/SdkType';
+import { VaultOperationParams } from '../types/VaultOperationParams';
+export interface WithdrawParams {
+    amount: string;
+    sdkType: SdkType;
+    tokenAddress: string;
+    vaultAddress: string;
+    onChainProjectId?: number;
+}
+export interface GetBalanceParams {
+    sdkType: SdkType;
+    tokenAddress: string;
+    vaultAddress: string;
+    onChainProjectId?: number;
+}
+export interface VaultOperations {
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    deposit(params: VaultOperationParams): Promise<string>;
+    withdraw(params: WithdrawParams): Promise<string>;
+    getBalance(vaultAddress: string, tokenAddress?: string, onChainProjectId?: number): Promise<string>;
+}
+export default class VaultHandler {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    /**
+     * Get allowance for vault operations
+     * Returns true if the user has approved sufficient allowance for the specified amount
+     */
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    /**
+     * Approve allowance for vault operations
+     * Automatically determines the correct approval method based on deposit type
+     */
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    /**
+     * Deposit to vault
+     * Automatically determines the correct deposit method based on deposit type
+     */
+    deposit(params: VaultOperationParams): Promise<string>;
+    /**
+     * Withdraw from vault
+     */
+    withdraw(params: WithdrawParams): Promise<string>;
+    /**
+     * Get the balance of the vault
+     */
+    getBalance(params: GetBalanceParams): Promise<string>;
+    /**
+     * Get the appropriate SDK handler based on SDK type
+     */
+    private getSdkHandler;
+}

package/dist/subpackages/VaultHandlerPackage.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const YelayVaultOperations_1 = require("./YelayVaultOperations");
+const SiloVaultOperations_1 = require("./SiloVaultOperations");
+class VaultHandler {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    /**
+     * Get allowance for vault operations
+     * Returns true if the user has approved sufficient allowance for the specified amount
+     */
+    async getAllowance(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.getAllowance(params);
+        }
+        catch (error) {
+            console.error('Error getting allowance:', error);
+            throw error;
+        }
+    }
+    /**
+     * Approve allowance for vault operations
+     * Automatically determines the correct approval method based on deposit type
+     */
+    async approveAllowance(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.approveAllowance(params);
+        }
+        catch (error) {
+            console.error('Error approving allowance:', error);
+            throw error;
+        }
+    }
+    /**
+     * Deposit to vault
+     * Automatically determines the correct deposit method based on deposit type
+     */
+    async deposit(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.deposit(params);
+        }
+        catch (error) {
+            console.error('Error depositing to vault:', error);
+            throw error;
+        }
+    }
+    /**
+     * Withdraw from vault
+     */
+    async withdraw(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.withdraw(params);
+        }
+        catch (error) {
+            console.error('Error withdrawing from vault:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get the balance of the vault
+     */
+    async getBalance(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.getBalance(params.vaultAddress, params.tokenAddress, params.onChainProjectId);
+        }
+        catch (error) {
+            console.error('Error withdrawing from vault:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get the appropriate SDK handler based on SDK type
+     */
+    getSdkHandler(sdkType) {
+        switch (sdkType) {
+            case 'yelay':
+                return new YelayVaultOperations_1.YelayVaultOperations(this.perqSdk);
+            case 'silo':
+                return new SiloVaultOperations_1.SiloVaultOperations(this.perqSdk);
+            default:
+                throw new Error(`Unsupported SDK type: ${sdkType}`);
+        }
+    }
+}
+exports.default = VaultHandler;

package/dist/subpackages/YelayVaultOperations.d.ts

@@ -0,0 +1,13 @@
+import PerqSdk from '../PerqSdk';
+import { VaultOperationParams } from '../types/VaultOperationParams';
+import { VaultOperations, WithdrawParams } from './VaultHandlerPackage';
+export declare class YelayVaultOperations implements VaultOperations {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    deposit(params: VaultOperationParams): Promise<string>;
+    withdraw(params: WithdrawParams): Promise<string>;
+    getBalance(vaultAddress: string, _: string, onChainProjectId: number): Promise<string>;
+    private determineDepositType;
+}