@dripfi/drip-sdk 1.4.28-silo-sdk → 1.4.28-silo-sdk-2

package/README.md

@@ -54,6 +54,35 @@ const perqSdk = new PerqSdk(perqConfig, perqSupportedChainId, provider?: ethers.
 
 ## Modules
 
+### Automatic Deposit Type Detection
+
+The SDK automatically determines the deposit type based on the provided parameters:
+
+- **Direct Deposit**: When `sourceTokenSymbol` equals `vaultTokenSymbol`
+- **Wrap Deposit**: When `sourceTokenSymbol` is "ETH" / "S" or any other native token
+- **Swap Deposit**: When `sourceTokenSymbol` differs from `vaultTokenSymbol` only possible on certain `sdkType` vaults
+
+### Supported SDK Types
+
+- **Yelay**: Supports direct deposits, ETH deposits, and swap deposits
+- **Silo**: Supports standard ERC20 deposits and withdrawals
+
+### Vault Handler
+
+Access vault methods through `sdk.vault`:
+
+| Method | Description |
+| --- | --- |
+| `getAllowance(params: VaultOperationParams): Promise<boolean>` | Checks if the user's allowance is sufficient for the `depositAmount` |
+| `approveAllowance(params: VaultOperationParams): Promise<string>` | Approves the allowance for the `depositAmount` for the selected Vault |
+| `deposit(params: VaultOperationParams): Promise<string>` | Deposits the `depositAmount` into the selected `vault` |
+| `withdraw(params: VaultOperationParams): Promise<string>` | Withdraws the specified amount from the selected vault |
+| `getBalance(vaultAddress: string, tokenAddress?: string, onChainProjectId?: number): Promise<string>` | Gets the user's balance for the specified vault |
+
+## Legacy Methods
+
+For backward compatibility, the original methods are still available:
+
 ### Core SDK
 
 Core methods available directly on the SDK instance:
@@ -188,15 +217,6 @@ Access silo methods through `sdk.silo`:
 | `getTotalSupply(vaultAddress: string): Promise<BigNumber>`                          | Retrieves the total amounts of shares in the Vault.               |
 | `getTotalAssets(vaultAddress: string): string`                                      | Returns the total balance in the vaults currency/asset.           |
 
-### Vault Handler
-
-Access vault methods through `sdk.vault`:
-
-| Method                                                                                                                               | Description                                                     |
-| ------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------- |
-| `deposit(tokenAddress: string, vaultAddress: string, amount: string, sdkType: SdkType, onChainProjectId?: number): Promise<string>`  | Handles deposit into any Vault by determining which sdk to use. |
-| `withdraw(tokenAddress: string, vaultAddress: string, amount: string, sdkType: SdkType, onChainProjectId?: number): Promise<string>` | Withdraws from any Vault.                                       |
-
 ## Examples
 
 ### `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`
@@ -301,7 +321,7 @@ const vaultToWithdrawFrom = vaults[0];
 const txHash = await lite.withdraw(
 	vaultToWithdrawFrom.depositToken.tokenAddress,
 	vaultToWithdrawFrom.vaultAddress,
-	**vaultToWithdrawFrom**.onChainProjectId,
+	vaultToWithdrawFrom.onChainProjectId,
 	'3.55',
 );
 ```
@@ -394,6 +414,8 @@ type DepositToken = {
 	tokenAddress: string;
 };
 
+type DepositType = 'direct' | 'swap' | 'wrap';
+
 enum ELoyaltyCardTier {
 	White = 'White',
 	Ivory = 'Ivory',
@@ -404,6 +426,14 @@ enum ELoyaltyCardTier {
 	Black = 'Black',
 }
 
+interface IVaultOperations {
+	getAllowance(params: VaultOperationParams): Promise<boolean>;
+	approveAllowance(params: VaultOperationParams): Promise<string>;
+	deposit(params: VaultOperationParams): Promise<string>;
+	withdraw(params: VaultOperationParams): Promise<string>;
+	getBalance(vaultAddress: string, tokenAddress?: string, onChainProjectId?: number): Promise<string>;
+}
+
 type LoyaltyCard = {
 	id: string;
 	tier: ELoyaltyCardTier;
@@ -499,7 +529,7 @@ type QLFastRedeem = {
 	svtWithdrawn: string;
 };
 
-type SdkType = 'lite' | 'silo';
+type SdkType = 'yelay' | 'silo';
 
 type SpecialEditionLoyaltyCard = {
 	id: string;
@@ -619,6 +649,17 @@ type VaultStats = {
 
 type VaultType = 'launch' | 'earn' | 'airdrop';
 
+interface VaultOperationParams {
+	sourceTokenAddress: string;
+	vaultTokenAddress: string;
+	vaultAddress: string;
+	amount: string;
+	sdkType: SdkType;
+	onChainProjectId?: number;
+	sourceTokenSymbol?: string;
+	vaultTokenSymbol?: string;
+}
+
 type VestingInfo = {
 	startTimestamp: string;
 	endTimestamp: string;

package/dist/subpackages/SiloPackage.js

@@ -5,9 +5,6 @@ class SiloPackage {
     siloSdk;
     constructor(signer) {
         this.siloSdk = new silo_sdk_1.SiloSdk(signer);
-        console.log('Silo sdk constructed');
-        console.log('siloSdk.subgraph ', this.siloSdk.subgraph);
-        console.log('siloSdk.contracts ', this.siloSdk.contracts);
     }
     async deposit(assetAmount, vaultAddress) {
         try {

package/dist/subpackages/SiloVaultOperations.d.ts

@@ -0,0 +1,31 @@
+import PerqSdk from '../PerqSdk';
+import { VaultOperationParams } from '../types/VaultOperationParams';
+import { IVaultOperations } from './VaultHandlerPackage';
+/**
+ * Silo SDK vault operations implementation
+ */
+export declare class SiloVaultOperations implements IVaultOperations {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    deposit(params: VaultOperationParams): Promise<string>;
+    withdraw(params: VaultOperationParams): 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,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiloVaultOperations = void 0;
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+/**
+ * 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 token decimals for proper amount comparison
+            const tokenContract = new ERC20TokenContract_1.default(sourceTokenAddress, this.perqSdk.signer);
+            const decimals = await tokenContract.getPrecission();
+            const requiredAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+            console.log('🚀 ~ requiredAmount:', requiredAmount);
+            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 } = 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 tx = await this.perqSdk.siloPackage.deposit(amount, vaultAddress);
+        return this.extractTransactionHash(tx);
+    }
+    async withdraw(params) {
+        const { sourceTokenAddress, vaultAddress, amount } = params;
+        console.log(`🚀 ~ silo withdraw called with these params:`, { sourceTokenAddress, vaultAddress, amount });
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        return await this.handleSiloWithdraw(sourceTokenAddress, vaultAddress, amount);
+    }
+    async getBalance(vaultAddress, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw new Error('Signer not initialized');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const balance = await this.perqSdk.siloPackage.getBalanceInAssets(vaultAddress);
+        const formattedBalance = ethers_1.ethers.utils.formatUnits(balance, decimals);
+        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);
+        }
+        catch (error) {
+            console.error('Error getting user balance for silo withdraw: ', error);
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedWithdrawAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        try {
+            if (parsedWithdrawAmount.gte(userBalance)) {
+                return await this.handleSiloFullWithdraw(vaultAddress);
+            }
+            else {
+                return await this.handleSiloPartialWithdraw(vaultAddress, parsedWithdrawAmount);
+            }
+        }
+        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/VaultHandlerPackage.d.ts

@@ -1,37 +1,40 @@
 import PerqSdk from '../PerqSdk';
-import SdkType from '../types/SdkType';
+import { VaultOperationParams } from '../types/VaultOperationParams';
+export interface IVaultOperations {
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
+    deposit(params: VaultOperationParams): Promise<string>;
+    withdraw(params: VaultOperationParams): Promise<string>;
+    getBalance(vaultAddress: string, tokenAddress?: string, onChainProjectId?: number): Promise<string>;
+}
 export default class VaultHandler {
     private perqSdk;
     constructor(perqSdk: PerqSdk);
-    deposit(tokenAddress: string, vaultAddress: string, amount: string, sdkType: SdkType, onChainProjectId?: number): Promise<string>;
-    withdraw(tokenAddress: string, vaultAddress: string, amount: string, sdkType: SdkType, onChainProjectId?: number): Promise<string>;
-    /**
-     * Centralized method to execute vault operations based on SDK type
-     * This makes it easy to add new SDK types in the future
-     */
-    private executeVaultOperation;
     /**
-     * Handles Yelay Lite vault operations
+     * Get allowance for vault operations
+     * Returns true if the user has approved sufficient allowance for the specified amount
      */
-    private handleYelayLiteOperation;
+    getAllowance(params: VaultOperationParams): Promise<boolean>;
     /**
-     * Handles Silo vault operations
+     * Approve allowance for vault operations
+     * Automatically determines the correct approval method based on deposit type
      */
-    private handleSiloOperation;
+    approveAllowance(params: VaultOperationParams): Promise<string>;
     /**
-     * Handles Silo withdraw with automatic full/partial withdraw detection
+     * Deposit to vault
+     * Automatically determines the correct deposit method based on deposit type
      */
-    private handleSiloWithdraw;
+    deposit(params: VaultOperationParams): Promise<string>;
     /**
-     * Handles a full withdraw from a Silo vault
+     * Withdraw from vault
      */
-    private handleSiloFullWithdraw;
+    withdraw(params: VaultOperationParams): Promise<string>;
     /**
-     * Handles a partial withdraw from a Silo vault
+     * Get the balance of the vault
      */
-    private handleSiloPartialWithdraw;
+    getBalance(params: VaultOperationParams): Promise<string>;
     /**
-     * Extracts transaction hash from various transaction response formats
+     * Get the appropriate SDK handler based on SDK type
      */
-    private extractTransactionHash;
+    private getSdkHandler;
 }

package/dist/subpackages/VaultHandlerPackage.js

@@ -1,154 +1,107 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+const YelayVaultOperations_1 = require("./YelayVaultOperations");
+const SiloVaultOperations_1 = require("./SiloVaultOperations");
 class VaultHandler {
     perqSdk;
     constructor(perqSdk) {
         this.perqSdk = perqSdk;
     }
-    async deposit(tokenAddress, vaultAddress, amount, sdkType, onChainProjectId) {
+    /**
+     * 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 {
-            return await this.executeVaultOperation('deposit', {
-                tokenAddress,
-                vaultAddress,
-                amount,
-                sdkType,
-                onChainProjectId,
-            });
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.getAllowance(params);
         }
         catch (error) {
-            console.error('Error depositing to vault:', error);
+            console.error('Error getting allowance:', error);
             throw error;
         }
     }
-    async withdraw(tokenAddress, vaultAddress, amount, sdkType, onChainProjectId) {
+    /**
+     * 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 {
-            return await this.executeVaultOperation('withdraw', {
-                tokenAddress,
-                vaultAddress,
-                amount,
-                sdkType,
-                onChainProjectId,
-            });
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.approveAllowance(params);
         }
         catch (error) {
-            console.error('Error withdrawing from vault:', error);
+            console.error('Error approving allowance:', error);
             throw error;
         }
     }
     /**
-     * Centralized method to execute vault operations based on SDK type
-     * This makes it easy to add new SDK types in the future
+     * Deposit to vault
+     * Automatically determines the correct deposit method based on deposit type
      */
-    async executeVaultOperation(operation, params) {
-        const { tokenAddress, vaultAddress, amount, sdkType, onChainProjectId } = params;
-        switch (sdkType) {
-            case 'lite':
-                return this.handleYelayLiteOperation(operation, tokenAddress, vaultAddress, amount, onChainProjectId);
-            case 'silo':
-                return this.handleSiloOperation(operation, tokenAddress, vaultAddress, amount);
-            default:
-                throw new Error(`Unsupported SDK type: ${sdkType}`);
-        }
-    }
-    /**
-     * Handles Yelay Lite vault operations
-     */
-    async handleYelayLiteOperation(operation, tokenAddress, vaultAddress, amount, onChainProjectId) {
-        if (!onChainProjectId || onChainProjectId === -1) {
-            throw new Error('OnChainProjectId is required for Lite vaults');
+    async deposit(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
         }
-        if (operation === 'deposit') {
-            return await this.perqSdk.lite.deposit(tokenAddress, vaultAddress, onChainProjectId, amount);
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.deposit(params);
         }
-        else {
-            return await this.perqSdk.lite.withdraw(tokenAddress, vaultAddress, onChainProjectId, amount);
+        catch (error) {
+            console.error('Error depositing to vault:', error);
+            throw error;
         }
     }
     /**
-     * Handles Silo vault operations
+     * Withdraw from vault
      */
-    async handleSiloOperation(operation, tokenAddress, vaultAddress, amount) {
-        if (!this.perqSdk.siloPackage) {
-            throw new Error('Silo package not initialized. Please provide a signer.');
+    async withdraw(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
         }
-        if (operation === 'deposit') {
-            const tx = await this.perqSdk.siloPackage.deposit(amount, vaultAddress);
-            return this.extractTransactionHash(tx);
+        try {
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.withdraw(params);
         }
-        else {
-            return await this.handleSiloWithdraw(tokenAddress, vaultAddress, amount);
+        catch (error) {
+            console.error('Error withdrawing from vault:', error);
+            throw error;
         }
     }
     /**
-     * Handles Silo withdraw with automatic full/partial withdraw detection
+     * Get the balance of the vault
      */
-    async handleSiloWithdraw(tokenAddress, vaultAddress, amount) {
-        if (!this.perqSdk.siloPackage) {
-            throw new Error('Silo package not initialized. Please provide a signer.');
-        }
-        let userBalance = ethers_1.BigNumber.from(0);
-        try {
-            userBalance = await this.perqSdk.siloPackage.getBalanceInAssets(vaultAddress);
-        }
-        catch (error) {
-            console.error('Error getting user balance for silo withdraw: ', error);
+    async getBalance(params) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
         }
-        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
-        const decimals = await tokenContract.getPrecission();
-        const parsedWithdrawAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
         try {
-            if (parsedWithdrawAmount.gte(userBalance)) {
-                return await this.handleSiloFullWithdraw(vaultAddress);
-            }
-            else {
-                return await this.handleSiloPartialWithdraw(vaultAddress, parsedWithdrawAmount);
-            }
+            const sdkHandler = this.getSdkHandler(params.sdkType);
+            return await sdkHandler.getBalance(params.vaultAddress, params.vaultTokenAddress, params.onChainProjectId);
         }
         catch (error) {
-            console.error('Error handling silo withdraw: ', error);
+            console.error('Error withdrawing from vault:', error);
             throw error;
         }
     }
     /**
-     * Handles a full withdraw from a Silo vault
-     */
-    async handleSiloFullWithdraw(vaultAddress) {
-        const balanceInShares = await this.perqSdk.siloPackage.getBalanceInShares(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) {
-        const tx = await this.perqSdk.siloPackage.withdraw(parsedWithdrawAmount.toString(), vaultAddress);
-        return this.extractTransactionHash(tx);
-    }
-    /**
-     * Extracts transaction hash from various transaction response formats
+     * Get the appropriate SDK handler based on SDK type
      */
-    extractTransactionHash(tx) {
-        if (typeof tx === 'string') {
-            return tx;
-        }
-        if (tx?.hash) {
-            return tx.hash;
-        }
-        if (tx?.transactionHash) {
-            return tx.transactionHash;
+    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}`);
         }
