@epicentral/sos-sdk 0.1.0

package/short/builders.ts

@@ -0,0 +1,268 @@
+import {
+  getOptionMintInstructionAsync,
+  getSettleMakerCollateralInstructionAsync,
+  getSyncWriterPositionInstruction,
+  getUnwindWriterUnsoldInstructionAsync,
+  type OptionType,
+} from "../generated";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction } from "../client/types";
+import { deriveMakerCollateralSharePda, deriveMetadataPda } from "../accounts/pdas";
+import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
+import { invariant } from "../shared/errors";
+import {
+  appendRemainingAccounts,
+  type RemainingAccountInput,
+} from "../shared/remaining-accounts";
+
+export interface BuildOptionMintParams {
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  quantity: bigint | number;
+  underlyingAsset: AddressLike;
+  underlyingSymbol: string;
+  makerCollateralAmount: bigint | number;
+  borrowedAmount: bigint | number;
+  maker: AddressLike;
+  makerCollateralAccount: AddressLike;
+  underlyingMint: AddressLike;
+  longMetadataAccount?: AddressLike;
+  shortMetadataAccount?: AddressLike;
+  optionAccount?: AddressLike;
+  longMint?: AddressLike;
+  shortMint?: AddressLike;
+  mintAuthority?: AddressLike;
+  makerLongAccount?: AddressLike;
+  makerShortAccount?: AddressLike;
+  marketData?: AddressLike;
+  optionPool?: AddressLike;
+  escrowLongAccount?: AddressLike;
+  premiumVault?: AddressLike;
+  collateralPool?: AddressLike;
+  collateralVault?: AddressLike;
+  writerPosition?: AddressLike;
+  vault?: AddressLike;
+  vaultTokenAccount?: AddressLike;
+  escrowState?: AddressLike;
+  escrowAuthority?: AddressLike;
+  escrowTokenAccount?: AddressLike;
+  poolLoan?: AddressLike;
+  liquidityRouter?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export interface BuildUnwindWriterUnsoldParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  longMint: AddressLike;
+  shortMint: AddressLike;
+  escrowLongAccount: AddressLike;
+  writerShortAccount: AddressLike;
+  collateralVault: AddressLike;
+  writerCollateralAccount: AddressLike;
+  writer: AddressLike;
+  unwindQty: bigint | number;
+  collateralPool?: AddressLike;
+  writerPosition?: AddressLike;
+  omlpVault?: AddressLike;
+  feeWallet?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export interface BuildSyncWriterPositionParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  writerPosition: AddressLike;
+}
+
+export interface BuildSettleMakerCollateralParams {
+  optionAccount: AddressLike;
+  collateralVault: AddressLike;
+  makerCollateralAccount: AddressLike;
+  omlpVault: AddressLike;
+  poolLoan: AddressLike;
+  maker: AddressLike;
+  makerCollateralShare?: AddressLike;
+  collateralPool?: AddressLike;
+}
+
+export async function buildOptionMintInstruction(
+  params: BuildOptionMintParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.quantity, "quantity");
+  assertNonNegativeAmount(params.makerCollateralAmount, "makerCollateralAmount");
+  assertNonNegativeAmount(params.borrowedAmount, "borrowedAmount");
+  invariant(params.strikePrice > 0, "strikePrice must be greater than zero.");
+  invariant(params.underlyingSymbol.length > 0, "underlyingSymbol is required.");
+
+  const borrowedAmount = BigInt(params.borrowedAmount);
+  if (borrowedAmount > 0n) {
+    invariant(!!params.vault, "vault is required when borrowedAmount > 0");
+    invariant(
+      !!params.vaultTokenAccount,
+      "vaultTokenAccount is required when borrowedAmount > 0"
+    );
+    invariant(!!params.escrowState, "escrowState is required when borrowedAmount > 0");
+    invariant(
+      !!params.escrowAuthority,
+      "escrowAuthority is required when borrowedAmount > 0"
+    );
+    invariant(
+      !!params.escrowTokenAccount,
+      "escrowTokenAccount is required when borrowedAmount > 0"
+    );
+    invariant(!!params.poolLoan, "poolLoan is required when borrowedAmount > 0");
+  }
+
+  const [derivedLongMetadata, derivedShortMetadata] = await Promise.all([
+    params.longMint ? deriveMetadataPda(params.longMint) : Promise.resolve(undefined),
+    params.shortMint ? deriveMetadataPda(params.shortMint) : Promise.resolve(undefined),
+  ]);
+  const longMetadata = params.longMetadataAccount ?? derivedLongMetadata?.[0];
+  const shortMetadata = params.shortMetadataAccount ?? derivedShortMetadata?.[0];
+
+  invariant(
+    !!longMetadata && !!shortMetadata,
+    "longMetadataAccount and shortMetadataAccount are required (or provide longMint/shortMint to derive)."
+  );
+
+  const kitInstruction = await getOptionMintInstructionAsync({
+    optionAccount: params.optionAccount ? toAddress(params.optionAccount) : undefined,
+    longMint: params.longMint ? toAddress(params.longMint) : undefined,
+    shortMint: params.shortMint ? toAddress(params.shortMint) : undefined,
+    mintAuthority: params.mintAuthority ? toAddress(params.mintAuthority) : undefined,
+    makerLongAccount: params.makerLongAccount
+      ? toAddress(params.makerLongAccount)
+      : undefined,
+    makerShortAccount: params.makerShortAccount
+      ? toAddress(params.makerShortAccount)
+      : undefined,
+    longMetadataAccount: toAddress(longMetadata!),
+    shortMetadataAccount: toAddress(shortMetadata!),
+    marketData: params.marketData ? toAddress(params.marketData) : undefined,
+    underlyingMint: toAddress(params.underlyingMint),
+    optionPool: params.optionPool ? toAddress(params.optionPool) : undefined,
+    escrowLongAccount: params.escrowLongAccount
+      ? toAddress(params.escrowLongAccount)
+      : undefined,
+    premiumVault: params.premiumVault ? toAddress(params.premiumVault) : undefined,
+    collateralPool: params.collateralPool ? toAddress(params.collateralPool) : undefined,
+    collateralVault: params.collateralVault ? toAddress(params.collateralVault) : undefined,
+    makerCollateralAccount: toAddress(params.makerCollateralAccount),
+    writerPosition: params.writerPosition ? toAddress(params.writerPosition) : undefined,
+    vault: params.vault ? toAddress(params.vault) : undefined,
+    vaultTokenAccount: params.vaultTokenAccount
+      ? toAddress(params.vaultTokenAccount)
+      : undefined,
+    escrowState: params.escrowState ? toAddress(params.escrowState) : undefined,
+    escrowAuthority: params.escrowAuthority ? toAddress(params.escrowAuthority) : undefined,
+    escrowTokenAccount: params.escrowTokenAccount
+      ? toAddress(params.escrowTokenAccount)
+      : undefined,
+    poolLoan: params.poolLoan ? toAddress(params.poolLoan) : undefined,
+    liquidityRouter: params.liquidityRouter ? toAddress(params.liquidityRouter) : undefined,
+    maker: toAddress(params.maker) as any,
+    optionType: params.optionType,
+    strikePrice: params.strikePrice,
+    expirationDate: params.expirationDate,
+    quantity: params.quantity,
+    underlyingAsset: toAddress(params.underlyingAsset),
+    underlyingSymbol: params.underlyingSymbol,
+    makerCollateralAmount: params.makerCollateralAmount,
+    borrowedAmount: params.borrowedAmount,
+  });
+
+  return appendRemainingAccounts(kitInstruction, params.remainingAccounts);
+}
+
+export async function buildOptionMintTransaction(
+  params: BuildOptionMintParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildOptionMintInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildUnwindWriterUnsoldInstruction(
+  params: BuildUnwindWriterUnsoldParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.unwindQty, "unwindQty");
+
+  const kitInstruction = await getUnwindWriterUnsoldInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    collateralPool: params.collateralPool ? toAddress(params.collateralPool) : undefined,
+    writerPosition: params.writerPosition ? toAddress(params.writerPosition) : undefined,
+    longMint: toAddress(params.longMint),
+    shortMint: toAddress(params.shortMint),
+    escrowLongAccount: toAddress(params.escrowLongAccount),
+    writerShortAccount: toAddress(params.writerShortAccount),
+    collateralVault: toAddress(params.collateralVault),
+    writerCollateralAccount: toAddress(params.writerCollateralAccount),
+    omlpVault: params.omlpVault ? toAddress(params.omlpVault) : undefined,
+    feeWallet: params.feeWallet ? toAddress(params.feeWallet) : undefined,
+    writer: toAddress(params.writer) as any,
+    unwindQty: params.unwindQty,
+  });
+
+  return appendRemainingAccounts(kitInstruction, params.remainingAccounts);
+}
+
+export async function buildUnwindWriterUnsoldTransaction(
+  params: BuildUnwindWriterUnsoldParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildUnwindWriterUnsoldInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export function buildSyncWriterPositionInstruction(
+  params: BuildSyncWriterPositionParams
+): Instruction<string> {
+  const kitInstruction = getSyncWriterPositionInstruction({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    writerPosition: toAddress(params.writerPosition),
+  });
+  return kitInstruction;
+}
+
+export function buildSyncWriterPositionTransaction(
+  params: BuildSyncWriterPositionParams
+): BuiltTransaction {
+  const instruction = buildSyncWriterPositionInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildSettleMakerCollateralInstruction(
+  params: BuildSettleMakerCollateralParams
+): Promise<Instruction<string>> {
+  const makerCollateralShare =
+    params.makerCollateralShare ??
+    (params.collateralPool
+      ? (await deriveMakerCollateralSharePda(params.collateralPool, params.maker))[0]
+      : undefined);
+
+  invariant(
+    !!makerCollateralShare,
+    "makerCollateralShare is required (or provide collateralPool + maker to derive)."
+  );
+
+  const kitInstruction = await getSettleMakerCollateralInstructionAsync({
+    optionAccount: toAddress(params.optionAccount),
+    collateralPool: params.collateralPool ? toAddress(params.collateralPool) : undefined,
+    makerCollateralShare: toAddress(makerCollateralShare),
+    collateralVault: toAddress(params.collateralVault),
+    makerCollateralAccount: toAddress(params.makerCollateralAccount),
+    omlpVault: toAddress(params.omlpVault),
+    poolLoan: toAddress(params.poolLoan),
+  });
+  return kitInstruction;
+}
+
+export async function buildSettleMakerCollateralTransaction(
+  params: BuildSettleMakerCollateralParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildSettleMakerCollateralInstruction(params);
+  return { instructions: [instruction] };
+}

package/short/claim-premium.ts

@@ -0,0 +1,37 @@
+import { getClaimPremiumInstructionAsync } from "../generated/instructions";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction } from "../client/types";
+
+export interface BuildClaimPremiumParams {
+  optionPool: AddressLike;
+  makerPaymentAccount: AddressLike;
+  premiumVault: AddressLike;
+  maker: AddressLike;
+  makerPoolShare?: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export async function buildClaimPremiumInstruction(
+  params: BuildClaimPremiumParams
+): Promise<Instruction<string>> {
+  return getClaimPremiumInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
+    makerPaymentAccount: toAddress(params.makerPaymentAccount),
+    premiumVault: toAddress(params.premiumVault),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+  });
+}
+
+/**
+ * Builds a premium claim transaction for a maker's pool share.
+ * `makerPoolShare` is optional and can be derived by the generated instruction helper.
+ */
+export async function buildClaimPremiumTransaction(
+  params: BuildClaimPremiumParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildClaimPremiumInstruction(params);
+  return { instructions: [instruction] };
+}

