@epicentral/sos-sdk 0.1.0

package/accounts/pdas.ts

@@ -0,0 +1,308 @@
+import { address, getAddressEncoder, getProgramDerivedAddress, type Address } from "@solana/kit";
+import { OptionType } from "../generated/types";
+import { PROGRAM_ID, toAddress } from "../client/program";
+import type { AddressLike } from "../client/types";
+
+const METADATA_PROGRAM_ADDRESS = address("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+const TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+
+function f64ToLeBytes(value: number): Uint8Array {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setFloat64(0, value, true);
+  return bytes;
+}
+
+function i64ToLeBytes(value: bigint | number): Uint8Array {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setBigInt64(0, BigInt(value), true);
+  return bytes;
+}
+
+function u64ToLeBytes(value: bigint | number): Uint8Array {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setBigUint64(0, BigInt(value), true);
+  return bytes;
+}
+
+function optionTypeToU8(optionType: OptionType): number {
+  return optionType === OptionType.Call ? 0 : 1;
+}
+
+export async function deriveOptionAccountPda(params: {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  programId?: AddressLike;
+}): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  const programAddress = params.programId ? toAddress(params.programId) : PROGRAM_ID;
+  return getProgramDerivedAddress({
+    programAddress,
+    seeds: [
+      new TextEncoder().encode("option"),
+      addressEncoder.encode(toAddress(params.underlyingAsset)),
+      Uint8Array.of(optionTypeToU8(params.optionType)),
+      f64ToLeBytes(params.strikePrice),
+      i64ToLeBytes(params.expirationDate),
+    ],
+  });
+}
+
+export async function deriveLongMintPda(
+  optionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("long_mint"),
+      addressEncoder.encode(toAddress(optionAccount)),
+    ],
+  });
+}
+
+export async function deriveShortMintPda(
+  optionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("short_mint"),
+      addressEncoder.encode(toAddress(optionAccount)),
+    ],
+  });
+}
+
+export async function deriveMintAuthorityPda(
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [new TextEncoder().encode("mint_authority")],
+  });
+}
+
+export async function deriveConfigPda(
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [new TextEncoder().encode("config")],
+  });
+}
+
+export async function deriveOptionPoolPda(
+  optionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("option_pool"),
+      addressEncoder.encode(toAddress(optionAccount)),
+    ],
+  });
+}
+
+export async function deriveCollateralPoolPda(
+  optionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("collateral_pool"),
+      addressEncoder.encode(toAddress(optionAccount)),
+    ],
+  });
+}
+
+export async function deriveWriterPositionPda(
+  optionPool: AddressLike,
+  writer: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("writer_position"),
+      addressEncoder.encode(toAddress(optionPool)),
+      addressEncoder.encode(toAddress(writer)),
+    ],
+  });
+}
+
+export async function deriveMakerCollateralSharePda(
+  collateralPool: AddressLike,
+  maker: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("maker_collateral_share"),
+      addressEncoder.encode(toAddress(collateralPool)),
+      addressEncoder.encode(toAddress(maker)),
+    ],
+  });
+}
+
+export async function deriveMakerPoolSharePda(
+  optionPool: AddressLike,
+  maker: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("maker_pool_share"),
+      addressEncoder.encode(toAddress(optionPool)),
+      addressEncoder.encode(toAddress(maker)),
+    ],
+  });
+}
+
+export async function deriveBuyerPositionPda(
+  buyer: AddressLike,
+  optionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("position"),
+      addressEncoder.encode(toAddress(buyer)),
+      addressEncoder.encode(toAddress(optionAccount)),
+    ],
+  });
+}
+
+export async function deriveMetadataPda(mint: AddressLike): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: METADATA_PROGRAM_ADDRESS,
+    seeds: [
+      new TextEncoder().encode("metadata"),
+      addressEncoder.encode(METADATA_PROGRAM_ADDRESS),
+      addressEncoder.encode(toAddress(mint)),
+    ],
+  });
+}
+
+export async function deriveMarketDataPda(
+  underlyingAsset: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("market_data"),
+      addressEncoder.encode(toAddress(underlyingAsset)),
+    ],
+  });
+}
+
+export async function deriveVaultPda(
+  mint: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [new TextEncoder().encode("vault"), addressEncoder.encode(toAddress(mint))],
+  });
+}
+
+export async function deriveLenderPositionPda(
+  vault: AddressLike,
+  lender: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("lender_position"),
+      addressEncoder.encode(toAddress(vault)),
+      addressEncoder.encode(toAddress(lender)),
+    ],
+  });
+}
+
+export async function deriveEscrowStatePda(
+  maker: AddressLike,
+  collateralMint: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("escrow_v2"),
+      addressEncoder.encode(toAddress(maker)),
+      addressEncoder.encode(toAddress(collateralMint)),
+    ],
+  });
+}
+
+export async function deriveEscrowAuthorityPda(
+  escrowState: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("escrow_authority_v2"),
+      addressEncoder.encode(toAddress(escrowState)),
+    ],
+  });
+}
+
+export async function derivePoolLoanPda(
+  writerPosition: AddressLike,
+  nonce: bigint | number,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("pool_loan"),
+      addressEncoder.encode(toAddress(writerPosition)),
+      u64ToLeBytes(nonce),
+    ],
+  });
+}
+
+export async function deriveAssociatedTokenAddress(
+  owner: AddressLike,
+  mint: AddressLike,
+  _allowOwnerOffCurve = false
+): Promise<Address> {
+  const addressEncoder = getAddressEncoder();
+  const [associatedTokenAddress] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(toAddress(owner)),
+      addressEncoder.encode(TOKEN_PROGRAM_ADDRESS),
+      addressEncoder.encode(toAddress(mint)),
+    ],
+  });
+  return associatedTokenAddress;
+}