-        throw new Error('Unable to extract transaction hash from response');
     }
 }
 exports.default = VaultHandler;

package/dist/subpackages/YelayVaultOperations.d.ts

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

package/dist/subpackages/YelayVaultOperations.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YelayVaultOperations = void 0;
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+class YelayVaultOperations {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getAllowance(params) {
+        const { sourceTokenAddress, vaultAddress, onChainProjectId, amount } = params;
+        console.log(`🚀 ~ yelay getAllowance with these params: `, {
+            sourceTokenAddress,
+            vaultAddress,
+            onChainProjectId,
+            amount,
+        });
+        if (!onChainProjectId || onChainProjectId === -1) {
+            throw new Error('OnChainProjectId is required for Yelay vaults');
+        }
+        const depositType = this.determineDepositType(params);
+        console.log('🚀 ~ depositType: ', depositType);
+        try {
+            let allowance;
+            switch (depositType) {
+                case 'direct': {
+                    allowance = await this.perqSdk.tokenUtils.getERC20TokenAllowance(vaultAddress, sourceTokenAddress);
+                    console.log('🚀 ~ direct deposit allowance: ', allowance);
+                    break;
+                }
+                case 'swap': {
+                    const allowanceString = await this.perqSdk.lite.getSwapAndDepositAllowance(sourceTokenAddress);
+                    allowance = ethers_1.BigNumber.from(allowanceString);
+                    console.log('🚀 ~ swapAndDeposit allowance: ', allowance);
+                    break;
+                }
+                case 'wrap': {
+                    return true;
+                }
+                default:
+                    throw new Error(`Unsupported deposit type: ${depositType}`);
+            }
+            // Get token decimals for proper amount comparison
+            const tokenContract = new ERC20TokenContract_1.default(sourceTokenAddress, this.perqSdk.signer);
+            const decimals = await tokenContract.getPrecission();
+            const requiredAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+            return allowance.gte(requiredAmount);
+        }
+        catch (error) {
+            console.error('Error checking allowance:', error);
+            return false;
+        }
+    }
+    async approveAllowance(params) {
+        const { sourceTokenAddress, vaultAddress, amount, onChainProjectId } = params;
+        console.log(`🚀 ~ yelay approveAllowance called with these params:`, {
+            sourceTokenAddress,
+            vaultAddress,
+            amount,
+            onChainProjectId,
+        });
+        if (!onChainProjectId || onChainProjectId === -1) {
+            throw new Error('OnChainProjectId is required for Yelay vaults');
+        }
+        const depositType = this.determineDepositType(params);
+        switch (depositType) {
+            case 'direct':
+                return await this.perqSdk.tokenUtils.approveAllowance(sourceTokenAddress, amount, vaultAddress);
+            case 'wrap':
+                throw new Error("Can't approve a native token");
+            case 'swap':
+                return await this.perqSdk.lite.approveSwapAndDeposit(sourceTokenAddress, amount);
+            default:
+                throw new Error(`Unsupported deposit type: ${depositType}`);
+        }
+    }
+    async deposit(params) {
+        const { sourceTokenAddress, vaultTokenAddress, vaultAddress, amount, onChainProjectId } = params;
+        console.log(`🚀 ~ yelay deposit called with these params: `, {
+            sourceTokenAddress,
+            vaultTokenAddress,
+            vaultAddress,
+            amount,
+            onChainProjectId,
+        });
+        if (!onChainProjectId || onChainProjectId === -1) {
+            throw new Error('OnChainProjectId is required for Yelay vaults');
+        }
+        const depositType = this.determineDepositType(params);
+        switch (depositType) {
+            case 'direct':
+                console.log('🚀 ~ this.perqSdk.lite.deposit called', {
+                    sourceTokenAddress,
+                    vaultAddress,
+                    onChainProjectId,
+                    amount,
+                });
+                return await this.perqSdk.lite.deposit(sourceTokenAddress, vaultAddress, onChainProjectId, amount);
+            case 'wrap':
+                console.log('🚀 ~ this.perqSdk.lite.wrapAndDepositEth called', {
+                    vaultAddress,
+                    onChainProjectId,
+                    amount,
+                });
+                return await this.perqSdk.lite.wrapAndDepositEth(vaultAddress, onChainProjectId, amount);
+            case 'swap':
+                console.log('🚀 ~ this.perqSdk.lite.swapAndDeposit called', {
+                    sourceTokenAddress,
+                    vaultTokenAddress,
+                    amount,
+                    vaultAddress,
+                    onChainProjectId,
+                });
+                return await this.perqSdk.lite.swapAndDeposit(sourceTokenAddress, vaultTokenAddress, amount, vaultAddress, onChainProjectId);
+            default:
+                throw new Error(`Unsupported deposit type: ${depositType}`);
+        }
+    }
+    async withdraw(params) {
+        const { sourceTokenAddress, vaultAddress, amount, onChainProjectId } = params;
+        console.log(`🚀 ~ yelay withdraw called with these params: `, {
+            sourceTokenAddress,
+            vaultAddress,
+            amount,
+            onChainProjectId,
+        });
+        if (!onChainProjectId || onChainProjectId === -1) {
+            throw new Error('OnChainProjectId is required for Yelay vaults');
+        }
+        console.log('🚀 ~ this.perqSdk.lite.withdraw called', {
+            sourceTokenAddress,
+            vaultAddress,
+            onChainProjectId,
+            amount,
+        });
+        return await this.perqSdk.lite.withdraw(sourceTokenAddress, vaultAddress, onChainProjectId, amount);
+    }
+    async getBalance(vaultAddress, tokenAddress, onChainProjectId) {
+        return await this.perqSdk.pools.getUserPoolBalance(vaultAddress, onChainProjectId);
+    }
+    determineDepositType(params) {
+        const { sourceTokenSymbol, vaultTokenSymbol } = params;
+        if (!sourceTokenSymbol || !vaultTokenSymbol) {
+            return 'direct';
+        }
+        const lowerSourceToken = sourceTokenSymbol.toLowerCase();
+        const lowerVaultToken = vaultTokenSymbol.toLowerCase();
+        // Check if it's ETH wrap deposit
+        if (lowerSourceToken === 'eth' || lowerSourceToken === 's') {
+            return 'wrap';
+        }
+        // Check if it's a direct deposit (same token)
+        if (lowerSourceToken === lowerVaultToken) {
+            return 'direct';
+        }
+        // Otherwise it's a swap deposit
+        return 'swap';
+    }
+}
+exports.YelayVaultOperations = YelayVaultOperations;