package/short/close-option.ts

@@ -0,0 +1,34 @@
+import { getCloseOptionInstruction } from "../generated/instructions";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction } from "../client/types";
+
+export interface BuildCloseOptionParams {
+  optionAccount: AddressLike;
+  optionMint: AddressLike;
+  makerOptionAccount: AddressLike;
+  maker: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export function buildCloseOptionInstruction(
+  params: BuildCloseOptionParams
+): Instruction<string> {
+  return getCloseOptionInstruction({
+    optionAccount: toAddress(params.optionAccount),
+    optionMint: toAddress(params.optionMint),
+    makerOptionAccount: toAddress(params.makerOptionAccount),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+  });
+}
+
+/**
+ * Builds the close-option transaction instruction set for a maker.
+ */
+export function buildCloseOptionTransaction(
+  params: BuildCloseOptionParams
+): BuiltTransaction {
+  const instruction = buildCloseOptionInstruction(params);
+  return { instructions: [instruction] };
+}

package/short/pool.ts

@@ -0,0 +1,224 @@
+import {
+  getBorrowFromPoolInstructionAsync,
+  getDepositToPoolInstructionAsync,
+  getRepayPoolLoanInstructionAsync,
+  getRepayPoolLoanFromCollateralInstructionAsync,
+  getWithdrawFromPoolInstructionAsync,
+} from "../generated/instructions";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction } from "../client/types";
+import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
+
+export interface BuildDepositToPoolParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  makerOptionAccount: AddressLike;
+  escrowLongAccount: AddressLike;
+  maker: AddressLike;
+  amount: bigint | number;
+  makerPoolShare?: AddressLike;
+  tokenProgram?: AddressLike;
+  associatedTokenProgram?: AddressLike;
+  systemProgram?: AddressLike;
+}
+
+export interface BuildWithdrawFromPoolParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  makerOptionAccount: AddressLike;
+  escrowLongAccount: AddressLike;
+  maker: AddressLike;
+  amount: bigint | number;
+  makerPoolShare?: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export interface BuildBorrowFromPoolParams {
+  vault: AddressLike;
+  vaultTokenAccount: AddressLike;
+  escrowTokenAccount: AddressLike;
+  collateralMint: AddressLike;
+  maker: AddressLike;
+  nonce: bigint | number;
+  borrowAmount: bigint | number;
+  collateralAmount: bigint | number;
+  poolLoan?: AddressLike;
+  escrowState?: AddressLike;
+  escrowAuthority?: AddressLike;
+  tokenProgram?: AddressLike;
+  systemProgram?: AddressLike;
+}
+
+export interface BuildRepayPoolLoanParams {
+  poolLoan: AddressLike;
+  vault: AddressLike;
+  vaultTokenAccount: AddressLike;
+  escrowState: AddressLike;
+  escrowTokenAccount: AddressLike;
+  makerTokenAccount: AddressLike;
+  feeWalletTokenAccount: AddressLike;
+  maker: AddressLike;
+  escrowAuthority?: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export interface BuildRepayPoolLoanFromCollateralParams {
+  poolLoan: AddressLike;
+  vault: AddressLike;
+  vaultTokenAccount: AddressLike;
+  optionAccount: AddressLike;
+  optionPool: AddressLike;
+  collateralVault: AddressLike;
+  writerPosition: AddressLike;
+  feeWalletTokenAccount: AddressLike;
+  maker: AddressLike;
+  collateralPool?: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export async function buildDepositToPoolInstruction(
+  params: BuildDepositToPoolParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.amount, "amount");
+
+  return getDepositToPoolInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
+    makerOptionAccount: toAddress(params.makerOptionAccount),
+    escrowLongAccount: toAddress(params.escrowLongAccount),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+    associatedTokenProgram: params.associatedTokenProgram
+      ? toAddress(params.associatedTokenProgram)
+      : undefined,
+    systemProgram: params.systemProgram ? toAddress(params.systemProgram) : undefined,
+    amount: params.amount,
+  });
+}
+
+export async function buildDepositToPoolTransaction(
+  params: BuildDepositToPoolParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildDepositToPoolInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildWithdrawFromPoolInstruction(
+  params: BuildWithdrawFromPoolParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.amount, "amount");
+
+  return getWithdrawFromPoolInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
+    makerOptionAccount: toAddress(params.makerOptionAccount),
+    escrowLongAccount: toAddress(params.escrowLongAccount),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+    amount: params.amount,
+  });
+}
+
+/**
+ * Builds a pool withdraw instruction set for an LP maker position.
+ */
+export async function buildWithdrawFromPoolTransaction(
+  params: BuildWithdrawFromPoolParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildWithdrawFromPoolInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildBorrowFromPoolInstruction(
+  params: BuildBorrowFromPoolParams
+): Promise<Instruction<string>> {
+  assertNonNegativeAmount(params.nonce, "nonce");
+  assertPositiveAmount(params.borrowAmount, "borrowAmount");
+  assertPositiveAmount(params.collateralAmount, "collateralAmount");
+
+  return getBorrowFromPoolInstructionAsync({
+    poolLoan: params.poolLoan ? toAddress(params.poolLoan) : undefined,
+    vault: toAddress(params.vault),
+    vaultTokenAccount: toAddress(params.vaultTokenAccount),
+    escrowState: params.escrowState ? toAddress(params.escrowState) : undefined,
+    escrowAuthority: params.escrowAuthority ? toAddress(params.escrowAuthority) : undefined,
+    escrowTokenAccount: toAddress(params.escrowTokenAccount),
+    collateralMint: toAddress(params.collateralMint),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+    systemProgram: params.systemProgram ? toAddress(params.systemProgram) : undefined,
+    nonce: params.nonce,
+    borrowAmount: params.borrowAmount,
+    collateralAmount: params.collateralAmount,
+  });
+}
+
+/**
+ * Builds the borrow transaction instruction set for pool leverage.
+ */
+export async function buildBorrowFromPoolTransaction(
+  params: BuildBorrowFromPoolParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildBorrowFromPoolInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildRepayPoolLoanInstruction(
+  params: BuildRepayPoolLoanParams
+): Promise<Instruction<string>> {
+  return getRepayPoolLoanInstructionAsync({
+    poolLoan: toAddress(params.poolLoan),
+    vault: toAddress(params.vault),
+    vaultTokenAccount: toAddress(params.vaultTokenAccount),
+    escrowState: toAddress(params.escrowState),
+    escrowAuthority: params.escrowAuthority
+      ? toAddress(params.escrowAuthority)
+      : undefined,
+    escrowTokenAccount: toAddress(params.escrowTokenAccount),
+    makerTokenAccount: toAddress(params.makerTokenAccount),
+    feeWalletTokenAccount: toAddress(params.feeWalletTokenAccount),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+  });
+}
+
+/**
+ * Builds the repay loan instruction set.
+ */
+export async function buildRepayPoolLoanTransaction(
+  params: BuildRepayPoolLoanParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildRepayPoolLoanInstruction(params);
+  return { instructions: [instruction] };
+}
+
+export async function buildRepayPoolLoanFromCollateralInstruction(
+  params: BuildRepayPoolLoanFromCollateralParams
+): Promise<Instruction<string>> {
+  return getRepayPoolLoanFromCollateralInstructionAsync({
+    poolLoan: toAddress(params.poolLoan),
+    vault: toAddress(params.vault),
+    vaultTokenAccount: toAddress(params.vaultTokenAccount),
+    optionAccount: toAddress(params.optionAccount),
+    optionPool: toAddress(params.optionPool),
+    collateralPool: params.collateralPool ? toAddress(params.collateralPool) : undefined,
+    collateralVault: toAddress(params.collateralVault),
+    writerPosition: toAddress(params.writerPosition),
+    feeWalletTokenAccount: toAddress(params.feeWalletTokenAccount),
+    maker: toAddress(params.maker) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+  });
+}
+
+/**
+ * Builds the repay-from-collateral instruction set.
+ */
+export async function buildRepayPoolLoanFromCollateralTransaction(
+  params: BuildRepayPoolLoanFromCollateralParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildRepayPoolLoanFromCollateralInstruction(params);
+  return { instructions: [instruction] };
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "es2022",
+    "target": "es2020",
+    "moduleResolution": "node",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}