@haven-fi/solauto-sdk 1.0.0

package/src/clients/solautoMarginfiClient.ts

@@ -0,0 +1,496 @@
+import {
+  fromWeb3JsKeypair,
+  fromWeb3JsPublicKey,
+  toWeb3JsPublicKey,
+} from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  Signer,
+  TransactionBuilder,
+  publicKey,
+  PublicKey as UmiPublicKey,
+  transactionBuilder,
+  createSignerFromKeypair,
+  AccountMeta,
+} from "@metaplex-foundation/umi";
+import {
+  Keypair,
+  PublicKey,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+} from "@solana/web3.js";
+import { SolautoClient, SolautoClientArgs } from "./solautoClient";
+import { MarginfiTokenAccounts } from "../types/accounts";
+import {
+  DEFAULT_MARGINFI_GROUP,
+  MARGINFI_ACCOUNTS_LOOKUP_TABLE,
+} from "../constants/marginfiAccounts";
+import {
+  DCASettingsInpArgs,
+  LendingPlatform,
+  PositionState,
+  SolautoActionArgs,
+  SolautoRebalanceTypeArgs,
+  SolautoSettingsParametersInpArgs,
+  marginfiOpenPosition,
+  marginfiProtocolInteraction,
+  marginfiRebalance,
+  marginfiRefreshData,
+} from "../generated";
+import { getMarginfiAccountPDA, getTokenAccount } from "../utils/accountUtils";
+import { generateRandomU64 } from "../utils/generalUtils";
+import {
+  MARGINFI_PROGRAM_ID,
+  MarginfiAccount,
+  lendingAccountBorrow,
+  lendingAccountEndFlashloan,
+  lendingAccountRepay,
+  lendingAccountStartFlashloan,
+  marginfiAccountInitialize,
+  safeFetchMarginfiAccount,
+} from "../marginfi-sdk";
+import { JupSwapDetails } from "../utils/jupiterUtils";
+import { FlashLoanDetails } from "../utils/solauto/rebalanceUtils";
+import {
+  findMarginfiBankAccounts,
+  getAllMarginfiAccountsByAuthority,
+  getMarginfiAccountPositionState,
+} from "../utils/marginfiUtils";
+import { bytesToI80F48 } from "../utils/numberUtils";
+
+export interface SolautoMarginfiClientArgs extends SolautoClientArgs {
+  marginfiAccount?: PublicKey | Signer;
+  marginfiAccountSeedIdx?: bigint;
+  marginfiGroup?: PublicKey;
+}
+
+export function newMarginfiSolautoManagedPositionArgs(
+  positionId: number,
+  signer: Signer,
+  supplyMint: PublicKey,
+  debtMint: PublicKey,
+  referredByAuthority?: PublicKey
+): SolautoMarginfiClientArgs {
+  return {
+    positionId,
+    signer,
+    marginfiAccountSeedIdx: positionId > 0 ? generateRandomU64() : undefined,
+    supplyLiquidityMint: supplyMint,
+    debtLiquidityMint: debtMint,
+    referredByAuthority,
+  };
+}
+
+export class SolautoMarginfiClient extends SolautoClient {
+  public marginfiProgram!: PublicKey;
+
+  public marginfiAccountSeedIdx?: bigint;
+  public marginfiAccount!: PublicKey | Signer;
+  public marginfiAccountPk!: PublicKey;
+  public marginfiGroup!: PublicKey;
+
+  public marginfiSupplyBankAccounts!: MarginfiTokenAccounts;
+  public marginfiDebtBankAccounts!: MarginfiTokenAccounts;
+
+  // For flash loans
+  public intermediaryMarginfiAccountSigner?: Signer;
+  public intermediaryMarginfiAccountPk!: PublicKey;
+  public intermediaryMarginfiAccount?: MarginfiAccount;
+
+  async initialize(args: SolautoMarginfiClientArgs) {
+    if (args.marginfiAccount) {
+      this.marginfiAccount = args.marginfiAccount;
+    }
+
+    await super.initialize(args, LendingPlatform.Marginfi);
+
+    this.marginfiAccountSeedIdx = args.marginfiAccountSeedIdx;
+    this.marginfiAccount =
+      this.marginfiAccountSeedIdx !== undefined
+        ? await getMarginfiAccountPDA(
+            this.solautoPosition,
+            this.marginfiAccountSeedIdx
+          )
+        : args.marginfiAccount ??
+          toWeb3JsPublicKey(this.solautoPositionData!.position.protocolAccount);
+    this.marginfiAccountPk =
+      "publicKey" in this.marginfiAccount
+        ? toWeb3JsPublicKey(this.marginfiAccount.publicKey)
+        : this.marginfiAccount;
+
+    const marginfiAccountData = await safeFetchMarginfiAccount(
+      this.umi,
+      publicKey(this.marginfiAccountPk)
+    );
+    this.marginfiGroup = marginfiAccountData
+      ? toWeb3JsPublicKey(marginfiAccountData.group)
+      : args.marginfiGroup ?? new PublicKey(DEFAULT_MARGINFI_GROUP);
+
+    this.marginfiSupplyBankAccounts = findMarginfiBankAccounts({
+      mint: this.supplyLiquidityMint.toString(),
+    })!;
+    this.marginfiDebtBankAccounts = findMarginfiBankAccounts({
+      mint: this.debtLiquidityMint.toString(),
+    })!;
+
+    const existingMarginfiAccounts = await getAllMarginfiAccountsByAuthority(
+      toWeb3JsPublicKey(this.signer.publicKey)
+    );
+    const emptyMarginfiAccounts = existingMarginfiAccounts.filter(
+      (x) =>
+        x.lendingAccount.balances.find(
+          (y) =>
+            y.bankPk.toString() !== PublicKey.default.toString() &&
+            (Math.round(bytesToI80F48(y.assetShares.value)) != 0 ||
+              Math.round(bytesToI80F48(y.liabilityShares.value)) != 0)
+        ) === undefined
+    );
+
+    this.intermediaryMarginfiAccountSigner =
+      emptyMarginfiAccounts.length > 0
+        ? undefined
+        : createSignerFromKeypair(
+            this.umi,
+            fromWeb3JsKeypair(Keypair.generate())
+          );
+    this.intermediaryMarginfiAccountPk =
+      emptyMarginfiAccounts.length > 0
+        ? toWeb3JsPublicKey(emptyMarginfiAccounts[0].publicKey)
+        : toWeb3JsPublicKey(this.intermediaryMarginfiAccountSigner!.publicKey);
+    this.intermediaryMarginfiAccount =
+      emptyMarginfiAccounts.length > 0 ? emptyMarginfiAccounts[0] : undefined;
+  }
+
+  defaultLookupTables(): string[] {
+    return [MARGINFI_ACCOUNTS_LOOKUP_TABLE, ...super.defaultLookupTables()];
+  }
+
+  lutAccountsToAdd(): PublicKey[] {
+    return [
+      ...super.lutAccountsToAdd(),
+      this.marginfiAccountPk,
+      this.intermediaryMarginfiAccountPk,
+    ];
+  }
+
+  openPosition(
+    settingParams?: SolautoSettingsParametersInpArgs,
+    dca?: DCASettingsInpArgs
+  ): TransactionBuilder {
+    return super
+      .openPosition(settingParams, dca)
+      .add(this.marginfiOpenPositionIx(settingParams, dca));
+  }
+
+  private marginfiOpenPositionIx(
+    settingParams?: SolautoSettingsParametersInpArgs,
+    dca?: DCASettingsInpArgs
+  ): TransactionBuilder {
+    let signerDebtLiquidityTa: UmiPublicKey | undefined = undefined;
+    if (dca) {
+      signerDebtLiquidityTa = publicKey(this.signerDebtLiquidityTa);
+    }
+
+    return marginfiOpenPosition(this.umi, {
+      signer: this.signer,
+      marginfiProgram: publicKey(MARGINFI_PROGRAM_ID),
+      solautoFeesWallet: publicKey(this.solautoFeesWallet),
+      solautoFeesSupplyTa: publicKey(this.solautoFeesSupplyTa),
+      signerReferralState: publicKey(this.authorityReferralState),
+      referredByState: this.referredByState
+        ? publicKey(this.referredByState)
+        : undefined,
+      referredBySupplyTa: this.referredBySupplyTa
+        ? publicKey(this.referredBySupplyTa)
+        : undefined,
+      solautoPosition: publicKey(this.solautoPosition),
+      marginfiGroup: publicKey(this.marginfiGroup),
+      marginfiAccount:
+        this.marginfiAccountSeedIdx !== undefined
+          ? publicKey(this.marginfiAccount)
+          : (this.marginfiAccount as Signer),
+      supplyMint: publicKey(this.supplyLiquidityMint),
+      supplyBank: publicKey(this.marginfiSupplyBankAccounts.bank),
+      positionSupplyTa: publicKey(this.positionSupplyLiquidityTa),
+      debtMint: publicKey(this.debtLiquidityMint),
+      debtBank: publicKey(this.marginfiDebtBankAccounts.bank),
+      positionDebtTa: publicKey(this.positionDebtLiquidityTa),
+      signerDebtTa: signerDebtLiquidityTa,
+      positionData: {
+        positionId: this.positionId!,
+        settingParams: settingParams ?? null,
+        dca: dca ?? null,
+      },
+      marginfiAccountSeedIdx: this.marginfiAccountSeedIdx ?? null,
+    });
+  }
+
+  refresh(): TransactionBuilder {
+    return marginfiRefreshData(this.umi, {
+      signer: this.signer,
+      marginfiProgram: publicKey(MARGINFI_PROGRAM_ID),
+      marginfiGroup: publicKey(this.marginfiGroup),
+      marginfiAccount: publicKey(this.marginfiAccount),
+      supplyBank: publicKey(this.marginfiSupplyBankAccounts.bank),
+      supplyPriceOracle: publicKey(this.marginfiSupplyBankAccounts.priceOracle),
+      debtBank: publicKey(this.marginfiDebtBankAccounts.bank),
+      debtPriceOracle: publicKey(this.marginfiDebtBankAccounts.priceOracle),
+      solautoPosition: publicKey(this.solautoPosition),
+    });
+  }
+
+  protocolInteraction(args: SolautoActionArgs): TransactionBuilder {
+    return super
+      .protocolInteraction(args)
+      .add(this.marginfiProtocolInteractionIx(args));
+  }
+
+  private marginfiProtocolInteractionIx(
+    args: SolautoActionArgs
+  ): TransactionBuilder {
+    let sourceSupplyTa: UmiPublicKey | undefined = undefined;
+    let vaultSupplyTa: UmiPublicKey | undefined = undefined;
+    let supplyVaultAuthority: UmiPublicKey | undefined = undefined;
+    if (args.__kind === "Deposit" || args.__kind === "Withdraw") {
+      sourceSupplyTa = publicKey(
+        args.__kind === "Withdraw" || this.selfManaged
+          ? this.signerSupplyLiquidityTa
+          : this.positionSupplyLiquidityTa
+      );
+      vaultSupplyTa = publicKey(this.marginfiSupplyBankAccounts.liquidityVault);
+      supplyVaultAuthority = publicKey(
+        this.marginfiSupplyBankAccounts.vaultAuthority
+      );
+    }
+
+    let sourceDebtTa: UmiPublicKey | undefined = undefined;
+    let vaultDebtTa: UmiPublicKey | undefined = undefined;
+    let debtVaultAuthority: UmiPublicKey | undefined = undefined;
+    if (args.__kind === "Borrow" || args.__kind === "Repay") {
+      sourceDebtTa = publicKey(
+        args.__kind === "Borrow" || this.selfManaged
+          ? this.signerDebtLiquidityTa
+          : this.positionDebtLiquidityTa
+      );
+      vaultDebtTa = publicKey(this.marginfiDebtBankAccounts.liquidityVault);
+      debtVaultAuthority = publicKey(
+        this.marginfiDebtBankAccounts.vaultAuthority
+      );
+    }
+
+    let supplyPriceOracle: UmiPublicKey | undefined = undefined;
+    let debtPriceOracle: UmiPublicKey | undefined = undefined;
+    if (args.__kind === "Withdraw" || args.__kind === "Borrow") {
+      supplyPriceOracle = publicKey(
+        this.marginfiSupplyBankAccounts.priceOracle
+      );
+      debtPriceOracle = publicKey(this.marginfiDebtBankAccounts.priceOracle);
+    }
+
+    return marginfiProtocolInteraction(this.umi, {
+      signer: this.signer,
+      marginfiProgram: publicKey(MARGINFI_PROGRAM_ID),
+      solautoPosition: publicKey(this.solautoPosition),
+      marginfiGroup: publicKey(this.marginfiGroup),
+      marginfiAccount: publicKey(this.marginfiAccountPk),
+      supplyBank: publicKey(this.marginfiSupplyBankAccounts.bank),
+      supplyPriceOracle,
+      sourceSupplyTa,
+      vaultSupplyTa,
+      supplyVaultAuthority,
+      debtBank: publicKey(this.marginfiDebtBankAccounts.bank),
+      debtPriceOracle,
+      sourceDebtTa,
+      vaultDebtTa,
+      debtVaultAuthority,
+      solautoAction: args,
+    });
+  }
+
+  rebalance(
+    rebalanceStep: "A" | "B",
+    swapDetails: JupSwapDetails,
+    rebalanceType: SolautoRebalanceTypeArgs,
+    targetLiqUtilizationRateBps?: number,
+    limitGapBps?: number
+  ): TransactionBuilder {
+    return marginfiRebalance(this.umi, {
+      signer: this.signer,
+      marginfiProgram: publicKey(MARGINFI_PROGRAM_ID),
+      ixsSysvar: publicKey(SYSVAR_INSTRUCTIONS_PUBKEY),
+      solautoFeesSupplyTa:
+        rebalanceStep === "B" ? publicKey(this.solautoFeesSupplyTa) : undefined,
+      authorityReferralState:
+        rebalanceStep === "B"
+          ? publicKey(this.authorityReferralState)
+          : undefined,
+      referredBySupplyTa:
+        rebalanceStep === "B" && this.referredBySupplyTa
+          ? publicKey(this.referredBySupplyTa)
+          : undefined,
+      solautoPosition: publicKey(this.solautoPosition),
+      marginfiGroup: publicKey(this.marginfiGroup),
+      marginfiAccount: publicKey(this.marginfiAccountPk),
+      intermediaryTa: publicKey(
+        getTokenAccount(
+          toWeb3JsPublicKey(this.signer.publicKey),
+          swapDetails.inputMint
+        )
+      ),
+      supplyBank: publicKey(this.marginfiSupplyBankAccounts.bank),
+      supplyPriceOracle: publicKey(this.marginfiSupplyBankAccounts.priceOracle),
+      positionSupplyTa: publicKey(this.positionSupplyLiquidityTa),
+      vaultSupplyTa: publicKey(this.marginfiSupplyBankAccounts.liquidityVault),
+      supplyVaultAuthority: publicKey(
+        this.marginfiSupplyBankAccounts.vaultAuthority
+      ),
+      debtBank: publicKey(this.marginfiDebtBankAccounts.bank),
+      debtPriceOracle: publicKey(this.marginfiDebtBankAccounts.priceOracle),
+      positionDebtTa: publicKey(this.positionDebtLiquidityTa),
+      vaultDebtTa: publicKey(this.marginfiDebtBankAccounts.liquidityVault),
+      debtVaultAuthority: publicKey(
+        this.marginfiDebtBankAccounts.vaultAuthority
+      ),
+      rebalanceType,
+      targetLiqUtilizationRateBps: targetLiqUtilizationRateBps ?? null,
+      limitGapBps: limitGapBps ?? null,
+    });
+  }
+
+  flashBorrow(
+    flashLoanDetails: FlashLoanDetails,
+    destinationTokenAccount: PublicKey
+  ): TransactionBuilder {
+    const bank = flashLoanDetails.mint.equals(this.supplyLiquidityMint)
+      ? this.marginfiSupplyBankAccounts
+      : this.marginfiDebtBankAccounts;
+    return transactionBuilder()
+      .add(
+        lendingAccountStartFlashloan(this.umi, {
+          endIndex: 0, // We set this after building the transaction
+          ixsSysvar: publicKey(SYSVAR_INSTRUCTIONS_PUBKEY),
+          marginfiAccount: publicKey(this.intermediaryMarginfiAccountPk),
+          signer: this.signer,
+        })
+      )
+      .add(
+        lendingAccountBorrow(this.umi, {
+          amount: flashLoanDetails.baseUnitAmount,
+          bank: publicKey(bank.bank),
+          bankLiquidityVault: publicKey(bank.liquidityVault),
+          bankLiquidityVaultAuthority: publicKey(bank.vaultAuthority),
+          destinationTokenAccount: publicKey(destinationTokenAccount),
+          marginfiAccount: publicKey(this.intermediaryMarginfiAccountPk),
+          marginfiGroup: publicKey(DEFAULT_MARGINFI_GROUP),
+          signer: this.signer,
+        })
+      );
+  }
+
+  flashRepay(flashLoanDetails: FlashLoanDetails): TransactionBuilder {
+    const bank = flashLoanDetails.mint.equals(this.supplyLiquidityMint)
+      ? this.marginfiSupplyBankAccounts
+      : this.marginfiDebtBankAccounts;
+
+    const remainingAccounts: AccountMeta[] = [];
+    let includedFlashLoanToken = false;
+
+    if (this.intermediaryMarginfiAccount) {
+      this.intermediaryMarginfiAccount.lendingAccount.balances.forEach((x) => {
+        if (x.active) {
+          if (x.bankPk === bank.bank) {
+            includedFlashLoanToken = true;
+          }
+
+          remainingAccounts.push(
+            ...[
+              {
+                pubkey: x.bankPk,
+                isSigner: false,
+                isWritable: false,
+              },
+              {
+                pubkey: publicKey(
+                  findMarginfiBankAccounts({ bank: x.bankPk.toString() })
+                    .priceOracle
+                ),
+                isSigner: false,
+                isWritable: false,
+              },
+            ]
+          );
+        }
+      });
+    }
+    if (!this.intermediaryMarginfiAccount || !includedFlashLoanToken) {
+      remainingAccounts.push(
+        ...[
+          {
+            pubkey: fromWeb3JsPublicKey(new PublicKey(bank.bank)),
+            isSigner: false,
+            isWritable: false,
+          },
+          {
+            pubkey: fromWeb3JsPublicKey(new PublicKey(bank.priceOracle)),
+            isSigner: false,
+            isWritable: false,
+          },
+        ]
+      );
+    }
+
+    return transactionBuilder()
+      .add(
+        lendingAccountRepay(this.umi, {
+          amount: flashLoanDetails.baseUnitAmount,
+          repayAll: null,
+          bank: publicKey(bank.bank),
+          bankLiquidityVault: publicKey(bank.liquidityVault),
+          marginfiAccount: publicKey(this.intermediaryMarginfiAccountPk),
+          marginfiGroup: publicKey(DEFAULT_MARGINFI_GROUP),
+          signer: this.signer,
+          signerTokenAccount: publicKey(
+            getTokenAccount(
+              toWeb3JsPublicKey(this.signer.publicKey),
+              flashLoanDetails.mint
+            )
+          ),
+        })
+      )
+      .add(
+        lendingAccountEndFlashloan(this.umi, {
+          marginfiAccount: publicKey(this.intermediaryMarginfiAccountPk),
+          signer: this.signer,
+        }).addRemainingAccounts(remainingAccounts)
+      );
+  }
+
+  createIntermediaryMarginfiAccount(): TransactionBuilder {
+    return marginfiAccountInitialize(this.umi, {
+      marginfiAccount: this.intermediaryMarginfiAccountSigner!,
+      marginfiGroup: publicKey(DEFAULT_MARGINFI_GROUP),
+      authority: this.signer,
+      feePayer: this.signer,
+    });
+  }
+
+  async getFreshPositionState(): Promise<PositionState | undefined> {
+    const state = await super.getFreshPositionState();
+    if (state) {
+      return state;
+    }
+
+    const marginfiAccount = await safeFetchMarginfiAccount(
+      this.umi,
+      publicKey(this.marginfiAccountPk)
+    );
+
+    const freshState = await getMarginfiAccountPositionState(
+      this.supplyLiquidityMint,
+      this.debtLiquidityMint,
+      marginfiAccount,
+      this.livePositionUpdates
+    );
+    this.log(freshState);
+    
+    return freshState;
+  }
+}

