@strkfarm/sdk 1.0.55 → 1.0.57

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 import BigNumber from 'bignumber.js';
 import * as starknet from 'starknet';
-import { RpcProvider, BlockIdentifier, Contract, Uint256, Call, Account } from 'starknet';
+import { RpcProvider, BlockIdentifier, Contract, Uint256, Call, Account, CairoCustomEnum, RawArgs } from 'starknet';
 import React, { ReactNode } from 'react';
 import { Quote } from '@avnu/avnu-sdk';
+import { HexString, BytesLike } from '@ericnordelo/strk-merkle-tree/dist/bytes';
+import { MultiProof } from '@ericnordelo/strk-merkle-tree/dist/core';
+import { MerkleTreeImpl, MerkleTreeData } from '@ericnordelo/strk-merkle-tree/dist/merkletree';
+import { MerkleTreeOptions } from '@ericnordelo/strk-merkle-tree/dist/options';
+import { ValueType } from '@ericnordelo/strk-merkle-tree/dist/serde';
 import TelegramBot from 'node-telegram-bot-api';
 
 declare class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
@@ -40,6 +45,7 @@ declare class ContractAddr {
     static standardise(address: string | bigint): string;
     static eqString(a: string, b: string): boolean;
     toString(): string;
+    toBigInt(): bigint;
 }
 
 declare enum RiskType {
@@ -67,6 +73,7 @@ interface TokenInfo {
     logo: string;
     coingeckId?: string;
     displayDecimals: number;
+    priceCheckAmount?: number;
 }
 declare enum Network {
     mainnet = "mainnet",
@@ -137,7 +144,7 @@ interface IInvestmentFlow {
     linkedFlows: IInvestmentFlow[];
     style?: any;
 }
-declare function getMainnetConfig(rpcUrl: string, blockIdentifier?: BlockIdentifier): IConfig;
+declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
 declare const getRiskExplaination: (riskType: RiskType) => "The risk of the market moving against the position." | "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them." | "The risk of losing funds due to the position being liquidated." | "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position." | "The risk of the oracle being manipulated or incorrect." | "The risk of the smart contract being vulnerable to attacks." | "The risk of technical issues e.g. backend failure." | "The risk of the counterparty defaulting e.g. bad debt on lending platforms." | "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
 declare const getRiskColor: (risk: RiskFactor) => "light_green_2" | "yellow" | "red";
 declare const getNoRiskTags: (risks: RiskFactor[]) => RiskType[];
@@ -146,6 +153,15 @@ interface HighlightLink {
     link: string;
 }
 declare function highlightTextWithLinks(put: string, highlights: HighlightLink[]): ReactNode;
+interface VaultPosition {
+    amount: Web3Number;
+    usdValue: number;
+    token: TokenInfo;
+    remarks: string;
+}
+declare const Protocols: {
+    VESU: IProtocol;
+};
 
 interface ILendingMetadata {
     name: string;
@@ -320,12 +336,19 @@ declare class FatalError extends Error {
  * - fatalError: Things to do when a fatal error occurs
  */
 declare class Global {
+    static cache: Record<string, {
+        value: any;
+        ttl: number;
+        timestamp: number;
+    }>;
     static fatalError(message: string, err?: Error): void;
     static httpError(url: string, err: Error, message?: string): void;
     static getDefaultTokens(): TokenInfo[];
     static getTokens(): Promise<TokenInfo[]>;
     static assert(condition: any, message: string): void;
     static getTokenInfoFromAddr(addr: ContractAddr): Promise<TokenInfo>;
+    static setGlobalCache(key: string, data: any, ttl?: number): void;
+    static getGlobalCache<T>(key: string): T | null;
 }
 
 declare class AutoCompounderSTRK {
@@ -357,6 +380,18 @@ declare class AutoCompounderSTRK {
     }>;
 }
 
+interface CacheData$1 {
+    timestamp: number;
+    ttl: number;
+    data: any;
+}
+declare class CacheClass {
+    readonly cache: Map<string, CacheData$1>;
+    setCache(key: string, data: any, ttl?: number): void;
+    getCache<T>(key: string): T | null;
+    isCacheValid(key: string): boolean;
+}
+
 interface SingleActionAmount {
     tokenInfo: TokenInfo;
     amount: Web3Number;
@@ -378,7 +413,7 @@ interface CacheData {
     ttl: number;
     data: any;
 }
-declare class BaseStrategy<TVLInfo, ActionInfo> {
+declare class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     readonly config: IConfig;
     readonly cache: Map<string, CacheData>;
     constructor(config: IConfig);
@@ -386,9 +421,6 @@ declare class BaseStrategy<TVLInfo, ActionInfo> {
     getTVL(): Promise<TVLInfo>;
     depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]>;
     withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]>;
-    setCache(key: string, data: any, ttl?: number): void;
-    getCache(key: string): any | null;
-    isCacheValid(key: string): boolean;
 }
 
 interface PoolProps {
@@ -815,14 +847,6 @@ declare class SenseiVault extends BaseStrategy<SingleTokenInfo, SingleActionAmou
 }
 declare const SenseiStrategies: IStrategyMetadata<SenseiVaultSettings>[];
 
-declare class TelegramNotif {
-    private subscribers;
-    readonly bot: TelegramBot;
-    constructor(token: string, shouldPoll: boolean);
-    activateChatBot(): void;
-    sendMessage(msg: string): void;
-}
-
 interface LeveledLogMethod {
     (message: string, ...meta: any[]): void;
     (message: any): void;
@@ -836,6 +860,26 @@ interface MyLogger {
 }
 declare const logger: MyLogger;
 
+interface LeafData {
+    id: bigint;
+    readableId: string;
+    data: bigint[];
+}
+interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+    format: 'standard-v1';
+    leafEncoding: ValueType[];
+}
+declare class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
+    protected readonly tree: HexString[];
+    protected readonly values: StandardMerkleTreeData<LeafData>['values'];
+    protected readonly leafEncoding: ValueType[];
+    protected constructor(tree: HexString[], values: StandardMerkleTreeData<LeafData>['values'], leafEncoding: ValueType[]);
+    static of(values: LeafData[], leafEncoding?: ValueType[], options?: MerkleTreeOptions): StandardMerkleTree;
+    static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean;
+    static verifyMultiProof<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], multiproof: MultiProof<BytesLike, T>): boolean;
+    dump(): StandardMerkleTreeData<LeafData>;
+}
+
 type RequiredFields<T> = {
     [K in keyof T]-?: T[K];
 };
@@ -845,6 +889,271 @@ type RequiredKeys<T> = {
 declare function assert(condition: boolean, message: string): void;
 declare function getTrovesEndpoint(): string;
 
+interface ManageCall {
+    sanitizer: ContractAddr;
+    call: {
+        contractAddress: ContractAddr;
+        selector: string;
+        calldata: bigint[];
+    };
+}
+type GenerateCallFn<T> = (params: T) => ManageCall;
+type AdapterLeafType<T> = {
+    leaf: LeafData;
+    callConstructor: GenerateCallFn<T>;
+};
+type LeafAdapterFn<T> = () => AdapterLeafType<T>;
+declare class BaseAdapter extends CacheClass {
+    protected constructSimpleLeafData(params: {
+        id: string;
+        target: ContractAddr;
+        method: string;
+        packedArguments: bigint[];
+    }): LeafData;
+}
+
+interface FlashloanCallParams {
+    amount: Web3Number;
+    data: bigint[];
+}
+interface ApproveCallParams {
+    amount: Web3Number;
+}
+interface CommonAdapterConfig {
+    id: string;
+    manager: ContractAddr;
+    asset: ContractAddr;
+}
+declare class CommonAdapter extends BaseAdapter {
+    config: CommonAdapterConfig;
+    constructor(config: CommonAdapterConfig);
+    getFlashloanAdapter(): AdapterLeafType<FlashloanCallParams>;
+    getFlashloanCall(params: FlashloanCallParams): ManageCall;
+    getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams>;
+    getApproveCall(token: ContractAddr, spender: ContractAddr): (params: ApproveCallParams) => {
+        sanitizer: ContractAddr;
+        call: {
+            contractAddress: ContractAddr;
+            selector: string;
+            calldata: bigint[];
+        };
+    };
+}
+
+interface VesuPoolsInfo {
+    pools: any[];
+    isErrorPoolsAPI: boolean;
+}
+declare enum VesuAmountType {
+    Delta = 0,
+    Target = 1
+}
+declare enum VesuAmountDenomination {
+    Native = 0,
+    Assets = 1
+}
+interface i257 {
+    abs: Web3Number;
+    is_negative: boolean;
+}
+interface VesuAmount {
+    amount_type: VesuAmountType;
+    denomination: VesuAmountDenomination;
+    value: i257;
+}
+interface VesuModifyPositionCallParams {
+    collateralAmount: VesuAmount;
+    debtAmount: VesuAmount;
+}
+interface VesuAdapterConfig {
+    poolId: ContractAddr;
+    collateral: TokenInfo;
+    debt: TokenInfo;
+    vaultAllocator: ContractAddr;
+    id: string;
+}
+declare const VesuPools: {
+    Genesis: ContractAddr;
+};
+declare class VesuAdapter extends BaseAdapter {
+    VESU_SINGLETON: ContractAddr;
+    config: VesuAdapterConfig;
+    networkConfig: IConfig | undefined;
+    pricer: PricerBase | undefined;
+    constructor(config: VesuAdapterConfig);
+    getModifyPosition: () => AdapterLeafType<VesuModifyPositionCallParams>;
+    static getDefaultModifyPositionCallParams(params: {
+        collateralAmount: Web3Number;
+        isAddCollateral: boolean;
+        debtAmount: Web3Number;
+        isBorrow: boolean;
+    }): {
+        collateralAmount: {
+            amount_type: VesuAmountType;
+            denomination: VesuAmountDenomination;
+            value: {
+                abs: Web3Number;
+                is_negative: boolean;
+            };
+        };
+        debtAmount: {
+            amount_type: VesuAmountType;
+            denomination: VesuAmountDenomination;
+            value: {
+                abs: Web3Number;
+                is_negative: boolean;
+            };
+        };
+    };
+    getModifyPositionCall: (params: VesuModifyPositionCallParams) => ManageCall;
+    formatAmountTypeEnum(amountType: VesuAmountType): CairoCustomEnum;
+    formatAmountDenominationEnum(denomination: VesuAmountDenomination): CairoCustomEnum;
+    getVesuSingletonContract(config: IConfig): Contract;
+    getLTVConfig(config: IConfig): Promise<number>;
+    getPositions(config: IConfig): Promise<VaultPosition[]>;
+    getCollateralization(config: IConfig): Promise<Omit<VaultPosition, 'amount'>[]>;
+    getAssetPrices(): Promise<{
+        collateralTokenAmount: Web3Number;
+        collateralUSDAmount: number;
+        collateralPrice: number;
+        debtTokenAmount: Web3Number;
+        debtUSDAmount: number;
+        debtPrice: number;
+        ltv: number;
+    }>;
+    getHealthFactor(): Promise<number>;
+    static getVesuPools(retry?: number): Promise<VesuPoolsInfo>;
+}
+
+interface UniversalStrategySettings {
+    manager: ContractAddr;
+    vaultAllocator: ContractAddr;
+    redeemRequestNFT: ContractAddr;
+    leafAdapters: LeafAdapterFn<any>[];
+    adapters: {
+        id: string;
+        adapter: BaseAdapter;
+    }[];
+    targetHealthFactor: number;
+    minHealthFactor: number;
+}
+declare class UniversalStrategy<S extends UniversalStrategySettings> extends BaseStrategy<SingleTokenInfo, SingleActionAmount> {
+    /** Contract address of the strategy */
+    readonly address: ContractAddr;
+    /** Pricer instance for token price calculations */
+    readonly pricer: PricerBase;
+    /** Metadata containing strategy information */
+    readonly metadata: IStrategyMetadata<S>;
+    /** Contract instance for interacting with the strategy */
+    readonly contract: Contract;
+    readonly managerContract: Contract;
+    merkleTree: StandardMerkleTree | undefined;
+    constructor(config: IConfig, pricer: PricerBase, metadata: IStrategyMetadata<S>);
+    getMerkleTree(): StandardMerkleTree;
+    getMerkleRoot(): string;
+    getProofs<T>(id: string): {
+        proofs: string[];
+        callConstructor: GenerateCallFn<T>;
+    };
+    getAdapter(id: string): BaseAdapter;
+    asset(): TokenInfo;
+    depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]>;
+    /**
+     * Calculates the Total Value Locked (TVL) for a specific user.
+     * @param user - Address of the user
+     * @returns Object containing the amount in token units and USD value
+     */
+    getUserTVL(user: ContractAddr): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
+    /**
+     * Calculates the weighted average APY across all pools based on USD value.
+     * @returns {Promise<number>} The weighted average APY across all pools
+     */
+    netAPY(): Promise<{
+        net: number;
+        splits: {
+            apy: number;
+            id: string;
+        }[];
+    }>;
+    private computeAPY;
+    /**
+       * Calculates the total TVL of the strategy.
+       * @returns Object containing the total amount in token units and USD value
+    */
+    getTVL(): Promise<{
+        tokenInfo: TokenInfo;
+        amount: Web3Number;
+        usdValue: number;
+    }>;
+    getAUM(): Promise<{
+        net: SingleTokenInfo;
+        prevAum: Web3Number;
+        splits: {
+            id: string;
+            aum: Web3Number;
+        }[];
+    }>;
+    getVesuAdapters(): VesuAdapter[];
+    getVaultPositions(): Promise<VaultPosition[]>;
+    getSetManagerCall(strategist: ContractAddr, root?: string): Call;
+    getManageCall(proofIds: string[], manageCalls: ManageCall[]): Call;
+    getVesuModifyPositionCalls(params: {
+        isLeg1: boolean;
+        isDeposit: boolean;
+        depositAmount: Web3Number;
+        debtAmount: Web3Number;
+    }): {
+        proofs: string[];
+        manageCall: ManageCall;
+        step: UNIVERSAL_MANAGE_IDS;
+    }[];
+    getTag(): string;
+    getVesuHealthFactors(): Promise<number[]>;
+    computeRebalanceConditionAndReturnCalls(): Promise<Call[]>;
+    private getNewHealthFactor;
+    /**
+     *
+     * @param vesuAdapter
+     * @param currentHf
+     * @param isDeposit if true, attempt by adding collateral, else by repaying
+     * @returns
+     */
+    private getLegRebalanceAmount;
+    getVesuMultiplyCall(params: {
+        isDeposit: boolean;
+        leg1DepositAmount: Web3Number;
+    }): Promise<Call>;
+    getRebalanceCall(params: {
+        isLeg1toLeg2: boolean;
+        amount: Web3Number;
+    }): Promise<Call>;
+}
+declare enum UNIVERSAL_MANAGE_IDS {
+    FLASH_LOAN = "flash_loan_init",
+    VESU_LEG1 = "vesu_leg1",
+    VESU_LEG2 = "vesu_leg2",
+    APPROVE_TOKEN1 = "approve_token1",
+    APPROVE_TOKEN2 = "approve_token2"
+}
+declare enum UNIVERSAL_ADAPTERS {
+    COMMON = "common_adapter",
+    VESU_LEG1 = "vesu_leg1_adapter",
+    VESU_LEG2 = "vesu_leg2_adapter"
+}
+declare const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[];
+
+declare class TelegramNotif {
+    private subscribers;
+    readonly bot: TelegramBot;
+    constructor(token: string, shouldPoll: boolean);
+    activateChatBot(): void;
+    sendMessage(msg: string): void;
+}
+
 declare class PricerRedis extends Pricer {
     private redisClient;
     constructor(config: IConfig, tokens: TokenInfo[]);
@@ -860,6 +1169,37 @@ declare class PricerRedis extends Pricer {
 
 declare function getAPIUsingHeadlessBrowser(url: string): Promise<any>;
 
+declare function getAccount(accountKey: string, config: IConfig, password?: string | undefined, accountsFileName?: string, secretFileFolder?: string): Account;
+declare function myDeclare(contract_name: string, package_name: string | undefined, config: IConfig, acc: Account): Promise<{
+    transaction_hash: string;
+    class_hash: string;
+}>;
+declare function deployContract(contract_name: string, classHash: string, constructorData: RawArgs, config: IConfig, acc: Account): Promise<starknet.DeployContractUDCResponse>;
+interface DeployContractResult {
+    contract_name: string;
+    package_name: string;
+    class_hash: string;
+    call: Call;
+    address: string;
+}
+declare function prepareMultiDeployContracts(contracts: Array<{
+    contract_name: string;
+    package_name: string;
+    constructorData: RawArgs;
+}>, config: IConfig, acc: Account): Promise<DeployContractResult[]>;
+declare function executeDeployCalls(contractsInfo: DeployContractResult[], acc: Account, provider: RpcProvider): Promise<void>;
+declare function executeTransactions(calls: Call[], acc: Account, provider: RpcProvider, remarks?: string): Promise<{
+    transaction_hash: string;
+}>;
+declare const Deployer: {
+    getAccount: typeof getAccount;
+    myDeclare: typeof myDeclare;
+    deployContract: typeof deployContract;
+    prepareMultiDeployContracts: typeof prepareMultiDeployContracts;
+    executeDeployCalls: typeof executeDeployCalls;
+    executeTransactions: typeof executeTransactions;
+};
+
 /**
  * @description Config to manage storage of files on disk
  * @param SECRET_FILE_FOLDER - Folder to store secret files (default: ~/.starknet-store)
@@ -938,4 +1278,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { type AccountInfo, type AllAccountsStore, AutoCompounderSTRK, AvnuWrapper, BaseStrategy, type CLVaultStrategySettings, ContractAddr, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type FAQ, FatalError, FlowChartColors, Global, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, Initializable, type LendingToken, MarginType, Network, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerRedis, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, Store, type StoreConfig, type SwapInfo, TelegramNotif, type TokenInfo, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getAPIUsingHeadlessBrowser, getDefaultStoreConfig, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, highlightTextWithLinks, logger };
+export { type AccountInfo, type AdapterLeafType, type AllAccountsStore, type ApproveCallParams, AutoCompounderSTRK, AvnuWrapper, BaseAdapter, BaseStrategy, type CLVaultStrategySettings, CommonAdapter, type CommonAdapterConfig, ContractAddr, Deployer, type DualActionAmount, type DualTokenInfo, ERC20, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type GenerateCallFn, Global, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, Initializable, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, Network, PasswordJsonCryptoUtil, Pragma, type PriceInfo, Pricer, PricerFromApi, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, RiskType, type Route, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, Store, type StoreConfig, type SwapInfo, TelegramNotif, type TokenInfo, UNIVERSAL_ADAPTERS, UNIVERSAL_MANAGE_IDS, UniversalStrategies, UniversalStrategy, type UniversalStrategySettings, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, type VesuModifyPositionCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, Web3Number, ZkLend, assert, getAPIUsingHeadlessBrowser, getDefaultStoreConfig, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, highlightTextWithLinks, type i257, logger };