package/client/lookup-table.ts

@@ -0,0 +1,32 @@
+import { address, type Address } from "@solana/kit";
+import type { KitRpc } from "./types";
+
+export const LOOKUP_TABLE_ADDRESSES: Record<"devnet" | "mainnet", Address | null> = {
+  devnet: address("HsoWoDfW4yXVaXE31tEz167cjQn79TeXYxggSrXvRvri"),
+  mainnet: null,
+};
+
+export const LOOKUP_TABLE_ADDRESS: Address | null = LOOKUP_TABLE_ADDRESSES.devnet;
+
+export function detectNetwork(rpcUrl: string): "devnet" | "mainnet" {
+  const lower = rpcUrl.toLowerCase();
+  return lower.includes("mainnet") ? "mainnet" : "devnet";
+}
+
+export function getLookupTableAddressForNetwork(
+  network: "devnet" | "mainnet"
+): Address | null {
+  return LOOKUP_TABLE_ADDRESSES[network];
+}
+
+export async function getLookupTableAccount(
+  rpc: KitRpc,
+  lookupTableAddress: Address | null
+): Promise<unknown | null> {
+  if (!lookupTableAddress) return null;
+  const rpcWithLookupTable = rpc as KitRpc & {
+    getAddressLookupTable: (address: Address) => { send: () => Promise<{ value: unknown | null }> };
+  };
+  const result = await rpcWithLookupTable.getAddressLookupTable(lookupTableAddress).send();
+  return result.value ?? null;
+}

package/client/program.ts

@@ -0,0 +1,13 @@
+import { address, type Address } from "@solana/kit";
+import { OPTION_PROGRAM_PROGRAM_ADDRESS } from "../generated/programs";
+import type { AddressLike } from "./types";
+
+export const PROGRAM_ADDRESS = OPTION_PROGRAM_PROGRAM_ADDRESS;
+export const PROGRAM_ID = address(OPTION_PROGRAM_PROGRAM_ADDRESS);
+export const getProgramId = (): Address => PROGRAM_ID;
+export const getProgramIdString = (): string => PROGRAM_ID;
+
+export function toAddress(value: AddressLike): Address {
+  return typeof value === "string" ? address(value) : value;
+}
+export { address };

package/client/types.ts

@@ -0,0 +1,8 @@
+import type { Address, Instruction, Rpc, SolanaRpcApi } from "@solana/kit";
+
+export type AddressLike = Address | string;
+export type KitRpc = Rpc<SolanaRpcApi>;
+
+export interface BuiltTransaction {
+  instructions: Instruction<string>[];
+}

package/generated/accounts/collateralPool.ts

