@strkfarm/sdk 1.0.6

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@strkfarm/sdk",
+  "version": "1.0.6",
+  "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
+  "typings": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "accountsecure": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "browser": "./dist/index.global.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "tsup --clean && pnpm run build:esm && npm run build:dts && npm run build:iife && npm run build-cli",
+    "build:esm": "tsup --clean false --format esm --platform node",
+    "build-cli:esm": "tsup ./src/cli.ts --clean false --format esm --platform node",
+    "build-cli": "tsup ./src/cli.ts --clean false && pnpm run build-cli:esm",
+    "build:dts": "tsup --clean false --dts-only",
+    "build:iife": "tsup --clean false --format iife --platform browser"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node-telegram-bot-api": "^0.64.7",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "^29.1.5",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.1.0",
+    "typedoc": "^0.26.3",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "axios": "^1.7.2",
+    "bignumber.js": "4.0.4",
+    "browser-assert": "^1.2.1",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "inquirer": "^10.1.2",
+    "node-telegram-bot-api": "^0.66.0",
+    "redis": "^4.7.0",
+    "starknet": "^6.11.0",
+    "winston": "^3.13.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { Store, getDefaultStoreConfig } from './utils/store';
+import chalk from 'chalk';
+import { IConfig, Network } from './interfaces';
+import { RpcProvider } from 'starknet';
+
+const program = new Command();
+
+const getConfig = (network: Network) => {
+    return {
+        provider: new RpcProvider({
+            nodeUrl: 'https://starknet-mainnet.public.blastapi.io',
+        }),
+        network: network,
+        stage: 'production',
+    }
+}
+
+async function createStore() {
+    console.log(chalk.blue.bold('Welcome to the Account Secure project for Starknet!'));
+    const networkAnswers = await (<any>inquirer).prompt([
+        {
+            type: 'list',
+            name: 'network',
+            message: chalk.yellow('What is the network?'),
+            choices: ['mainnet', 'sepolia', 'devnet'],
+        },
+    ]);
+    const network: Network = networkAnswers.network as Network;
+    const defaultStoreConfig = getDefaultStoreConfig(network);
+
+    const storeConfigAnswers = await (<any>inquirer).prompt([
+        {
+            type: 'input',
+            name: 'secrets_folder',
+            message: chalk.yellow(`What is your secrets folder? (${defaultStoreConfig.SECRET_FILE_FOLDER})`),
+            default: defaultStoreConfig.SECRET_FILE_FOLDER,
+            validate: (input: string) => true,
+        },
+        {
+            type: 'input',
+            name: 'accounts_file',
+            message: chalk.yellow(`What is your accounts file? (${defaultStoreConfig.ACCOUNTS_FILE_NAME})`),
+            default: defaultStoreConfig.ACCOUNTS_FILE_NAME,
+            validate: (input: string) => true,
+        },
+        {
+            type: 'input',
+            name: 'encryption_password',
+            message: chalk.yellow(`What is your decryption password? (To generate one, press enter)`),
+            default: defaultStoreConfig.PASSWORD,
+            validate: (input: string) => true,
+        }
+    ]);
+
+    const config = getConfig(network);
+
+    const secrets_folder = storeConfigAnswers.secrets_folder;
+    const accounts_file = storeConfigAnswers.accounts_file;
+    const encryption_password = storeConfigAnswers.encryption_password;
+
+    const store = new Store(config, {
+        SECRET_FILE_FOLDER: secrets_folder,
+        ACCOUNTS_FILE_NAME: accounts_file,
+        PASSWORD: storeConfigAnswers.encryption_password,
+        NETWORK: network,
+    });
+
+    if (defaultStoreConfig.PASSWORD === encryption_password) {
+        Store.logPassword(encryption_password);
+    }
+
+    return store;
+}
+
+program
+  .version('1.0.0')
+  .description('Manage accounts securely on your disk with encryption');
+
+program
+  .description('Add accounts securely to your disk with encryption')
+  .command('add-account')
+  .action(async (options) => {
+        const store = await createStore();
+
+        const existingAccountKeys = store.listAccounts();
+
+        const accountAnswers = await (<any>inquirer).prompt([
+            {
+                type: 'input',
+                name: 'account_key',
+                message: chalk.yellow(`Provide a unique account key`),
+                validate: (input: string) => (input.length > 0 && !existingAccountKeys.includes(input)) || 'Please enter a unique account key',
+            },
+            {
+                type: 'input',
+                name: 'address',
+                message: chalk.yellow(`What is your account address?`),
+                validate: (input: string) => input.length > 0 || 'Please enter a valid address',
+            },
+            {
+                type: 'input',
+                name: 'pk',
+                message: chalk.yellow(`What is your account private key?`),
+                validate: (input: string) => input.length > 0 || 'Please enter a valid pk',
+            },
+        ]);
+
+        const address = accountAnswers.address;
+        const pk = accountAnswers.pk;
+        const account_key = accountAnswers.account_key;
+
+        store.addAccount(account_key, address, pk);
+
+        console.log(`${chalk.blue("Account added:")} ${account_key} to network: ${store.config.network}`);
+    });
+
+program
+  .description('List account names of a network')
+  .command('list-accounts')
+  .action(async (options) => {
+    const store = await createStore();
+    const accounts = store.listAccounts();
+    console.log(`${chalk.blue("Account keys:")} ${accounts.join(', ')}`);
+  })
+
+program
+  .description('List account names of a network')
+  .command('get-account')
+  .action(async (options) => {
+    const store = await createStore();
+    const existingAccountKeys = store.listAccounts();
+    const accountAnswers = await (<any>inquirer).prompt([
+        {
+            type: 'input',
+            name: 'account_key',
+            message: chalk.yellow(`Provide a unique account key`),
+            validate: (input: string) => (input.length > 0 && existingAccountKeys.includes(input)) || 'Please enter a value account key',
+        },
+    ]);
+
+    const account = store.getAccount(accountAnswers.account_key);
+    console.log(`${chalk.blue("Account Address:")} ${account.address}`);
+  })
+
+// Default action if no command is provided
+program
+  .action(() => {
+    program.help(); // Show help if no command is provided
+  });
+
+program.parse(process.argv);
+
+// Show help if no command is provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/src/data/pragma.abi.json