package/src/constants/README.md

@@ -0,0 +1,9 @@
+TODO: move this to main readme in root folder when that's ready
+
+Instructions for supporting new token:
+
+- add public key to tokenConstants.ts
+- add price feed in pythConstants.ts for it
+- create ATA for solauto fees wallet
+- `pnpm update-solauto-lut`
+- `pnpm test:ts:unit`

package/src/constants/generalAccounts.ts

@@ -0,0 +1,8 @@
+import { PublicKey } from "@solana/web3.js";
+
+export const USD_DECIMALS = 9;
+
+// TODO
+export const SOLAUTO_FEES_WALLET = new PublicKey("AprYCPiVeKMCgjQ2ZufwChMzvQ5kFjJo2ekTLSkXsQDm");
+
+export const SOLAUTO_MANAGER = new PublicKey("MNGRcX4nc7quPdzBbNKJ4ScK5EE73JnwJVGxuJXhHCY");

package/src/constants/index.ts

@@ -0,0 +1,5 @@
+export * from './generalAccounts';
+export * from './marginfiAccounts';
+export * from './pythConstants';
+export * from './solautoConstants';
+export * from './tokenConstants';

package/src/constants/marginfiAccounts.ts

@@ -0,0 +1,24 @@
+import { NATIVE_MINT } from "@solana/spl-token";
+import { USDC_MINT } from "./tokenConstants";
+import { MarginfiTokenAccounts } from "../types/accounts";
+
+export const DEFAULT_MARGINFI_GROUP = "4qp6Fx6tnZkY5Wropq9wUYgtFxXKwE6viZxFHg3rdAG8";
+
+export const MARGINFI_ACCOUNTS: { [key: string]: MarginfiTokenAccounts } = {
+  SOL: {
+    mint: NATIVE_MINT.toString(),
+    bank: "CCKtUs6Cgwo4aaQUmBPmyoApH2gUDErxNZCAntD6LYGh",
+    liquidityVault: "2eicbpitfJXDwqCuFAmPgDP7t2oUotnAzbGzRKLMgSLe",
+    vaultAuthority: "DD3AeAssFvjqTvRTrRAtpfjkBF8FpVKnFuwnMLN9haXD",
+    priceOracle: "7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE"
+  },
+  USDC: {
+    mint: USDC_MINT,
+    bank: "2s37akK2eyBbp8DZgCm7RtsaEz8eJP3Nxd4urLHQv7yB",
+    liquidityVault: "7jaiZR5Sk8hdYN9MxTpczTcwbWpb5WEoxSANuUwveuat",
+    vaultAuthority: "3uxNepDbmkDNq6JhRja5Z8QwbTrfmkKP8AKZV5chYDGG",
+    priceOracle: "Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX"
+  }
+};
+
+export const MARGINFI_ACCOUNTS_LOOKUP_TABLE = "GAjmWmBPcH5Gxbiykasydj6RsCEaCLyHEvK6kHdFigc6";