@@ -0,0 +1,217 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBooleanDecoder,
+  getBooleanEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getI64Decoder,
+  getI64Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder,
+  type Account,
+  type Address,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const COLLATERAL_POOL_DISCRIMINATOR = new Uint8Array([
+  186, 4, 253, 240, 93, 243, 212, 195,
+]);
+
+export function getCollateralPoolDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    COLLATERAL_POOL_DISCRIMINATOR,
+  );
+}
+
+export type CollateralPool = {
+  discriminator: ReadonlyUint8Array;
+  optionAccount: Address;
+  collateralMint: Address;
+  collateralVault: Address;
+  totalCollateral: bigint;
+  totalMakerContribution: bigint;
+  totalBorrowed: bigint;
+  totalInterestOwed: bigint;
+  totalExercisedValue: bigint;
+  totalLenderRepaid: bigint;
+  totalMakerReturned: bigint;
+  makerCount: number;
+  isExercised: boolean;
+  isFullySettled: boolean;
+  createdAt: bigint;
+  lastUpdated: bigint;
+  bump: number;
+};
+
+export type CollateralPoolArgs = {
+  optionAccount: Address;
+  collateralMint: Address;
+  collateralVault: Address;
+  totalCollateral: number | bigint;
+  totalMakerContribution: number | bigint;
+  totalBorrowed: number | bigint;
+  totalInterestOwed: number | bigint;
+  totalExercisedValue: number | bigint;
+  totalLenderRepaid: number | bigint;
+  totalMakerReturned: number | bigint;
+  makerCount: number;
+  isExercised: boolean;
+  isFullySettled: boolean;
+  createdAt: number | bigint;
+  lastUpdated: number | bigint;
+  bump: number;
+};
+
+/** Gets the encoder for {@link CollateralPoolArgs} account data. */
+export function getCollateralPoolEncoder(): FixedSizeEncoder<CollateralPoolArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["optionAccount", getAddressEncoder()],
+      ["collateralMint", getAddressEncoder()],
+      ["collateralVault", getAddressEncoder()],
+      ["totalCollateral", getU64Encoder()],
+      ["totalMakerContribution", getU64Encoder()],
+      ["totalBorrowed", getU64Encoder()],
+      ["totalInterestOwed", getU64Encoder()],
+      ["totalExercisedValue", getU64Encoder()],
+      ["totalLenderRepaid", getU64Encoder()],
+      ["totalMakerReturned", getU64Encoder()],
+      ["makerCount", getU32Encoder()],
+      ["isExercised", getBooleanEncoder()],
+      ["isFullySettled", getBooleanEncoder()],
+      ["createdAt", getI64Encoder()],
+      ["lastUpdated", getI64Encoder()],
+      ["bump", getU8Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: COLLATERAL_POOL_DISCRIMINATOR }),
+  );
+}
+
+/** Gets the decoder for {@link CollateralPool} account data. */
+export function getCollateralPoolDecoder(): FixedSizeDecoder<CollateralPool> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["optionAccount", getAddressDecoder()],
+    ["collateralMint", getAddressDecoder()],
+    ["collateralVault", getAddressDecoder()],
+    ["totalCollateral", getU64Decoder()],
+    ["totalMakerContribution", getU64Decoder()],
+    ["totalBorrowed", getU64Decoder()],
+    ["totalInterestOwed", getU64Decoder()],
+    ["totalExercisedValue", getU64Decoder()],
+    ["totalLenderRepaid", getU64Decoder()],
+    ["totalMakerReturned", getU64Decoder()],
+    ["makerCount", getU32Decoder()],
+    ["isExercised", getBooleanDecoder()],
+    ["isFullySettled", getBooleanDecoder()],
+    ["createdAt", getI64Decoder()],
+    ["lastUpdated", getI64Decoder()],
+    ["bump", getU8Decoder()],
+  ]);
+}
+
+/** Gets the codec for {@link CollateralPool} account data. */
+export function getCollateralPoolCodec(): FixedSizeCodec<
+  CollateralPoolArgs,
+  CollateralPool
+> {
+  return combineCodec(getCollateralPoolEncoder(), getCollateralPoolDecoder());
+}
+
+export function decodeCollateralPool<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<CollateralPool, TAddress>;
+export function decodeCollateralPool<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<CollateralPool, TAddress>;
+export function decodeCollateralPool<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<CollateralPool, TAddress> | MaybeAccount<CollateralPool, TAddress> {
+  return decodeAccount(
+    encodedAccount as MaybeEncodedAccount<TAddress>,
+    getCollateralPoolDecoder(),
+  );
+}
+
+export async function fetchCollateralPool<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<CollateralPool, TAddress>> {
+  const maybeAccount = await fetchMaybeCollateralPool(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeCollateralPool<
+  TAddress extends string = string,
+>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<CollateralPool, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeCollateralPool(maybeAccount);
+}
+
+export async function fetchAllCollateralPool(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<CollateralPool>[]> {
+  const maybeAccounts = await fetchAllMaybeCollateralPool(
+    rpc,
+    addresses,
+    config,
+  );
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeCollateralPool(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<CollateralPool>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) =>
+    decodeCollateralPool(maybeAccount),
+  );
+}
+
+export function getCollateralPoolSize(): number {
+  return 183;
+}