@haven-fi/solauto-sdk 1.0.0

package/src/utils/solanaUtils.ts

@@ -0,0 +1,333 @@
+import fs from "fs";
+import bs58 from "bs58";
+import path from "path";
+import {
+  AddressLookupTableInput,
+  Signer,
+  TransactionBuilder,
+  WrappedInstruction,
+  publicKey,
+  transactionBuilder,
+} from "@metaplex-foundation/umi";
+import {
+  fromWeb3JsInstruction,
+  toWeb3JsPublicKey,
+  toWeb3JsTransaction,
+} from "@metaplex-foundation/umi-web3js-adapters";
+import {
+  AddressLookupTableAccount,
+  ComputeBudgetProgram,
+  PublicKey,
+  RpcResponseAndContext,
+  SimulatedTransactionResponse,
+  SystemProgram,
+  TransactionInstruction,
+  VersionedTransaction,
+  TransactionError,
+} from "@solana/web3.js";
+import {
+  createAssociatedTokenAccountIdempotentInstruction,
+  createCloseAccountInstruction,
+  createTransferInstruction,
+} from "@solana/spl-token";
+import { getTokenAccount } from "./accountUtils";
+import { SolautoClient } from "../clients/solautoClient";
+import { CONNECTION, UMI } from "../constants/solautoConstants";
+import { arraysAreEqual, retryWithExponentialBackoff } from "./generalUtils";
+import {
+  getLendingAccountEndFlashloanInstructionDataSerializer,
+  getLendingAccountStartFlashloanInstructionDataSerializer,
+} from "../marginfi-sdk";
+
+export function loadSecretKey(keypairPath: string) {
+  const secretKey = JSON.parse(fs.readFileSync(keypairPath, "utf8"));
+  return new Uint8Array(secretKey);
+}
+
+export function getSecretKey(keypairFilename: string = "id"): Uint8Array {
+  return loadSecretKey(
+    path.join(process.env.HOME!, ".config", "solana", keypairFilename + ".json")
+  );
+}
+
+export async function currentUnixSecondsSolana(): Promise<number> {
+  return await retryWithExponentialBackoff(async () => {
+    const blockTime = await CONNECTION.getBlockTime(await CONNECTION.getSlot());
+    if (blockTime === null) {
+      throw new Error("Unable to retrieve block time");
+    }
+    return blockTime;
+  });
+}
+
+export function getWrappedInstruction(
+  signer: Signer,
+  ix: TransactionInstruction
+): WrappedInstruction {
+  return {
+    instruction: fromWeb3JsInstruction(ix),
+    signers: [signer],
+    bytesCreatedOnChain: 0,
+  };
+}
+
+export function setComputeUnitLimitUmiIx(
+  signer: Signer,
+  maxComputeUnits: number
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    ComputeBudgetProgram.setComputeUnitLimit({
+      units: maxComputeUnits,
+    })
+  );
+}
+
+export function setComputeUnitPriceUmiIx(
+  signer: Signer,
+  lamports: number
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    ComputeBudgetProgram.setComputeUnitPrice({
+      microLamports: lamports,
+    })
+  );
+}
+
+export function createAssociatedTokenAccountUmiIx(
+  signer: Signer,
+  wallet: PublicKey,
+  mint: PublicKey
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    createAssociatedTokenAccountIdempotentInstruction(
+      toWeb3JsPublicKey(signer.publicKey),
+      getTokenAccount(wallet, mint),
+      wallet,
+      mint
+    )
+  );
+}
+
+export function systemTransferUmiIx(
+  signer: Signer,
+  destination: PublicKey,
+  lamports: bigint
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    SystemProgram.transfer({
+      fromPubkey: toWeb3JsPublicKey(signer.publicKey),
+      toPubkey: destination,
+      lamports,
+    })
+  );
+}
+
+export function closeTokenAccountUmiIx(
+  signer: Signer,
+  tokenAccount: PublicKey,
+  authority: PublicKey
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    createCloseAccountInstruction(tokenAccount, authority, authority)
+  );
+}
+
+export function splTokenTransferUmiIx(
+  signer: Signer,
+  fromTa: PublicKey,
+  toTa: PublicKey,
+  authority: PublicKey,
+  amount: bigint
+): WrappedInstruction {
+  return getWrappedInstruction(
+    signer,
+    createTransferInstruction(fromTa, toTa, authority, amount)
+  );
+}
+
+export async function getAdressLookupInputs(
+  lookupTableAddresses: string[]
+): Promise<AddressLookupTableInput[]> {
+  const addressLookupTableAccountInfos = await UMI.rpc.getAccounts(
+    lookupTableAddresses.map((key) => publicKey(key))
+  );
+
+  return addressLookupTableAccountInfos.reduce((acc, accountInfo, index) => {
+    const addressLookupTableAddress = lookupTableAddresses[index];
+    if (accountInfo.exists) {
+      acc.push({
+        publicKey: publicKey(addressLookupTableAddress),
+        addresses: AddressLookupTableAccount.deserialize(
+          accountInfo.data
+        ).addresses.map((x) => publicKey(x)),
+      } as AddressLookupTableInput);
+    }
+
+    return acc;
+  }, new Array<AddressLookupTableInput>());
+}
+
+export function assembleFinalTransaction(
+  signer: Signer,
+  tx: TransactionBuilder,
+  computeUnitPrice: number,
+  computeUnitLimit?: number
+) {
+  tx = tx
+    .prepend(setComputeUnitPriceUmiIx(signer, computeUnitPrice))
+    .prepend(
+      computeUnitLimit
+        ? setComputeUnitLimitUmiIx(signer, computeUnitLimit)
+        : transactionBuilder()
+    );
+
+  const marginfiStartFlSerializer =
+    getLendingAccountStartFlashloanInstructionDataSerializer();
+  const marginfiStartFlDiscriminator = marginfiStartFlSerializer
+    .serialize({
+      endIndex: 0,
+    })
+    .slice(0, 8);
+
+  const marginfiEndFlSerializer =
+    getLendingAccountEndFlashloanInstructionDataSerializer();
+  const marginfiEndFlDiscriminator = marginfiEndFlSerializer
+    .serialize({
+      endIndex: 0,
+    })
+    .slice(0, 8);
+
+  let endFlIndex = 0;
+  const instructions = tx.getInstructions();
+
+  for (let i = instructions.length - 1; i >= 0; i--) {
+    const ix = instructions[i];
+
+    try {
+      const [data, _] = marginfiStartFlSerializer.deserialize(ix.data);
+      if (
+        arraysAreEqual(
+          data.discriminator,
+          Array.from(marginfiStartFlDiscriminator)
+        )
+      ) {
+        ix.data = marginfiStartFlSerializer.serialize({
+          endIndex: endFlIndex,
+        });
+      }
+    } catch {}
+
+    try {
+      const [data, _] = marginfiEndFlSerializer.deserialize(ix.data);
+      if (
+        arraysAreEqual(
+          data.discriminator,
+          Array.from(marginfiEndFlDiscriminator)
+        )
+      ) {
+        endFlIndex = i;
+      }
+    } catch {}
+  }
+
+  return tx;
+}
+
+async function simulateTransaction(
+  transaction: VersionedTransaction
+): Promise<RpcResponseAndContext<SimulatedTransactionResponse>> {
+  const simulationResult = await CONNECTION.simulateTransaction(transaction, {
+    sigVerify: true,
+  });
+  if (simulationResult.value.err) {
+    simulationResult.value.logs?.forEach((x) => {
+      console.log(x);
+    });
+    throw simulationResult.value.err;
+  }
+  return simulationResult;
+}
+
+export async function getComputeUnitPriceEstimate(
+  tx: TransactionBuilder,
+  attemptNum?: number
+): Promise<number> {
+  const web3Transaction = toWeb3JsTransaction(
+    (await tx.setLatestBlockhash(UMI, { commitment: "finalized" })).build(UMI)
+  );
+  const serializedTransaction = bs58.encode(web3Transaction.serialize());
+  const resp = await UMI.rpc.call("getPriorityFeeEstimate", [
+    {
+      transaction: serializedTransaction,
+      options: { priorityLevel: attemptNum && attemptNum > 0 ? "VeryHigh" : "High" },
+    },
+  ]);
+  const feeEstimate = Math.round((resp as any).priorityFeeEstimate as number);
+  console.log("Compute unit price: ", feeEstimate);
+
+  return feeEstimate;
+}
+
+export async function sendSingleOptimizedTransaction(
+  client: SolautoClient,
+  tx: TransactionBuilder,
+  simulateOnly?: boolean,
+  attemptNum?: number
+): Promise<Uint8Array | undefined> {
+  client.log("Sending single optimized transaction...");
+  client.log("Instructions: ", tx.getInstructions().length);
+  client.log("Serialized transaction size: ", tx.getTransactionSize(UMI));
+
+  const feeEstimate = await getComputeUnitPriceEstimate(tx, attemptNum);
+
+  const simulationResult = await retryWithExponentialBackoff(
+    async () =>
+      await simulateTransaction(
+        toWeb3JsTransaction(
+          await (
+            await assembleFinalTransaction(
+              client.signer,
+              tx,
+              feeEstimate,
+              1_400_000
+            ).setLatestBlockhash(UMI)
+          ).buildAndSign(UMI)
+        )
+      )
+  );
+
+  const computeUnitLimit = Math.round(
+    simulationResult.value.unitsConsumed! * 1.15
+  );
+  console.log("Compute unit limit: ", computeUnitLimit);
+
+  if (!simulateOnly) {
+    const result = await retryWithExponentialBackoff(
+      async () =>
+        await assembleFinalTransaction(
+          client.signer,
+          tx,
+          feeEstimate,
+          computeUnitLimit
+        ).sendAndConfirm(UMI, {
+          send: {
+            skipPreflight: true,
+            commitment: "finalized",
+          },
+          confirm: { commitment: "finalized" },
+        })
+    );
+    client.log(`https://solscan.io/tx/${bs58.encode(result.signature)}`);
+    if (result.result.value.err !== null) {
+      throw new Error(result.result.value.err.toString());
+    }
+    return result.signature;
+  }
+
+  return undefined;
+}