package/src/constants/pythConstants.ts

@@ -0,0 +1,10 @@
+import { NATIVE_MINT } from "@solana/spl-token";
+import { USDC_MINT } from "./tokenConstants";
+
+// https://pyth.network/developers/price-feed-ids#solana-stable
+export const PYTH_PRICE_FEED_IDS = {
+  [NATIVE_MINT.toString()]:
+    "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
+  [USDC_MINT]:
+    "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
+};

package/src/constants/solautoConstants.ts

@@ -0,0 +1,54 @@
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+import {
+  SYSVAR_CLOCK_PUBKEY,
+  SYSVAR_RENT_PUBKEY,
+  SystemProgram,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  Connection,
+  PublicKey,
+} from "@solana/web3.js";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} from "@solana/spl-token";
+import { JitoRpcConnection } from "jito-ts";
+import { createSolautoProgram, SOLAUTO_PROGRAM_ID } from "../generated";
+import { SOLAUTO_MANAGER } from "./generalAccounts";
+
+export const DEFAULT_RISK_AVERSION_BPS = 1500;
+export const DEFAULT_LIMIT_GAP_BPS = 1000;
+export const MIN_POSITION_STATE_FRESHNESS_SECS = 5;
+export const MAX_REPAY_GAP_BPS = 100;
+
+export const CONNECTION = new Connection(
+  `https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`,
+  "finalized"
+);
+
+export const JITO_BLOCK_ENGINE = "ny.mainnet.block-engine.jito.wtf";
+export const JITO_CONNECTION = new JitoRpcConnection(
+  `https://${JITO_BLOCK_ENGINE}`,
+  "finalized"
+);
+export const UMI = createUmi(CONNECTION).use({
+  install(umi) {
+    umi.programs.add(createSolautoProgram(), false);
+  },
+});
+
+export const PRICES: { [key: string]: { price: number; time: number; } } = {};
+
+export const JUPITER_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+
+export const STANDARD_LUT_ACCOUNTS = [
+  PublicKey.default.toString(),
+  SOLAUTO_PROGRAM_ID,
+  SOLAUTO_MANAGER.toString(),
+  SystemProgram.programId.toString(),
+  TOKEN_PROGRAM_ID.toString(),
+  ASSOCIATED_TOKEN_PROGRAM_ID.toString(),
+  SYSVAR_CLOCK_PUBKEY.toString(),
+  SYSVAR_RENT_PUBKEY.toString(),
+  SYSVAR_INSTRUCTIONS_PUBKEY.toString(),
+  JUPITER_PROGRAM_ID
+];

package/src/constants/tokenConstants.ts

@@ -0,0 +1,9 @@
+import { NATIVE_MINT } from "@solana/spl-token";
+
+export const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+
+// When adding token ensure a price feed is provided in pythConstants.ts
+export const ALL_SUPPORTED_TOKENS = [
+    NATIVE_MINT.toString(),
+    USDC_MINT,
+];

package/src/generated/accounts/index.ts

@@ -0,0 +1,10 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+export * from './referralState';
+export * from './solautoPosition';