package/dist/types/SdkType.d.ts

@@ -1,2 +1,2 @@
-type SdkType = 'lite' | 'silo';
+type SdkType = 'yelay' | 'silo';
 export default SdkType;

package/dist/types/VaultOperationParams.d.ts

@@ -0,0 +1,12 @@
+import SdkType from './SdkType';
+export interface VaultOperationParams {
+    sourceTokenAddress: string;
+    vaultTokenAddress: string;
+    vaultAddress: string;
+    amount: string;
+    sdkType: SdkType;
+    onChainProjectId?: number;
+    sourceTokenSymbol?: string;
+    vaultTokenSymbol?: string;
+}
+export type DepositType = 'direct' | 'swap' | 'wrap';

package/dist/types/VaultOperationParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -25,9 +25,10 @@ import VaultData from './VaultData';
 import VaultReward, { RewardType } from './VaultReward';
 import VaultStats from './VaultStats';
 import VaultType from './VaultType';
+import { VaultOperationParams, DepositType } from './VaultOperationParams';
 import VestingInfo from './VestingInfo';
 import YelayVersion from './YelayVersion';
 import Earnings from './Earnings';
 import LinkedPodWallets from './LinkedPodWallets';
 import MigrationOption from './MigrationOption';
-export { Asset, BasePayload, BeanEntry, BeansBalance, DeployedProject, DeployedVault, DepositToken, DetailedProjectData, ELoyaltyCardTier, NearWalletPayload, SuiWalletPayload, LinkedPodWallets, LoyaltyCard, MigrationOption, MyPerqData, NFTBoost, NonceEnrichedPayload, NonceEnrichedSignedPayload, PerqConfig, PerqToBeansSwapInfo, ProjectBacker, QLFastRedeem, ReducedProjectData, RewardType, SpecialEditionLoyaltyCard, Strategy, StretchGoal, SwapInfo, UpgradeLoyaltyCardPayload, UserRewards, VaultData, VaultReward, VaultStats, VaultType, VestingInfo, YelayVersion, Earnings, };
+export { Asset, BasePayload, BeanEntry, BeansBalance, DeployedProject, DeployedVault, DepositToken, DetailedProjectData, ELoyaltyCardTier, NearWalletPayload, SuiWalletPayload, LinkedPodWallets, LoyaltyCard, MigrationOption, MyPerqData, NFTBoost, NonceEnrichedPayload, NonceEnrichedSignedPayload, PerqConfig, PerqToBeansSwapInfo, ProjectBacker, QLFastRedeem, ReducedProjectData, RewardType, SpecialEditionLoyaltyCard, Strategy, StretchGoal, SwapInfo, UpgradeLoyaltyCardPayload, UserRewards, VaultData, VaultReward, VaultStats, VaultType, VaultOperationParams, DepositType, VestingInfo, YelayVersion, Earnings, };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dripfi/drip-sdk",
-	"version": "1.4.28-silo-sdk",
+	"version": "1.4.28-silo-sdk-2",
 	"description": "Drip SDK",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",