@dripfi/drip-sdk 1.4.28-bridge-perq-1 → 1.4.28-silo-sdk

package/dist/contracts/{PerqTokenContract.d.ts → perq/PerqTokenContract.d.ts}

@@ -1,6 +1,6 @@
 import { BigNumber, ContractTransaction, ethers } from 'ethers';
-import BasePerqContract from './BasePerqContract';
-export default class PerqTokenContract extends BasePerqContract {
+import BaseContract from '../BaseContract';
+export default class PerqTokenContract extends BaseContract {
     constructor(address: string, signer?: ethers.Signer);
     getAllowance(spender: string): Promise<BigNumber>;
     approve(spender: string, amount: BigNumber): Promise<ContractTransaction>;

package/dist/contracts/{PerqTokenContract.js → perq/PerqTokenContract.js}

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-const PerqTokenAbi_json_1 = __importDefault(require("../abi/PerqTokenAbi.json"));
-const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
-class PerqTokenContract extends BasePerqContract_1.default {
+const PerqTokenAbi_json_1 = __importDefault(require("../../abi/perq/PerqTokenAbi.json"));
+const BaseContract_1 = __importDefault(require("../BaseContract"));
+class PerqTokenContract extends BaseContract_1.default {
     constructor(address, signer) {
         super(address, new ethers_1.ethers.utils.Interface(PerqTokenAbi_json_1.default), signer);
     }

package/dist/contracts/{PerqTokenRecyclerContract.d.ts → perq/PerqTokenRecyclerContract.d.ts}

@@ -1,7 +1,7 @@
 import { ContractTransaction } from 'ethers';
-import BasePerqContract from './BasePerqContract';
-import PerqSdk from '../PerqSdk';
-export default class PerqTokenRecyclerContract extends BasePerqContract {
+import BaseContract from '../BaseContract';
+import PerqSdk from '../../PerqSdk';
+export default class PerqTokenRecyclerContract extends BaseContract {
     constructor(perqSdk: PerqSdk);
     recycle(amountToRecycle: string, beneficiary: string | undefined, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
 }

package/dist/contracts/{PerqTokenRecyclerContract.js → perq/PerqTokenRecyclerContract.js}

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-const TokenRecyclerAbi_json_1 = __importDefault(require("../abi/TokenRecyclerAbi.json"));
-const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
-class PerqTokenRecyclerContract extends BasePerqContract_1.default {
+const TokenRecyclerAbi_json_1 = __importDefault(require("../../abi/perq/TokenRecyclerAbi.json"));
+const BaseContract_1 = __importDefault(require("../BaseContract"));
+class PerqTokenRecyclerContract extends BaseContract_1.default {
     constructor(perqSdk) {
         super(perqSdk.perqConfig.perqTokenRecyclerAddress, new ethers_1.ethers.utils.Interface(TokenRecyclerAbi_json_1.default), perqSdk.signer);
     }

package/dist/contracts/{PerqVestingContract.d.ts → perq/PerqVestingContract.d.ts}

@@ -1,7 +1,7 @@
 import { BigNumber, ContractTransaction } from 'ethers';
-import BasePerqContract from './BasePerqContract';
-import PerqSdk from '../PerqSdk';
-export default class PerqVestingContract extends BasePerqContract {
+import BaseContract from '../BaseContract';
+import PerqSdk from '../../PerqSdk';
+export default class PerqVestingContract extends BaseContract {
     constructor(perqSdk: PerqSdk);
     start(): Promise<BigNumber>;
     end(): Promise<BigNumber>;

package/dist/contracts/{PerqVestingContract.js → perq/PerqVestingContract.js}

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-const PerqVestingAbi_json_1 = __importDefault(require("../abi/PerqVestingAbi.json"));
-const BasePerqContract_1 = __importDefault(require("./BasePerqContract"));
-class PerqVestingContract extends BasePerqContract_1.default {
+const PerqVestingAbi_json_1 = __importDefault(require("../../abi/perq/PerqVestingAbi.json"));
+const BaseContract_1 = __importDefault(require("../BaseContract"));
+class PerqVestingContract extends BaseContract_1.default {
     constructor(perqSdk) {
         super(perqSdk.perqConfig.perqVestingAddress, new ethers_1.ethers.utils.Interface(PerqVestingAbi_json_1.default), perqSdk.signer);
     }

package/dist/subpackages/SiloPackage.d.ts

@@ -0,0 +1,18 @@
+import { BigNumber, Signer } from 'ethers';
+import { SiloSdk } from '@dripfi/silo-sdk';
+export default class SiloPackage {
+    siloSdk: SiloSdk;
+    constructor(signer: Signer);
+    deposit(assetAmount: string, vaultAddress: string): Promise<string | undefined>;
+    withdraw(assetAmount: string, vaultAddress: string): Promise<string | undefined>;
+    redeem(sharesAmount: string, vaultAddress: string): Promise<string | undefined>;
+    getHistoricalTvl(): Promise<any>;
+    getApy(): Promise<any>;
+    getEarnedRewards(): Promise<any>;
+    getBalanceInShares(vaultAddress: string): Promise<BigNumber>;
+    getBalanceInAssets(vaultAddress: string): Promise<BigNumber>;
+    getTotalSupply(vaultAddress: string): Promise<BigNumber>;
+    getTotalAssets(vaultAddress: string): Promise<BigNumber>;
+    private convertToShares;
+    private convertToAssets;
+}

package/dist/subpackages/SiloPackage.js

@@ -0,0 +1,115 @@
+"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);
+        console.log('Silo sdk constructed');
+        console.log('siloSdk.subgraph ', this.siloSdk.subgraph);
+        console.log('siloSdk.contracts ', this.siloSdk.contracts);
+    }
+    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/VaultHandlerPackage.d.ts

@@ -0,0 +1,37 @@
+import PerqSdk from '../PerqSdk';
+import SdkType from '../types/SdkType';
+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
+     */
+    private handleYelayLiteOperation;
+    /**
+     * Handles Silo vault operations
+     */
+    private handleSiloOperation;
+    /**
+     * 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/VaultHandlerPackage.js

@@ -0,0 +1,154 @@
+"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"));
+class VaultHandler {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async deposit(tokenAddress, vaultAddress, amount, sdkType, onChainProjectId) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            return await this.executeVaultOperation('deposit', {
+                tokenAddress,
+                vaultAddress,
+                amount,
+                sdkType,
+                onChainProjectId,
+            });
+        }
+        catch (error) {
+            console.error('Error depositing to vault:', error);
+            throw error;
+        }
+    }
+    async withdraw(tokenAddress, vaultAddress, amount, sdkType, onChainProjectId) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        try {
+            return await this.executeVaultOperation('withdraw', {
+                tokenAddress,
+                vaultAddress,
+                amount,
+                sdkType,
+                onChainProjectId,
+            });
+        }
+        catch (error) {
+            console.error('Error withdrawing from vault:', 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
+     */
+    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');
+        }
+        if (operation === 'deposit') {
+            return await this.perqSdk.lite.deposit(tokenAddress, vaultAddress, onChainProjectId, amount);
+        }
+        else {
+            return await this.perqSdk.lite.withdraw(tokenAddress, vaultAddress, onChainProjectId, amount);
+        }
+    }
+    /**
+     * Handles Silo vault operations
+     */
+    async handleSiloOperation(operation, tokenAddress, vaultAddress, amount) {
+        if (!this.perqSdk.siloPackage) {
+            throw new Error('Silo package not initialized. Please provide a signer.');
+        }
+        if (operation === 'deposit') {
+            const tx = await this.perqSdk.siloPackage.deposit(amount, vaultAddress);
+            return this.extractTransactionHash(tx);
+        }
+        else {
+            return await this.handleSiloWithdraw(tokenAddress, vaultAddress, amount);
+        }
+    }
+    /**
+     * Handles Silo withdraw with automatic full/partial withdraw detection
+     */
+    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);
+        }
+        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);
+        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
+     */
+    extractTransactionHash(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.default = VaultHandler;

package/dist/types/DeployedProject.d.ts

@@ -43,6 +43,7 @@ type DeployedProject = {
     liveFrom: string;
     distributionType: string;
     isHidden: boolean;
+    siloVaults: string[];
 };
 export default DeployedProject;
 export type ProjectBacker = {

package/dist/types/PerqConfig.d.ts

@@ -9,8 +9,6 @@ type PerqConfig = {
     swapAndDepositContractAddress: string;
     ethereumSwapperAddress: string;
     smartVaultManagerContractAddress: string;
-    bridgeMainnetPerqToSonicAddress: string;
-    bridgeSonicPerqToMainnetAddress: string;
 };
 export default PerqConfig;
 export declare const PRODUCTION: PerqConfig;

package/dist/types/PerqConfig.js

@@ -12,8 +12,6 @@ exports.PRODUCTION = {
     swapAndDepositContractAddress: '0xd8534197bd587f8226d12e0c864ef2cae6f82f5c',
     ethereumSwapperAddress: '0x33e52c206d584550193e642c8982f2fff6339994',
     smartVaultManagerContractAddress: '0x23daf34e2b9af02a74dc19cb52af727b19403874',
-    bridgeMainnetPerqToSonicAddress: '0x26c352304909CC7e59EEeD39242Eb7AFbC706Ad3',
-    bridgeSonicPerqToMainnetAddress: '0x26c352304909CC7e59EEeD39242Eb7AFbC706Ad3',
 };
 exports.DEVELOPMENT = {
     route: 'https://dev.perq.finance',
@@ -24,6 +22,4 @@ exports.DEVELOPMENT = {
     swapAndDepositContractAddress: '0x5fb08e00de169f041711206a0995410884080177',
     ethereumSwapperAddress: '0xe411921ee9eedfefd7b9ae15bf232bd36949fcbbc',
     smartVaultManagerContractAddress: '0x2638d6c0b4ef6dee04050fa0b07ca62500435747',
-    bridgeMainnetPerqToSonicAddress: '0x26c352304909CC7e59EEeD39242Eb7AFbC706Ad3',
-    bridgeSonicPerqToMainnetAddress: '0x26c352304909CC7e59EEeD39242Eb7AFbC706Ad3',
 };

package/dist/types/SdkType.d.ts

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

package/dist/types/VaultData.d.ts

@@ -1,5 +1,6 @@
 import { ChainId } from './ChainId';
 import DepositToken from './DepositToken';
+import SdkType from './SdkType';
 import Strategy from './Strategy';
 import StretchGoal from './StretchGoal';
 import VaultReward from './VaultReward';
@@ -26,5 +27,6 @@ type VaultData = {
     stretchGoals: StretchGoal[];
     rewards: VaultReward[];
     rewardTooltipName: string;
+    sdkType: SdkType;
 };
 export default VaultData;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dripfi/drip-sdk",
-	"version": "1.4.28-bridge-perq-1",
+	"version": "1.4.28-silo-sdk",
 	"description": "Drip SDK",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -13,6 +13,7 @@
 		"pretty": "prettier --write \"./**/*.{js,jsx,mjs,cjs,ts,tsx,json}\""
 	},
 	"dependencies": {
+		"@dripfi/silo-sdk": "^0.0.1",
 		"@yelay-lite/sdk": "1.0.7",
 		"ethers": "^5.7.2"
 	},