@haven-fi/solauto-sdk 1.0.0

package/dist/transactions/transactionsManager.d.ts

@@ -0,0 +1,42 @@
+import { TransactionBuilder } from "@metaplex-foundation/umi";
+import { SolautoClient } from "../clients/solautoClient";
+export declare class TransactionItem {
+    fetchTx: (attemptNum: number) => Promise<{
+        tx: TransactionBuilder;
+        lookupTableAddresses?: string[];
+    } | undefined>;
+    name?: string | undefined;
+    lookupTableAddresses: string[];
+    tx?: TransactionBuilder;
+    constructor(fetchTx: (attemptNum: number) => Promise<{
+        tx: TransactionBuilder;
+        lookupTableAddresses?: string[];
+    } | undefined>, name?: string | undefined);
+    initialize(): Promise<void>;
+    refetch(attemptNum: number): Promise<void>;
+}
+export declare enum TransactionStatus {
+    Skipped = "Skipped",
+    Processing = "Processing",
+    Queued = "Queued",
+    Successful = "Successful"
+}
+export type TransactionManagerStatuses = {
+    name: string;
+    status: TransactionStatus;
+    txSig?: string;
+}[];
+export declare class TransactionsManager {
+    private client;
+    private items;
+    private statusCallback?;
+    private simulateOnly?;
+    private mustBeAtomic?;
+    private statuses;
+    private lookupTables;
+    constructor(client: SolautoClient, items: TransactionItem[], statusCallback?: ((statuses: TransactionManagerStatuses) => void) | undefined, simulateOnly?: boolean | undefined, mustBeAtomic?: boolean | undefined);
+    private assembleTransactionSets;
+    updateStatus(name: string, status: TransactionStatus, txSig?: string): void;
+    send(): Promise<void>;
+}
+//# sourceMappingURL=transactionsManager.d.ts.map

package/dist/transactions/transactionsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionsManager.d.ts","sourceRoot":"","sources":["../../src/transactions/transactionsManager.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAuCzD,qBAAa,eAAe;IAKjB,OAAO,EAAE,CACd,UAAU,EAAE,MAAM,KACf,OAAO,CACV;QAAE,EAAE,EAAE,kBAAkB,CAAC;QAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,SAAS,CACxE;IACM,IAAI,CAAC;IATd,oBAAoB,EAAG,MAAM,EAAE,CAAC;IAChC,EAAE,CAAC,EAAE,kBAAkB,CAAC;gBAGf,OAAO,EAAE,CACd,UAAU,EAAE,MAAM,KACf,OAAO,CACV;QAAE,EAAE,EAAE,kBAAkB,CAAC;QAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,SAAS,CACxE,EACM,IAAI,CAAC,oBAAQ;IAGhB,UAAU;IAIV,OAAO,CAAC,UAAU,EAAE,MAAM;CAKjC;AAsED,oBAAY,iBAAiB;IAC3B,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,MAAM,WAAW;IACjB,UAAU,eAAe;CAC1B;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,EAAE,CAAC;AAEJ,qBAAa,mBAAmB;IAK5B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,YAAY,CAAC;IACrB,OAAO,CAAC,YAAY,CAAC;IARvB,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,YAAY,CAAe;gBAGzB,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,eAAe,EAAE,EACxB,cAAc,CAAC,6CAA4C,IAAI,aAAA,EAC/D,YAAY,CAAC,qBAAS,EACtB,YAAY,CAAC,qBAAS;YAKlB,uBAAuB;IAsCrC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,MAAM;IAgB9D,IAAI;CA6HX"}

