@strkfarm/sdk 1.0.54 → 1.0.56

package/src/dataTypes/address.ts

@@ -39,4 +39,8 @@ export class ContractAddr {
     toString() {
         return this.address;
     }
+
+    toBigInt() {
+        return num.toBigInt(this.address);
+    }
 }

package/src/global.ts

@@ -62,6 +62,16 @@ const defaultTokens: TokenInfo[] = [{
     decimals: 8,
     coingeckId: undefined,
     displayDecimals: 6,
+    priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
+}, {
+    name: 'tBTC',
+    symbol: 'tBTC',
+    logo: 'https://assets.strkfarm.com/integrations/tokens/tbtc.svg',
+    address: ContractAddr.from('0x4daa17763b286d1e59b97c283c0b8c949994c361e426a28f743c67bdfe9a32f'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
 }]
 const tokens: TokenInfo[] = defaultTokens;
 
@@ -69,6 +79,8 @@ const tokens: TokenInfo[] = defaultTokens;
  * - fatalError: Things to do when a fatal error occurs
  */
 export class Global {
+    static cache: Record<string, {value: any, ttl: number, timestamp: number}> = {};
+
     static fatalError(message: string, err?: Error) {
         logger.error(message);
         console.error(message, err);
@@ -149,4 +161,22 @@ export class Global {
         }
         return token;
     }
+
+    static setGlobalCache(key: string, data: any, ttl: number = 60000) {
+        Global.cache[key] = {
+            value: data,
+            ttl,
+            timestamp: Date.now()
+        };
+    }
+    
+    static getGlobalCache<T>(key: string): T | null {
+        const cached = Global.cache[key];
+        if (!cached) return null;
+        if (Date.now() - cached.timestamp > cached.ttl) {
+            delete Global.cache[key];
+            return null;
+        }
+        return cached.value;
+    }
 }

package/src/interfaces/common.tsx

@@ -14,7 +14,8 @@ export enum RiskType {
   SMART_CONTRACT_RISK = "Smart Contract Risk",
   ORACLE_RISK = "Oracle Risk",
   TECHNICAL_RISK = "Technical Risk",
-  COUNTERPARTY_RISK = "Counterparty Risk" // e.g. bad debt
+  COUNTERPARTY_RISK = "Counterparty Risk", // e.g. bad debt
+  DEPEG_RISK = "Depeg Risk" // e.g. USDC depeg
 }
 
 export interface RiskFactor {
@@ -32,6 +33,7 @@ export interface TokenInfo {
   logo: string;
   coingeckId?: string;
   displayDecimals: number;
+  priceCheckAmount?: number; // for tokens like BTC, doing 1BTC price check may not be ideal, esp on illiquid netwrks like sn
 }
 
 export enum Network {
@@ -104,7 +106,7 @@ export interface IInvestmentFlow {
 }
 
 export function getMainnetConfig(
-  rpcUrl = "https://starknet-mainnet.public.blastapi.io",
+  rpcUrl: string = 'https://starknet-mainnet.public.blastapi.io',
   blockIdentifier: BlockIdentifier = "pending"
 ): IConfig {
   return {
@@ -135,6 +137,8 @@ export const getRiskExplaination = (riskType: RiskType) => {
       return "The risk of technical issues e.g. backend failure.";
     case RiskType.COUNTERPARTY_RISK:
       return "The risk of the counterparty defaulting e.g. bad debt on lending platforms.";
+    case RiskType.DEPEG_RISK:
+      return "The risk of a token losing its peg to the underlying asset, leading to potential losses for holders.";
   }
 };
 
@@ -197,3 +201,19 @@ export function highlightTextWithLinks(
     </>
   );
 }
+
+export interface VaultPosition {
+  amount: Web3Number,
+  usdValue: number,
+  token: TokenInfo,
+  remarks: string
+}
+
+const VesuProtocol: IProtocol = {
+  name: "Vesu",
+  logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
+};
+
+export const Protocols = {
+  VESU: VesuProtocol,
+}

package/src/modules/pricer.ts

@@ -149,7 +149,7 @@ export class Pricer extends PricerBase {
                 }
             case 'Ekubo':
                 try {
-                    const result = await this._getPriceEkubo(token);
+                    const result = await this._getPriceEkubo(token, new Web3Number(token.priceCheckAmount ? token.priceCheckAmount : 1, token.decimals));
                     this.methodToUse[token.symbol] = 'Ekubo';
                     return result;
                 } catch (error: any) {

package/src/node/deployer.ts

@@ -0,0 +1,219 @@
+import assert from 'assert'
+import {Account, Call, RawArgs, RpcProvider, TransactionExecutionStatus, constants, extractContractHashes, hash, json, num, provider, transaction} from 'starknet'
+import { readFileSync, existsSync, writeFileSync } from 'fs'
+import { IConfig } from '../interfaces';
+import { Store, getDefaultStoreConfig } from '../utils/store';
+import { add } from 'winston';
+
+function getContracts() {
+    const PATH = './contracts.json'
+    if (existsSync(PATH)) {
+        return JSON.parse(readFileSync(PATH, {encoding: 'utf-8'}))
+    }
+    return {}
+}
+
+function saveContracts(contracts: any) {
+    const PATH = './contracts.json'
+    writeFileSync(PATH, JSON.stringify(contracts));
+}
+
+function getAccount(
+    accountKey: string, 
+    config: IConfig, 
+    password = process.env.ACCOUNT_SECURE_PASSWORD,
+    accountsFileName = process.env.ACCOUNTS_FILE_NAME || getDefaultStoreConfig(config.network).ACCOUNTS_FILE_NAME,
+    secretFileFolder = process.env.SECRET_FILE_FOLDER || getDefaultStoreConfig(config.network).SECRET_FILE_FOLDER
+) { 
+    const storeConfig = getDefaultStoreConfig(config.network);
+    storeConfig.ACCOUNTS_FILE_NAME = accountsFileName;
+    storeConfig.SECRET_FILE_FOLDER = secretFileFolder;
+    if (!password) {
+        throw new Error(`getAccount: Password is required (either in env as ACCOUNT_SECURE_PASSWORD or input to function)`);
+    }
+    const store = new Store(config, {
+        ...storeConfig,
+        PASSWORD: password
+    });
+    
+    return store.getAccount(accountKey);
+}
+
+async function myDeclare(contract_name: string, package_name: string = 'strkfarm', config: IConfig, acc: Account) {
+    const provider = config.provider;
+    const compiledSierra = json.parse(
+        readFileSync(`./target/release/${package_name}_${contract_name}.contract_class.json`).toString("ascii")
+    )
+    const compiledCasm = json.parse(
+    readFileSync(`./target/release/${package_name}_${contract_name}.compiled_contract_class.json`).toString("ascii")
+    )
+    
+    const contracts = getContracts();
+    const payload = {
+        contract: compiledSierra,
+        casm: compiledCasm
+    };
+    
+    const result = extractContractHashes(payload);
+    console.log("classhash:", result.classHash);
+    
+    try {
+        const cls = await provider.getClassByHash(result.classHash);
+        console.log(`Class ${result.classHash} already declared`);
+        return {
+            transaction_hash: '',
+            class_hash: result.classHash
+        }
+    } catch (err) {}
+
+    const fee = await acc.estimateDeclareFee({
+        contract: compiledSierra,
+        casm: compiledCasm, 
+    })
+
+    const tx = await acc.declareIfNot(payload)
+    console.log(`Declaring: ${contract_name}, tx:`, tx.transaction_hash);
+    await provider.waitForTransaction(tx.transaction_hash, {
+        successStates: [TransactionExecutionStatus.SUCCEEDED]
+    })
+    
+    if (!contracts.class_hashes) {
+        contracts['class_hashes'] = {};
+    }
+
+    // Todo attach cairo and scarb version. and commit ID
+    contracts.class_hashes[contract_name] = tx.class_hash;
+    saveContracts(contracts);
+    console.log(`Contract declared: ${contract_name}`)
+    console.log(`Class hash: ${tx.class_hash}`)
+    return tx;
+}
+
+async function deployContract(contract_name: string, classHash: string, constructorData: RawArgs, config: IConfig, acc: Account) {
+    const provider = config.provider;
+
+    const fee = await acc.estimateDeployFee({
+        classHash,
+        constructorCalldata: constructorData,
+    })
+    console.log("Deploy fee", contract_name, Number(fee.suggestedMaxFee) / 10 ** 18, 'ETH')
+
+    const tx = await acc.deployContract({
+        classHash,
+        constructorCalldata: constructorData,
+    })
+    console.log('Deploy tx: ', tx.transaction_hash);
+    await provider.waitForTransaction(tx.transaction_hash, {
+        successStates: [TransactionExecutionStatus.SUCCEEDED]
+    })
+    const contracts = getContracts();
+    if (!contracts.contracts) {
+        contracts['contracts'] = {};
+    }
+    contracts.contracts[contract_name] = tx.contract_address;
+    saveContracts(contracts);
+    console.log(`Contract deployed: ${contract_name}`)
+    console.log(`Address: ${tx.contract_address}`)
+    return tx;
+}
+
+interface DeployContractResult {
+    contract_name: string;
+    package_name: string;
+    class_hash: string;
+    call: Call,
+    address: string
+}
+
+async function prepareMultiDeployContracts(
+    contracts: Array<{ contract_name: string, package_name: string, constructorData: RawArgs }>, 
+    config: IConfig, 
+    acc: Account
+) {
+    const result: DeployContractResult[] = [];
+
+    for (const { contract_name, package_name, constructorData } of contracts) {
+        const declaredInfo = await myDeclare(contract_name, package_name, config, acc);
+        const classHash = declaredInfo.class_hash;
+
+        const {calls, addresses} = transaction.buildUDCCall({
+            classHash,
+            constructorCalldata: constructorData,
+        }, acc.address);
+
+        assert(calls.length == 1, `Expected exactly one call, got ${calls.length}`);
+        assert(addresses.length == 1, `Expected exactly one address, got ${addresses.length}`);
+
+        result.push({
+            contract_name,
+            package_name,
+            class_hash: classHash,
+            call: calls[0],
+            address: addresses[0]
+        });
+    }
+
+    return result;
+}
+
+async function executeDeployCalls(
+    contractsInfo: DeployContractResult[],
+    acc: Account,
+    provider: RpcProvider
+) {
+    // all must be UDC 
+    for (let contractInfo of contractsInfo) {
+        assert(num.toHexString(contractInfo.call.contractAddress) == num.toHexString(constants.UDC.ADDRESS), 'Must be pointed at UDC address');
+    }
+
+    const allCalls = contractsInfo.map(info => info.call);
+    await executeTransactions(allCalls, acc, provider, `Deploying contracts: ${contractsInfo.map(info => info.contract_name).join(', ')}`);
+
+    // save contracts in storage
+    const contracts = getContracts();
+    if (!contracts.contracts) {
+        contracts['contracts'] = {};
+    }
+    if (!contracts.class_hashes) {
+        contracts['class_hashes'] = {};
+    }
+
+    for (let contractInfo of contractsInfo) {
+        // Todo attach cairo and scarb version. and commit ID
+        contracts.class_hashes[contractInfo.contract_name] = contractInfo.class_hash;
+        contracts.contracts[contractInfo.contract_name] = contractInfo.address;
+        console.log(`Contract deployed: ${contractInfo.contract_name}, addr: ${contractInfo.address}`);
+    }
+    saveContracts(contracts);
+}
+
+async function executeTransactions(
+    calls: Call[],
+    acc: Account,
+    provider: RpcProvider,
+    remarks?: string, // optional string for logging purposes
+) {
+    const tx = await acc.execute(calls);
+    console.log(`Transaction executed: ${tx.transaction_hash}`);
+    if (remarks)
+        console.log(`Remarks: ${remarks}`);
+
+
+    await provider.waitForTransaction(tx.transaction_hash, {
+        successStates: [TransactionExecutionStatus.SUCCEEDED]
+    });
+    console.log(`Transaction confirmed: ${tx.transaction_hash}`);
+
+    return tx;
+}
+
+const Deployer = {
+    getAccount,
+    myDeclare,
+    deployContract,
+    prepareMultiDeployContracts,
+    executeDeployCalls,
+    executeTransactions
+}
+
+export default Deployer;

package/src/node/index.ts

@@ -1,2 +1,3 @@
 export * from './pricer-redis';
-export * from '@/node/headless';
+export * from '@/node/headless';
+export { default as Deployer } from './deployer';

package/src/strategies/base-strategy.ts

@@ -21,8 +21,14 @@ export interface DualTokenInfo {
     token1: SingleTokenInfo
 }
 
+interface CacheData {
+  timestamp: number;
+  ttl: number;
+  data: any;
+}
 export class BaseStrategy<TVLInfo, ActionInfo> {
     readonly config: IConfig;
+    readonly cache: Map<string, CacheData> = new Map();
 
     constructor(config: IConfig) {
         this.config = config;
@@ -43,5 +49,26 @@ export class BaseStrategy<TVLInfo, ActionInfo> {
     async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
+
+    setCache(key: string, data: any, ttl: number = 60000): void {
+        const timestamp = Date.now();
+        this.cache.set(key, { timestamp, ttl, data });
+    }
+
+    getCache(key: string): any | null {
+        const cachedData = this.cache.get(key);
+        if (!cachedData || !this.isCacheValid(key)) {
+            return null;
+        }
+        return cachedData.data;
+    }
+
+    isCacheValid(key: string): boolean {
+        const cachedData = this.cache.get(key);
+        if (!cachedData) return false;
+
+        const { timestamp, ttl } = cachedData;
+        return Date.now() - timestamp <= ttl;
+    }
     
 }

package/src/strategies/index.ts

@@ -2,3 +2,6 @@ export * from './autoCompounderStrk';
 export * from './vesu-rebalance';
 export * from './ekubo-cl-vault';
 export * from './base-strategy';
+export * from './sensei';
+export * from './universal-adapters';
+export * from './universal-strategy';