package/src/utils/solauto/generalUtils.ts

@@ -0,0 +1,371 @@
+import { assert } from "chai";
+import { isOption, isSome, PublicKey } from "@metaplex-foundation/umi";
+import {
+  AutomationSettings,
+  DCASettings,
+  DCASettingsInpArgs,
+  FeeType,
+  LendingPlatform,
+  PositionState,
+  SOLAUTO_PROGRAM_ID,
+  SolautoSettingsParameters,
+  SolautoSettingsParametersInpArgs,
+  getReferralStateSize,
+  getSolautoPositionAccountDataSerializer,
+  getSolautoPositionSize,
+} from "../../generated";
+import { currentUnixSeconds } from "../generalUtils";
+import { fromBps, toBps } from "../numberUtils";
+import {
+  MAX_REPAY_GAP_BPS,
+  MIN_POSITION_STATE_FRESHNESS_SECS,
+  UMI,
+} from "../../constants/solautoConstants";
+import { getReferralState } from "../accountUtils";
+import { toWeb3JsPublicKey } from "@metaplex-foundation/umi-web3js-adapters";
+
+function newPeriodsPassed(
+  automation: AutomationSettings,
+  currentUnixTimestamp: number
+): number {
+  return Math.min(
+    automation.targetPeriods,
+    automation.periodsPassed +
+      Math.floor(
+        (currentUnixTimestamp - Number(automation.unixStartDate)) /
+          Number(automation.intervalSeconds)
+      )
+  );
+}
+
+export function nextAutomationPeriodTimestamp(
+  automation: AutomationSettings
+): number {
+  return automation.periodsPassed === 0
+    ? Number(automation.unixStartDate)
+    : Number(automation.unixStartDate) +
+        automation.periodsPassed * Number(automation.intervalSeconds);
+}
+
+export function eligibleForNextAutomationPeriod(
+  automation: AutomationSettings
+): boolean {
+  return currentUnixSeconds() >= nextAutomationPeriodTimestamp(automation);
+}
+
+export function getUpdatedValueFromAutomation(
+  currValue: number,
+  targetValue: number,
+  automation: AutomationSettings,
+  currentUnixTimestamp: number
+) {
+  const currRateDiff = currValue - targetValue;
+  const progressPct =
+    1 /
+    Math.max(
+      1,
+      automation.targetPeriods -
+        newPeriodsPassed(automation, currentUnixTimestamp)
+    );
+  const newValue = currValue - currRateDiff * progressPct;
+  return newValue;
+}
+
+export function getAdjustedSettingsFromAutomation(
+  settings: SolautoSettingsParameters,
+  currentUnixSeconds: number
+): SolautoSettingsParameters {
+  const boostToBps =
+    settings.automation.targetPeriods > 0 &&
+    eligibleForNextAutomationPeriod(settings.automation)
+      ? getUpdatedValueFromAutomation(
+          settings.boostToBps,
+          settings.targetBoostToBps,
+          settings.automation,
+          currentUnixSeconds
+        )
+      : settings.boostToBps;
+
+  return {
+    ...settings,
+    boostToBps,
+  };
+}
+
+export function getSolautoFeesBps(isReferred: boolean, feeType: FeeType): {
+  solauto: number;
+  referrer: number;
+  total: number;
+} {
+  const fees = feeType === FeeType.Small ? 100 : 500;
+  let referrer = 0;
+  if (isReferred) {
+    referrer = fees / 4;
+  }
+
+  return {
+    solauto: fees - referrer,
+    referrer,
+    total: fees,
+  };
+}
+
+export function getMaxLiqUtilizationRate(
+  maxLtvBps: number,
+  liqThresholdBps: number
+): number {
+  return toBps((fromBps(maxLtvBps) - 0.015) / fromBps(liqThresholdBps)) - 1;
+}
+
+export function maxRepayFrom(maxLtvBps: number, liqThresholdBps: number) {
+  return Math.min(9000, getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps - 1000));
+}
+
+export function maxRepayTo(maxLtvBps: number, liqThresholdBps: number) {
+  return Math.min(maxRepayFrom(maxLtvBps, liqThresholdBps) - MAX_REPAY_GAP_BPS, getMaxLiqUtilizationRate(maxLtvBps, liqThresholdBps));
+}
+
+export function eligibileForRebalance(
+  positionState: PositionState,
+  positionSettings: SolautoSettingsParameters,
+  positionDca: DCASettings
+): boolean {
+  if (
+    positionDca.automation.targetPeriods > 0 &&
+    eligibleForNextAutomationPeriod(positionDca.automation)
+  ) {
+    return true;
+  }
+
+  const boostToBps =
+    eligibleForRefresh(positionState, positionSettings) &&
+    positionSettings.automation.targetPeriods > 0
+      ? getUpdatedValueFromAutomation(
+          positionSettings.boostToBps,
+          positionSettings.targetBoostToBps,
+          positionSettings.automation,
+          currentUnixSeconds()
+        )
+      : positionSettings.boostToBps;
+  const repayFrom = positionSettings.repayToBps + positionSettings.repayGap;
+  const boostFrom = boostToBps - positionSettings.boostGap;
+
+  if (positionState.liqUtilizationRateBps <= boostFrom) {
+    return true;
+  } else if (
+    positionState.liqUtilizationRateBps >= repayFrom ||
+    repayFrom - positionState.liqUtilizationRateBps < repayFrom * 0.01
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function eligibleForRefresh(
+  positionState: PositionState,
+  positionSettings: SolautoSettingsParameters
+): boolean {
+  if (positionSettings.automation.targetPeriods > 0) {
+    return eligibleForNextAutomationPeriod(positionSettings.automation);
+  } else {
+    return currentUnixSeconds() - Number(positionState.lastUpdated) > 60 * 60 * 24 * 7;
+  }
+}
+
+export async function getSolautoManagedPositions(
+  authority?: PublicKey
+): Promise<
+  {
+    authority: PublicKey;
+    positionId: number;
+    lendingPlatform: LendingPlatform;
+  }[]
+> {
+  // bump: [u8; 1]
+  // position_id: [u8; 1]
+  // self_managed: u8 - (1 for true, 0 for false)
+  // padding: [u8; 5]
+  // authority: Pubkey
+  // lending_platform: u8
+
+  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+    commitment: "finalized",
+    dataSlice: {
+      offset: 0,
+      length: 1 + 1 + 1 + 5 + 32 + 1, // bump + position_id + self_managed + padding + authority (pubkey) + lending_platform
+    },
+    filters: [
+      {
+        dataSize: getSolautoPositionSize(),
+      },
+      {
+        memcmp: {
+          bytes: new Uint8Array([0]),
+          offset: 2,
+        },
+      },
+      ...(authority
+        ? [
+            {
+              memcmp: {
+                bytes: new Uint8Array(toWeb3JsPublicKey(authority).toBuffer()),
+                offset: 8,
+              },
+            },
+          ]
+        : []),
+    ],
+  });
+
+  return accounts.map((x) => {
+    const [position, _] = getSolautoPositionAccountDataSerializer().deserialize(
+      new Uint8Array([
+        ...x.data,
+        ...Array(getSolautoPositionSize() - x.data.length).fill(0),
+      ])
+    );
+    return {
+      authority: position.authority,
+      positionId: position.positionId[0],
+      lendingPlatform: position.position.lendingPlatform,
+    };
+  });
+}
+
+export async function getAllReferralStates(): Promise<PublicKey[]> {
+  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+    commitment: "finalized",
+    dataSlice: {
+      offset: 0,
+      length: 0,
+    },
+    filters: [
+      {
+        dataSize: getReferralStateSize(),
+      },
+    ],
+  });
+
+  return accounts.map((x) => x.publicKey);
+}
+
+export async function getReferralsByUser(
+  user: PublicKey
+): Promise<PublicKey[]> {
+  // bump: [u8; 1],
+  // padding: [u8; 7],
+  // authority: Pubkey,
+  // referred_by_state: Pubkey,
+
+  const userReferralState = await getReferralState(toWeb3JsPublicKey(user));
+  const accounts = await UMI.rpc.getProgramAccounts(SOLAUTO_PROGRAM_ID, {
+    commitment: "finalized",
+    dataSlice: {
+      offset: 0,
+      length: 0,
+    },
+    filters: [
+      {
+        dataSize: getReferralStateSize(),
+      },
+      {
+        memcmp: {
+          bytes: userReferralState.toBytes(),
+          offset: 1 + 7 + 32, // bump + padding + authority - target the referred_by_state field
+        },
+      },
+    ],
+  });
+
+  return accounts.map((x) => x.publicKey);
+}
+
+type PositionAdjustment =
+  | { type: "supply"; value: bigint }
+  | { type: "debt"; value: bigint }
+  | { type: "debtDcaIn"; value: bigint }
+  | { type: "settings"; value: SolautoSettingsParametersInpArgs }
+  | { type: "dca"; value: DCASettingsInpArgs };
+
+export class LivePositionUpdates {
+  public supplyAdjustment: bigint = BigInt(0);
+  public debtAdjustment: bigint = BigInt(0);
+  public debtTaBalanceAdjustment: bigint = BigInt(0);
+  public settings: SolautoSettingsParameters | undefined = undefined;
+  public activeDca: DCASettings | undefined = undefined;
+
+  new(update: PositionAdjustment) {
+    if (update.type === "supply") {
+      this.supplyAdjustment += update.value;
+    } else if (update.type === "debt") {
+      this.debtAdjustment += update.value;
+    } else if (update.type === "debtDcaIn") {
+      this.debtTaBalanceAdjustment += update.value;
+    } else if (update.type === "settings") {
+      const settings = update.value;
+      this.settings = {
+        automation:
+          isOption(settings.automation) && isSome(settings.automation)
+            ? {
+                ...settings.automation.value,
+                intervalSeconds: BigInt(
+                  settings.automation.value.intervalSeconds
+                ),
+                unixStartDate: BigInt(settings.automation.value.unixStartDate),
+                padding: new Uint8Array([]),
+                padding1: [],
+              }
+            : {
+                targetPeriods: 0,
+                periodsPassed: 0,
+                intervalSeconds: BigInt(0),
+                unixStartDate: BigInt(0),
+                padding: new Uint8Array([]),
+                padding1: [],
+              },
+        targetBoostToBps:
+          isOption(settings.targetBoostToBps) &&
+          isSome(settings.targetBoostToBps)
+            ? settings.targetBoostToBps.value
+            : 0,
+        boostGap: settings.boostGap,
+        boostToBps: settings.boostToBps,
+        repayGap: settings.repayGap,
+        repayToBps: settings.repayToBps,
+        padding: new Uint8Array([]),
+        padding1: [],
+      };
+    } else if (update.type === "dca") {
+      const dca = update.value;
+      this.activeDca = {
+        automation: {
+          ...dca.automation,
+          intervalSeconds: BigInt(dca.automation.intervalSeconds),
+          unixStartDate: BigInt(dca.automation.unixStartDate),
+          padding: new Uint8Array([]),
+          padding1: [],
+        },
+        debtToAddBaseUnit: BigInt(dca.debtToAddBaseUnit),
+        padding: new Uint8Array([]),
+      };
+    }
+  }
+
+  reset() {
+    this.supplyAdjustment = BigInt(0);
+    this.debtAdjustment = BigInt(0);
+    this.debtTaBalanceAdjustment = BigInt(0);
+    this.settings = undefined;
+    this.activeDca = undefined;
+  }
+
+  hasUpdates(): boolean {
+    return (
+      this.supplyAdjustment !== BigInt(0) ||
+      this.debtAdjustment !== BigInt(0) ||
+      this.debtTaBalanceAdjustment !== BigInt(0) ||
+      this.settings !== undefined
+    );
+  }
+}

package/src/utils/solauto/index.ts

@@ -0,0 +1,2 @@
+export * from './generalUtils';
+export * from './rebalanceUtils';