@strkfarm/sdk 1.0.55 → 1.0.57

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

@@ -33,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 {
@@ -105,7 +106,7 @@ export interface IInvestmentFlow {
 }
 
 export function getMainnetConfig(
-  rpcUrl: string,
+  rpcUrl: string = 'https://starknet-mainnet.public.blastapi.io',
   blockIdentifier: BlockIdentifier = "pending"
 ): IConfig {
   return {
@@ -200,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/notifs/telegram.ts

@@ -5,10 +5,8 @@ export class TelegramNotif {
     private subscribers: string[] = [
         // '6820228303',
         '1505578076',
-        // '5434736198', // maaza
         '1356705582', // langs
         '1388729514', // hwashere
-        '6020162572', //minato
         '985902592'
     ];
     readonly bot: TelegramBot;

package/src/strategies/base-strategy.ts

@@ -1,5 +1,6 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo } from "@/interfaces";
+import { CacheClass } from "@/utils/cacheClass";
 import { Call } from "starknet";
 
 export interface SingleActionAmount {
@@ -26,11 +27,12 @@ interface CacheData {
   ttl: number;
   data: any;
 }
-export class BaseStrategy<TVLInfo, ActionInfo> {
+export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
     readonly config: IConfig;
     readonly cache: Map<string, CacheData> = new Map();
 
     constructor(config: IConfig) {
+        super();
         this.config = config;
     }
 
@@ -49,26 +51,4 @@ 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,4 +2,6 @@ export * from './autoCompounderStrk';
 export * from './vesu-rebalance';
 export * from './ekubo-cl-vault';
 export * from './base-strategy';
-export * from './sensei';
+export * from './sensei';
+export * from './universal-adapters';
+export * from './universal-strategy';

package/src/strategies/sensei.ts

@@ -126,9 +126,16 @@ export class SenseiVault extends BaseStrategy<
     collateralInSTRK: number;
   }> {
     const CACHE_KEY = 'positionInfo';
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache<{
+      collateralXSTRK: Web3Number;
+      collateralUSDValue: Web3Number;
+      debtSTRK: Web3Number;
+      debtUSDValue: Web3Number;
+      xSTRKPrice: number;
+      collateralInSTRK: number;
+    }>(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
+
     const resp = await fetch(
       `${getTrovesEndpoint()}/vesu/positions?walletAddress=${this.address.address}`,
     );
@@ -179,9 +186,9 @@ export class SenseiVault extends BaseStrategy<
 
    async getSecondaryTokenPriceRelativeToMain(retry = 0): Promise<number> {
     const CACHE_KEY = 'xSTRKPrice';
-    if (this.isCacheValid(CACHE_KEY)) {
-      return this.getCache(CACHE_KEY);
-    }
+    const existingCacheData = this.getCache<number>(CACHE_KEY);
+    if (existingCacheData) return existingCacheData;
+    
     const params: QuoteRequest = {
       sellTokenAddress: this.metadata.additionalInfo.secondaryToken.address.address,
       buyTokenAddress: this.metadata.additionalInfo.mainToken.address.address,

package/src/strategies/universal-adapters/adapter-utils.ts

@@ -0,0 +1,13 @@
+import { ContractAddr } from "@/dataTypes";
+
+export const SIMPLE_SANITIZER = ContractAddr.from('0x11b59e89b35dfceb3e48ec18c01f8ec569592026c275bcb58e22af9f4dedaac');
+
+export function toBigInt(value: string | number): bigint {
+    if (typeof value === 'string') {
+        return BigInt(value);
+    } else if (typeof value === 'number') {
+        return BigInt(value.toString());
+    } else {
+        throw new Error('Value must be a string or number');
+    }
+}

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -0,0 +1,41 @@
+import { Call, hash, num, shortString } from "starknet";
+import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { ContractAddr } from "@/dataTypes";
+import { LeafData } from "@/utils";
+import { CacheClass } from "@/utils/cacheClass";
+
+export interface ManageCall {
+  sanitizer: ContractAddr,
+  call: {
+    contractAddress: ContractAddr,
+    selector: string,
+    calldata: bigint[]
+  }
+}
+
+export type GenerateCallFn<T> = (params: T) => ManageCall;
+export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
+export type LeafAdapterFn<T> = () => AdapterLeafType<T>;
+
+export class BaseAdapter extends CacheClass {
+
+  protected constructSimpleLeafData(params: {
+    id: string,
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[]
+  }): LeafData {
+    const { id, target, method, packedArguments } = params;
+    return {
+      id: BigInt(num.getDecimalString(shortString.encodeShortString(id))),
+      readableId: id,
+      data: [
+        SIMPLE_SANITIZER.toBigInt(), // sanitizer address
+        target.toBigInt(), // contract
+        toBigInt(hash.getSelectorFromName(method)), // method name
+        BigInt(packedArguments.length),
+        ...packedArguments
+      ]
+    };
+  }
+}

package/src/strategies/universal-adapters/common-adapter.ts

@@ -0,0 +1,96 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { LeafData } from "@/utils";
+import { Call, hash, num, shortString, uint256 } from "starknet";
+import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { AdapterLeafType, BaseAdapter, GenerateCallFn, LeafAdapterFn, ManageCall } from "./baseAdapter";
+
+export interface FlashloanCallParams {
+  amount: Web3Number,
+  data: bigint[]
+}
+export interface ApproveCallParams {
+  amount: Web3Number,
+}
+
+export interface CommonAdapterConfig {
+  id: string,
+  manager: ContractAddr,
+  asset: ContractAddr
+}
+
+export class CommonAdapter extends BaseAdapter {
+  config: CommonAdapterConfig;
+
+  constructor(config: CommonAdapterConfig) {
+    super();
+    this.config = config;
+  }
+
+  getFlashloanAdapter(): AdapterLeafType<FlashloanCallParams> {
+    const manageCall = this.getFlashloanCall.bind(this)({amount: Web3Number.fromWei('0', 6), data: []});
+    const packedArguments: bigint[] = [
+      this.config.manager.toBigInt(), // receiver
+      this.config.asset.toBigInt(), // asset
+      toBigInt(0), // is legacy false
+    ];
+    const leaf = this.constructSimpleLeafData({
+      id: this.config.id,
+      target: manageCall.call.contractAddress,
+      method: 'flash_loan',
+      packedArguments
+    });
+    return { leaf, callConstructor: this.getFlashloanCall.bind(this) };
+  }
+
+  getFlashloanCall(params: FlashloanCallParams): ManageCall {
+    const uint256Amount = uint256.bnToUint256(params.amount.toWei());
+    return {
+      sanitizer: SIMPLE_SANITIZER,
+      call: {
+        contractAddress: this.config.manager,
+        selector: hash.getSelectorFromName('flash_loan'),
+        calldata: [
+          this.config.manager.toBigInt(), // receiver
+          this.config.asset.toBigInt(), // asset
+          toBigInt(uint256Amount.low.toString()), // amount low
+          toBigInt(uint256Amount.high.toString()), // amount high
+          toBigInt(0), // is legacy false
+          BigInt(params.data.length),
+          ...params.data
+        ]
+      }
+    }
+  }
+
+  getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams> {
+    return () => ({
+      leaf: this.constructSimpleLeafData({
+        id: id,
+        target: token,
+        method: 'approve',
+        packedArguments: [
+          spender.toBigInt(), // spender
+        ]
+      }),
+      callConstructor: this.getApproveCall(token, spender).bind(this)
+    });
+  }
+
+  getApproveCall(token: ContractAddr, spender: ContractAddr) {
+    return (params: ApproveCallParams) => {
+      const uint256Amount = uint256.bnToUint256(params.amount.toWei());
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: token,
+          selector: hash.getSelectorFromName('approve'),
+          calldata: [
+            spender.toBigInt(), // spender
+            toBigInt(uint256Amount.low.toString()), // amount low
+            toBigInt(uint256Amount.high.toString()), // amount high
+          ]
+        }
+      }
+    }
+  }
+}

package/src/strategies/universal-adapters/index.ts

@@ -0,0 +1,3 @@
+export * from "./baseAdapter";
+export * from "./common-adapter";
+export * from "./vesu-adapter";