package/dist/transactions/transactionsManager.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionsManager = exports.TransactionStatus = exports.TransactionItem = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+const umi_1 = require("@metaplex-foundation/umi");
+const solanaUtils_1 = require("../utils/solanaUtils");
+const solautoConstants_1 = require("../constants/solautoConstants");
+const generalUtils_1 = require("../utils/generalUtils");
+const transactionUtils_1 = require("./transactionUtils");
+const jitoUtils_1 = require("../utils/jitoUtils");
+class LookupTables {
+    constructor(client) {
+        this.client = client;
+        this.defaultLuts = [];
+        this.cache = [];
+        this.defaultLuts = [
+            client.authorityLutAddress.toString(),
+            ...client.defaultLookupTables(),
+        ];
+    }
+    async getLutInputs(additionalAddresses) {
+        const addresses = [...this.defaultLuts, ...additionalAddresses];
+        const currentCacheAddresses = this.cache.map((x) => x.publicKey.toString());
+        const missingAddresses = addresses.filter((x) => !currentCacheAddresses.includes(x));
+        if (missingAddresses) {
+            const additionalInputs = await (0, solanaUtils_1.getAdressLookupInputs)(missingAddresses);
+            this.cache.push(...additionalInputs);
+        }
+        return this.cache.filter((x) => addresses.includes(x.publicKey.toString()));
+    }
+}
+class TransactionItem {
+    constructor(fetchTx, name) {
+        this.fetchTx = fetchTx;
+        this.name = name;
+    }
+    async initialize() {
+        await this.refetch(0);
+    }
+    async refetch(attemptNum) {
+        const resp = await this.fetchTx(attemptNum);
+        this.tx = resp?.tx;
+        this.lookupTableAddresses = resp?.lookupTableAddresses ?? [];
+    }
+}
+exports.TransactionItem = TransactionItem;
+class TransactionSet {
+    constructor(client, lookupTables, items = []) {
+        this.client = client;
+        this.lookupTables = lookupTables;
+        this.items = items;
+    }
+    async fitsWith(item) {
+        if (!item.tx) {
+            return true;
+        }
+        return (await this.getSingleTransaction())
+            .add(item.tx)
+            .setAddressLookupTables(await this.lookupTables.getLutInputs([
+            ...this.lutAddresses(),
+            ...item.lookupTableAddresses,
+        ]))
+            .fitsInOneTransaction(solautoConstants_1.UMI);
+    }
+    add(...items) {
+        this.items.push(...items.filter((x) => x.tx && x.tx.getInstructions().length > 0));
+    }
+    async refetchAll(attemptNum) {
+        await this.client.resetLivePositionUpdates();
+        for (const item of this.items) {
+            await item.refetch(attemptNum);
+        }
+    }
+    async getSingleTransaction() {
+        const transactions = this.items
+            .filter((x) => x.tx && x.tx.getInstructions().length > 0)
+            .map((x) => x.tx);
+        return (0, umi_1.transactionBuilder)()
+            .add(transactions)
+            .setAddressLookupTables(await this.lookupTables.getLutInputs(this.lutAddresses()));
+    }
+    lutAddresses() {
+        return Array.from(new Set(this.items.map((x) => x.lookupTableAddresses).flat()));
+    }
+    name() {
+        const names = this.items
+            .filter((x) => x.tx && x.name !== undefined)
+            .map((x) => x.name.toLowerCase());
+        if (names.length >= 3) {
+            return [names.slice(0, -1).join(", "), names[names.length - 1]].join(", and ");
+        }
+        else {
+            return names.join(" & ");
+        }
+    }
+}
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["Skipped"] = "Skipped";
+    TransactionStatus["Processing"] = "Processing";
+    TransactionStatus["Queued"] = "Queued";
+    TransactionStatus["Successful"] = "Successful";
+})(TransactionStatus = exports.TransactionStatus || (exports.TransactionStatus = {}));
+class TransactionsManager {
+    constructor(client, items, statusCallback, simulateOnly, mustBeAtomic) {
+        this.client = client;
+        this.items = items;
+        this.statusCallback = statusCallback;
+        this.simulateOnly = simulateOnly;
+        this.mustBeAtomic = mustBeAtomic;
+        this.statuses = [];
+        this.lookupTables = new LookupTables(client);
+    }
+    async assembleTransactionSets(items) {
+        let transactionSets = [];
+        this.client.log(`Reassembling ${items.length} items`);
+        for (let i = 0; i < items.length;) {
+            let item = items[i];
+            i++;
+            if (!item.tx) {
+                continue;
+            }
+            const transaction = item.tx.setAddressLookupTables(await this.lookupTables.getLutInputs(item.lookupTableAddresses));
+            if (!transaction.fitsInOneTransaction(solautoConstants_1.UMI)) {
+                throw new Error(`Transaction exceeds max transaction size (${transaction.getTransactionSize(solautoConstants_1.UMI)})`);
+            }
+            else {
+                let newSet = new TransactionSet(this.client, this.lookupTables, [item]);
+                for (let j = i; j < items.length; j++) {
+                    if (await newSet.fitsWith(items[j])) {
+                        newSet.add(items[j]);
+                        i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                transactionSets.push(newSet);
+            }
+        }
+        return transactionSets;
+    }
+    updateStatus(name, status, txSig) {
+        if (!this.statuses.filter((x) => x.name === name)) {
+            this.statuses.push({ name, status, txSig });
+        }
+        else {
+            const idx = this.statuses.findIndex((x) => x.name === name);
+            if (idx !== -1) {
+                this.statuses[idx].status = status;
+                this.statuses[idx].txSig = txSig;
+            }
+            else {
+                this.statuses.push({ name, status, txSig });
+            }
+        }
+        this.client.log(`${name} is ${status.toString().toLowerCase()}`);
+        this.statusCallback?.(this.statuses);
+    }
+    async send() {
+        const updateLookupTable = await this.client.updateLookupTable();
+        if (updateLookupTable && updateLookupTable?.needsToBeIsolated) {
+            this.updateStatus("update lookup table", TransactionStatus.Processing);
+            await (0, generalUtils_1.retryWithExponentialBackoff)(async (attemptNum) => await (0, solanaUtils_1.sendSingleOptimizedTransaction)(this.client, updateLookupTable.updateLutTx, this.simulateOnly, attemptNum), 2);
+            this.updateStatus("update lookup table", TransactionStatus.Successful);
+        }
+        for (const item of this.items) {
+            await item.initialize();
+        }
+        const [choresBefore, choresAfter] = await (0, transactionUtils_1.getTransactionChores)(this.client, (0, umi_1.transactionBuilder)().add(this.items
+            .filter((x) => x.tx && x.tx.getInstructions().length > 0)
+            .map((x) => x.tx)));
+        if (updateLookupTable && !updateLookupTable.needsToBeIsolated) {
+            choresBefore.prepend(updateLookupTable.updateLutTx);
+        }
+        if (choresBefore.getInstructions().length > 0) {
+            this.items.unshift(new TransactionItem(async () => ({ tx: choresBefore })));
+            this.client.log("Chores before: ", choresBefore.getInstructions().length);
+        }
+        if (choresAfter.getInstructions().length > 0) {
+            this.items.push(new TransactionItem(async () => ({ tx: choresAfter })));
+            this.client.log("Chores after: ", choresAfter.getInstructions().length);
+        }
+        const itemSets = await this.assembleTransactionSets(this.items);
+        const statusesStartIdx = this.statuses.length;
+        for (const itemSet of itemSets) {
+            this.updateStatus(itemSet.name(), TransactionStatus.Queued);
+        }
+        if (this.mustBeAtomic && itemSets.length > 1) {
+            itemSets.forEach((set) => {
+                this.updateStatus(set.name(), TransactionStatus.Processing);
+            });
+            await (0, jitoUtils_1.sendJitoBundledTransactions)(this.client, await Promise.all(itemSets.map((x) => x.getSingleTransaction())), this.simulateOnly);
+            // TODO: check if successful or not
+            // itemSets.forEach((set) => {
+            //   this.updateStatus(set.name(), TransactionStatus.Successful);
+            // });
+        }
+        else if (!this.simulateOnly || itemSets.length === 1) {
+            for (let i = 0; i < itemSets.length; i++) {
+                const getFreshItemSet = async (itemSet, attemptNum) => {
+                    await itemSet.refetchAll(attemptNum);
+                    const newItemSets = await this.assembleTransactionSets([
+                        ...itemSet.items,
+                        ...itemSets
+                            .slice(i + 1)
+                            .map((x) => x.items)
+                            .flat(),
+                    ]);
+                    if (newItemSets.length > 1) {
+                        this.statuses.splice(statusesStartIdx + i, itemSets.length - i, ...newItemSets.map((x) => ({
+                            name: x.name(),
+                            status: TransactionStatus.Queued,
+                        })));
+                        this.client.log(this.statuses);
+                        itemSets.splice(i + 1, itemSets.length - i - 1, ...newItemSets.slice(1));
+                    }
+                    return newItemSets[0];
+                };
+                let itemSet = itemSets[i];
+                await (0, generalUtils_1.retryWithExponentialBackoff)(async (attemptNum) => {
+                    itemSet =
+                        i > 0 || attemptNum > 0
+                            ? await getFreshItemSet(itemSet, attemptNum)
+                            : itemSet;
+                    const tx = await itemSet.getSingleTransaction();
+                    if (tx.getInstructions().length === 0) {
+                        this.updateStatus(itemSet.name(), TransactionStatus.Skipped);
+                    }
+                    else {
+                        this.updateStatus(itemSet.name(), TransactionStatus.Processing);
+                        const txSig = await (0, solanaUtils_1.sendSingleOptimizedTransaction)(this.client, tx, this.simulateOnly, attemptNum);
+                        this.updateStatus(itemSet.name(), TransactionStatus.Successful, txSig ? bs58_1.default.encode(txSig) : undefined);
+                    }
+                }, 3);
+            }
+        }
+        if (!this.simulateOnly) {
+            await this.client.resetLivePositionUpdates();
+        }
+    }
+}
+exports.TransactionsManager = TransactionsManager;

package/dist/types/accounts.d.ts

@@ -0,0 +1,8 @@
+export interface MarginfiTokenAccounts {
+    mint: string;
+    bank: string;
+    liquidityVault: string;
+    vaultAuthority: string;
+    priceOracle: string;
+}
+//# sourceMappingURL=accounts.d.ts.map

package/dist/types/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/types/accounts.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/dist/types/accounts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './accounts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./accounts"), exports);

package/dist/utils/accountUtils.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { PublicKey } from "@solana/web3.js";
+export declare function bufferFromU8(num: number): Buffer;
+export declare function bufferFromU64(num: bigint): Buffer;
+export declare function getTokenAccount(wallet: PublicKey, tokenMint: PublicKey): PublicKey;
+export declare function getTokenAccounts(wallet: PublicKey, tokenMints: PublicKey[]): PublicKey[];
+export declare function getSolautoPositionAccount(signer: PublicKey, positionId: number): Promise<PublicKey>;
+export declare function getReferralState(authority: PublicKey): Promise<PublicKey>;
+export declare function getMarginfiAccountPDA(solautoPositionAccount: PublicKey, marginfiAccountSeedIdx: bigint): Promise<PublicKey>;
+export declare function getSolendObligationAccount(solautoPositionAccount: PublicKey | undefined, signer: PublicKey, lendingMarket: PublicKey, solendProgram: PublicKey): Promise<PublicKey>;
+//# sourceMappingURL=accountUtils.d.ts.map

package/dist/utils/accountUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountUtils.d.ts","sourceRoot":"","sources":["../../src/utils/accountUtils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAe,MAAM,iBAAiB,CAAC;AAIzD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIjD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,CAMlF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAExF;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,sBAQnB;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,SAAS,sBAU1D;AAED,wBAAsB,qBAAqB,CACzC,sBAAsB,EAAE,SAAS,EACjC,sBAAsB,EAAE,MAAM,sBAa/B;AAED,wBAAsB,0BAA0B,CAC9C,sBAAsB,EAAE,SAAS,GAAG,SAAS,EAC7C,MAAM,EAAE,SAAS,EACjB,aAAa,EAAE,SAAS,EACxB,aAAa,EAAE,SAAS,sBAkBzB"}

package/dist/utils/accountUtils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolendObligationAccount = exports.getMarginfiAccountPDA = exports.getReferralState = exports.getSolautoPositionAccount = exports.getTokenAccounts = exports.getTokenAccount = exports.bufferFromU64 = exports.bufferFromU8 = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const generated_1 = require("../generated");
+function bufferFromU8(num) {
+    const buffer = Buffer.alloc(1);
+    buffer.writeUInt8(num);
+    return buffer;
+}
+exports.bufferFromU8 = bufferFromU8;
+function bufferFromU64(num) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64LE(num);
+    return buffer;
+}
+exports.bufferFromU64 = bufferFromU64;
+function getTokenAccount(wallet, tokenMint) {
+    return (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, wallet, true);
+}
+exports.getTokenAccount = getTokenAccount;
+function getTokenAccounts(wallet, tokenMints) {
+    return tokenMints.map(x => getTokenAccount(wallet, x));
+}
+exports.getTokenAccounts = getTokenAccounts;
+async function getSolautoPositionAccount(signer, positionId) {
+    const [positionAccount, _] = await web3_js_1.PublicKey.findProgramAddress([bufferFromU8(positionId), signer.toBuffer()], new web3_js_1.PublicKey(generated_1.SOLAUTO_PROGRAM_ID));
+    return positionAccount;
+}
+exports.getSolautoPositionAccount = getSolautoPositionAccount;
+async function getReferralState(authority) {
+    const str = "referral_state";
+    const strBuffer = Buffer.from(str, "utf-8");
+    const [ReferralState, _] = await web3_js_1.PublicKey.findProgramAddress([strBuffer, authority.toBuffer()], new web3_js_1.PublicKey(generated_1.SOLAUTO_PROGRAM_ID));
+    return ReferralState;
+}
+exports.getReferralState = getReferralState;
+async function getMarginfiAccountPDA(solautoPositionAccount, marginfiAccountSeedIdx) {
+    const seeds = [
+        solautoPositionAccount.toBuffer(),
+        bufferFromU64(marginfiAccountSeedIdx),
+    ];
+    const [marginfiAccount, _] = await web3_js_1.PublicKey.findProgramAddress(seeds, new web3_js_1.PublicKey(generated_1.SOLAUTO_PROGRAM_ID));
+    return marginfiAccount;
+}
+exports.getMarginfiAccountPDA = getMarginfiAccountPDA;
+async function getSolendObligationAccount(solautoPositionAccount, signer, lendingMarket, solendProgram) {
+    const seeds = [
+        signer.toBuffer(),
+        lendingMarket.toBuffer(),
+        solendProgram.toBuffer(),
+    ];
+    if (solautoPositionAccount !== undefined) {
+        seeds.unshift(solautoPositionAccount.toBuffer());
+    }
+    const [obligationAccount, _] = await web3_js_1.PublicKey.findProgramAddress(seeds, new web3_js_1.PublicKey(generated_1.SOLAUTO_PROGRAM_ID));
+    return obligationAccount;
+}
+exports.getSolendObligationAccount = getSolendObligationAccount;

package/dist/utils/deleteme.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deleteme.d.ts.map

package/dist/utils/deleteme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteme.d.ts","sourceRoot":"","sources":["../../src/utils/deleteme.ts"],"names":[],"mappings":""}

package/dist/utils/deleteme.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const numberUtils_1 = require("./numberUtils");
+// // TODO delete this file
+function check() {
+    let supply = 458948;
+    let debt = 212846;
+    let supply_weight = 0.899999976158142;
+    let debt_weight = 1.100000023841858;
+    let liq_threshold = (supply_weight / debt_weight) * 10000;
+    console.log(liq_threshold);
+    let liq_utilization_rate = (0, numberUtils_1.getLiqUtilzationRateBps)(supply, debt, liq_threshold);
+    console.log(liq_utilization_rate);
+    let debt_adjustment_usd = (0, numberUtils_1.getDebtAdjustmentUsd)(liq_threshold, supply, debt, 6000, 0);
+    supply += debt_adjustment_usd;
+    debt += debt_adjustment_usd;
+    liq_utilization_rate = (0, numberUtils_1.getLiqUtilzationRateBps)(supply, debt, liq_threshold);
+    console.log(debt_adjustment_usd);
+    console.log(liq_utilization_rate);
+}
+check();

package/dist/utils/generalUtils.d.ts

@@ -0,0 +1,11 @@
+import { PublicKey } from "@solana/web3.js";
+import { MaybeRpcAccount } from "@metaplex-foundation/umi";
+export declare function generateRandomU8(): number;
+export declare function generateRandomU64(): bigint;
+export declare function currentUnixSeconds(): number;
+export declare function getSolanaAccountCreated(pk: PublicKey): Promise<boolean>;
+export declare function rpcAccountCreated(account: MaybeRpcAccount): boolean;
+export declare function arraysAreEqual(arrayA: number[], arrayB: number[]): boolean;
+export declare function getTokenPrices(mints: PublicKey[]): Promise<number[]>;
+export declare function retryWithExponentialBackoff<T>(fn: (attemptNum: number) => Promise<T>, retries?: number, delay?: number, errorsToRetry?: Set<Function>): Promise<T>;
+//# sourceMappingURL=generalUtils.d.ts.map

package/dist/utils/generalUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalUtils.d.ts","sourceRoot":"","sources":["../../src/utils/generalUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAa,MAAM,0BAA0B,CAAC;AAKtE,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAG7E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAEnE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAU1E;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA+C1E;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAC3C,EAAE,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACtC,OAAO,GAAE,MAAU,EACnB,KAAK,GAAE,MAAY,EACnB,aAAa,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAwBZ"}

package/dist/utils/generalUtils.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryWithExponentialBackoff = exports.getTokenPrices = exports.arraysAreEqual = exports.rpcAccountCreated = exports.getSolanaAccountCreated = exports.currentUnixSeconds = exports.generateRandomU64 = exports.generateRandomU8 = void 0;
+const umi_1 = require("@metaplex-foundation/umi");
+const pythConstants_1 = require("../constants/pythConstants");
+const numberUtils_1 = require("./numberUtils");
+const solautoConstants_1 = require("../constants/solautoConstants");
+function generateRandomU8() {
+    return Math.floor(Math.random() * 255 + 1);
+}
+exports.generateRandomU8 = generateRandomU8;
+function generateRandomU64() {
+    const upperBound = 2n ** 64n;
+    let result = 0n;
+    for (let i = 0; i < 64; i += 8) {
+        result |= BigInt(Math.floor(Math.random() * 256)) << BigInt(i);
+    }
+    return result % upperBound;
+}
+exports.generateRandomU64 = generateRandomU64;
+function currentUnixSeconds() {
+    return Math.round(new Date().getTime() / 1000);
+}
+exports.currentUnixSeconds = currentUnixSeconds;
+async function getSolanaAccountCreated(pk) {
+    const account = await solautoConstants_1.UMI.rpc.getAccount((0, umi_1.publicKey)(pk));
+    return rpcAccountCreated(account);
+}
+exports.getSolanaAccountCreated = getSolanaAccountCreated;
+function rpcAccountCreated(account) {
+    return account.exists && account.data.length > 0;
+}
+exports.rpcAccountCreated = rpcAccountCreated;
+function arraysAreEqual(arrayA, arrayB) {
+    if (arrayA.length !== arrayB.length) {
+        return false;
+    }
+    for (let i = 0; i < arrayA.length; i++) {
+        if (arrayA[i] !== arrayB[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.arraysAreEqual = arraysAreEqual;
+async function getTokenPrices(mints) {
+    const currentTime = currentUnixSeconds();
+    if (!mints.some(mint => !(mint.toString() in solautoConstants_1.PRICES) || currentTime - solautoConstants_1.PRICES[mint.toString()].time > 3)) {
+        console.log("Accessing price cache");
+        return mints.map(mint => solautoConstants_1.PRICES[mint.toString()].price);
+    }
+    console.log("Fetching prices...");
+    const priceFeedIds = mints.map((mint) => pythConstants_1.PYTH_PRICE_FEED_IDS[mint.toString()]);
+    const getReq = async () => await fetch(`https://hermes.pyth.network/v2/updates/price/latest?${priceFeedIds.map((x) => `ids%5B%5D=${x}`).join("&")}`);
+    let resp = await getReq();
+    let status = resp.status;
+    while (status !== 200) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        resp = await getReq();
+        status = resp.status;
+    }
+    const json = await resp.json();
+    const prices = json.parsed.map((x) => {
+        if (x.price.expo > 0) {
+            return Number((0, numberUtils_1.toBaseUnit)(Number(x.price.price), x.price.expo));
+        }
+        else if (x.price.expo < 0) {
+            return (0, numberUtils_1.fromBaseUnit)(BigInt(x.price.price), Math.abs(x.price.expo));
+        }
+        else {
+            return Number(x.price.price);
+        }
+    });
+    for (var i = 0; i < mints.length; i++) {
+        solautoConstants_1.PRICES[mints[i].toString()] = {
+            price: prices[i],
+            time: currentUnixSeconds()
+        };
+    }
+    return prices;
+}
+exports.getTokenPrices = getTokenPrices;
+function retryWithExponentialBackoff(fn, retries = 5, delay = 150, errorsToRetry) {
+    return new Promise((resolve, reject) => {
+        const attempt = (attemptNum) => {
+            fn(attemptNum)
+                .then(resolve)
+                .catch((error) => {
+                attemptNum++;
+                if (attemptNum < retries &&
+                    (!errorsToRetry || errorsToRetry.has(error.constructor))) {
+                    console.log(error);
+                    setTimeout(() => {
+                        console.log("Retrying...");
+                        attempt(attemptNum);
+                    }, delay);
+                    delay *= 2;
+                }
+                else {
+                    reject(error);
+                }
+            });
+        };
+        attempt(0);
+    });
+}
+exports.retryWithExponentialBackoff = retryWithExponentialBackoff;

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './solauto/index';
+export * from './accountUtils';
+export * from './generalUtils';
+export * from './jitoUtils';
+export * from './jupiterUtils';
+export * from './marginfiUtils';
+export * from './numberUtils';
+export * from './solanaUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./solauto/index"), exports);
+__exportStar(require("./accountUtils"), exports);
+__exportStar(require("./generalUtils"), exports);
+__exportStar(require("./jitoUtils"), exports);
+__exportStar(require("./jupiterUtils"), exports);
+__exportStar(require("./marginfiUtils"), exports);
+__exportStar(require("./numberUtils"), exports);
+__exportStar(require("./solanaUtils"), exports);

package/dist/utils/jitoUtils.d.ts

@@ -0,0 +1,15 @@
+import { SolautoClient } from "../clients/solautoClient";
+import { PublicKey } from "@solana/web3.js";
+import { TransactionBuilder } from "@metaplex-foundation/umi";
+import { SearcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
+import { BundleResult } from "jito-ts/dist/gen/block-engine/bundle";
+export declare function getSearcherClient(): SearcherClient;
+export declare function getRandomTipAccount(): Promise<PublicKey>;
+export declare function waitUntilJitoNextLeader(distanceFromJitoSlot?: number): Promise<void>;
+interface JitoTransactionsResult {
+    bundleResult: BundleResult;
+    txSigs: Uint8Array[];
+}
+export declare function sendJitoBundledTransactions(client: SolautoClient, txs: TransactionBuilder[], simulateOnly?: boolean): Promise<JitoTransactionsResult | undefined>;
+export {};
+//# sourceMappingURL=jitoUtils.d.ts.map

package/dist/utils/jitoUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitoUtils.d.ts","sourceRoot":"","sources":["../../src/utils/jitoUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAW,SAAS,EAAwB,MAAM,iBAAiB,CAAC;AAQ3E,OAAO,EAGL,kBAAkB,EAEnB,MAAM,0BAA0B,CAAC;AAUlC,OAAO,EACL,cAAc,EAEf,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEpE,wBAAgB,iBAAiB,IAAI,cAAc,CAKlD;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,SAAS,CAAC,CAI9D;AAED,wBAAsB,uBAAuB,CAC3C,oBAAoB,GAAE,MAAU,iBAYjC;AAuFD,UAAU,sBAAsB;IAC9B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,kBAAkB,EAAE,EACzB,YAAY,CAAC,EAAE,OAAO,GACrB,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAsC7C"}