@@ -0,0 +1,96 @@
+[
+    {
+      "data": [
+        {
+          "name": "previousOwner",
+          "type": "felt"
+        },
+        {
+          "name": "newOwner",
+          "type": "felt"
+        }
+      ],
+      "keys": [],
+      "name": "OwnershipTransferred",
+      "type": "event"
+    },
+    {
+      "data": [
+        {
+          "name": "token",
+          "type": "felt"
+        },
+        {
+          "name": "source",
+          "type": "felt"
+        }
+      ],
+      "keys": [],
+      "name": "TokenSourceChanged",
+      "type": "event"
+    },
+    {
+      "name": "constructor",
+      "type": "constructor",
+      "inputs": [
+        {
+          "name": "owner",
+          "type": "felt"
+        }
+      ],
+      "outputs": []
+    },
+    {
+      "name": "get_price",
+      "type": "function",
+      "inputs": [
+        {
+          "name": "token",
+          "type": "felt"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "price",
+          "type": "felt"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "name": "get_price_with_time",
+      "type": "function",
+      "inputs": [
+        {
+          "name": "token",
+          "type": "felt"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "price",
+          "type": "felt"
+        },
+        {
+          "name": "update_time",
+          "type": "felt"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "name": "set_token_source",
+      "type": "function",
+      "inputs": [
+        {
+          "name": "token",
+          "type": "felt"
+        },
+        {
+          "name": "source",
+          "type": "felt"
+        }
+      ],
+      "outputs": []
+    }
+  ]

package/src/data/tokens.json

@@ -0,0 +1,72 @@
+[
+  {
+    "name": "Ether",
+    "symbol": "ETH",
+    "address": "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    "decimals": 18,
+    "pricerKey": "ETH-USDT"
+  },
+  {
+    "name": "USD Coin",
+    "symbol": "USDC",
+    "address": "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+    "decimals": 6,
+    "pricerKey": "USDC-USDT"
+  },
+  {
+    "name": "Wrapped BTC",
+    "symbol": "WBTC",
+    "address": "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+    "decimals": 8,
+    "pricerKey": "WBTC-USDT"
+  },
+  {
+    "name": "Tether USD",
+    "symbol": "USDT",
+    "address": "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8",
+    "decimals": 6,
+    "pricerKey": "USDT-USDT"
+  },
+  {
+    "name": "Dai Stablecoin",
+    "symbol": "DAIv0",
+    "address": "",
+    "decimals": 18,
+    "pricerKey": "DAI-USDT"
+  },
+  {
+    "name": "Starknet Wrapped Staked Ether",
+    "symbol": "wstETH",
+    "address": "0x042b8f0484674ca266ac5d08e4ac6a3fe65bd3129795def2dca5c34ecc5f96d2",
+    "decimals": 18,
+    "pricerKey": "wstETH-USDT"
+  },
+  {
+    "name": "Starknet Token",
+    "symbol": "STRK",
+    "address": "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+    "decimals": 18,
+    "pricerKey": "STRK-USDT"
+  },
+  {
+    "name": "zkLend Token",
+    "symbol": "ZEND",
+    "address": "",
+    "decimals": 18,
+    "pricerKey": "ZEND-USDT"
+  },
+  {
+    "name": "Dai Stablecoin",
+    "symbol": "DAI",
+    "address": "",
+    "decimals": 18,
+    "pricerKey": "DAI-USDT"
+  },
+  {
+    "name": "Ekubo Protocol",
+    "symbol": "EKUBO",
+    "address": "",
+    "decimals": 18,
+    "pricerKey": "DAI-USDT"
+  }
+]

package/src/dataTypes/address.ts

@@ -0,0 +1,38 @@
+import { num } from "starknet";
+
+/**
+ * A simple wrapper around a contract address that is universally comparable
+ * - Helps avoid padding issues
+ */
+export class ContractAddr {
+    readonly address: string;
+
+    constructor(address: string) {
+        this.address = ContractAddr.standardise(address);
+    }
+
+    static from(address: string) {
+        return new ContractAddr(address);
+    }
+
+    eq(other: ContractAddr) {
+        return this.address === other.address;
+    }
+
+    eqString(other: string) {
+        return this.address === ContractAddr.standardise(other);
+    }
+
+    static standardise(address: string | bigint) {
+        let _a = address;
+        if (!address) {
+            _a = "0";
+        }
+        const a = num.getHexString(num.getDecimalString(_a.toString()));
+        return a;
+    }
+
+    static eqString(a: string, b: string) {
+        return ContractAddr.standardise(a) === ContractAddr.standardise(b);
+    }
+}

package/src/dataTypes/bignumber.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+// import { inspect } from 'util';
+// const customInspectSymbol = inspect.custom || Symbol.for('nodejs.util.inspect.custom');
+
+function isNode() {
+    // Check for the presence of the `window` object, which is undefined in Node.js
+    return typeof window === 'undefined';
+}
+
+export class Web3Number extends BigNumber {
+    decimals: number;
+
+    constructor(value: string | number, decimals: number) {
+        super(value);
+        this.decimals = decimals;
+    }
+
+    static fromWei(weiNumber: string | number, decimals: number) {
+        const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
+        return new Web3Number(bn.toString(), decimals);
+    }
+
+    toWei() {
+        return this.mul(10 ** this.decimals).toFixed(0);
+    }
+
+    multipliedBy(value: string | number) {
+        return new Web3Number(this.mul(value).toString(), this.decimals);
+    }
+
+    dividedBy(value: string | number) {
+        return new Web3Number(this.div(value).toString(), this.decimals);
+    }
+
+    plus(value: string | number) {
+        return new Web3Number(this.add(value).toString(), this.decimals);
+    }
+
+    minus(n: number | string, base?: number): Web3Number {
+        return new Web3Number(super.minus(n, base).toString(), this.decimals);
+    }
+
+    toString(base?: number | undefined): string {
+        return super.toString(base);
+    }
+    
+    // [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
+    // return this.toString();
+    // }
+}
+
+BigNumber.config({ DECIMAL_PLACES: 18 })
+Web3Number.config({ DECIMAL_PLACES: 18 })

package/src/dataTypes/index.ts

@@ -0,0 +1,2 @@
+export * from './bignumber';
+export * from './address';

package/src/global.ts

@@ -0,0 +1,73 @@
+import { TokenInfo } from './interfaces';
+import TOKENS from '@/data/tokens.json';
+
+const colors = {
+    error: 'red',
+    warn: 'yellow',
+    info: 'blue',
+    verbose: 'white',
+    debug: 'white',
+}
+
+// Add custom colors to Winston
+// winston.addColors(colors);
+
+// export const logger = createLogger({
+//   level: 'verbose', // Set the minimum logging level
+//   format: format.combine(
+//     format.colorize({ all: true }), // Apply custom colors
+//     format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), // Add timestamp to log messages
+//     format.printf(({ timestamp, level, message }) => {
+//       return `${timestamp} ${level}: ${message}`;
+//     })
+//   ),
+//   transports: [
+//     // new transports.Console() // Output logs to the console
+//   ]
+// });
+
+
+export const logger = {
+    ...console,
+    verbose(message: string) {
+        console.log(`[VERBOSE] ${message}`);
+    }
+};
+
+
+export class FatalError extends Error {
+    constructor(message: string, err?: Error) {
+        super(message);
+        logger.error(message);
+        if (err)
+            logger.error(err.message);
+        this.name = "FatalError";
+    }
+}
+/** Contains globally useful functions. 
+ * - fatalError: Things to do when a fatal error occurs
+ */
+export class Global {
+    static fatalError(message: string, err?: Error) {
+        logger.error(message);
+        console.error(message, err);
+        if (err)
+            console.error(err);
+        process.exit(1);
+    }
+
+    static httpError(url: string, err: Error, message?: string) {
+        logger.error(`${url}: ${message}`);
+        console.error(err);
+    }
+
+    static async getTokens(): Promise<TokenInfo[]> {
+        return TOKENS;
+    }
+
+    static assert(condition: any, message: string) {
+        if (!condition) {
+            throw new FatalError(message);
+        }
+    }
+}

package/src/index.browser.ts

@@ -0,0 +1,6 @@
+// contains only browser supported modules
+export * from './modules';
+export * from './interfaces';
+export * from './dataTypes';
+export * from './global';
+export * from './strategies';

package/src/index.ts

@@ -0,0 +1,9 @@
+// contains all modules that can run in node
+export * from './modules';
+export * from './interfaces';
+export * from './dataTypes';
+export * from './global';
+export * from './strategies';
+export * from './notifs';
+export * from './utils';
+export * from './node';

package/src/interfaces/common.ts

@@ -0,0 +1,33 @@
+import { BlockIdentifier, RpcProvider } from "starknet"
+
+export interface TokenInfo {
+    name: string,
+    symbol: string,
+    address: string,
+    decimals: number,
+    pricerKey?: string
+}
+
+export enum Network {
+    mainnet = "mainnet",
+    sepolia = "sepolia",
+    devnet = "devnet"
+}
+
+export interface IConfig {
+    provider: RpcProvider,
+    network: Network,
+    stage: 'production' | 'staging',
+    heartbeatUrl?: string
+}
+
+export function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier: BlockIdentifier = 'pending'): IConfig {
+    return {
+        provider: new RpcProvider({
+            nodeUrl: rpcUrl,
+            blockIdentifier: blockIdentifier
+        }),
+        stage: "production",
+        network: Network.mainnet
+    }
+}

package/src/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './lending';
+export * from './common';
+export * from './initializable';

package/src/interfaces/initializable.ts

@@ -0,0 +1,21 @@
+export abstract class Initializable {
+    protected initialized: boolean;
+
+    constructor() {
+        this.initialized = false;
+    }
+    
+    abstract init(): Promise<void>;
+
+    async waitForInitilisation() {
+        return new Promise<void>((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (this.initialized) {
+                    console.log('Initialised');
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+}