@epicentral/sos-sdk 0.9.0-beta

package/accounts/fetchers.ts

@@ -0,0 +1,196 @@
+import {
+  getCollateralPoolDecoder,
+  getLenderPositionDecoder,
+  getMarketDataAccountDecoder,
+  getOptionAccountDecoder,
+  getOptionPoolDecoder,
+  getPoolLoanDecoder,
+  getPositionAccountDecoder,
+  getVaultDecoder,
+  getWriterPositionDecoder,
+  type CollateralPool,
+  type LenderPosition,
+  type MarketDataAccount,
+  type OptionAccount,
+  type OptionPool,
+  type PoolLoan,
+  type PositionAccount,
+  type Vault,
+  type WriterPosition,
+} from "../generated/accounts";
+import type { Address } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, KitRpc } from "../client/types";
+
+async function fetchRawAccount(
+  rpc: KitRpc,
+  address: AddressLike
+): Promise<Uint8Array | null> {
+  const response = await rpc.getAccountInfo(toAddress(address), { encoding: "base64" }).send();
+  const accountInfo = response.value;
+  if (!accountInfo) return null;
+  const [data] = accountInfo.data;
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+async function decodeAccount<T>(
+  rpc: KitRpc,
+  address: AddressLike,
+  decoder: { decode: (value: Uint8Array) => T }
+): Promise<T | null> {
+  const data = await fetchRawAccount(rpc, address);
+  if (!data) return null;
+  try {
+    return decoder.decode(data);
+  } catch (e) {
+    // #region agent log
+    try {
+      fetch("http://127.0.0.1:7586/ingest/4a07cb33-954d-4b27-b1a3-08f1423b9d05", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Debug-Session-Id": "af65cf" },
+        body: JSON.stringify({
+          sessionId: "af65cf",
+          location: "sos-sdk/accounts/fetchers.ts:decodeAccount",
+          message: "decode_throw",
+          data: {
+            address: String(address),
+            dataLen: data.length,
+            firstDiscHex: Array.from(data.slice(0, 8))
+              .map((b) => b.toString(16).padStart(2, "0"))
+              .join(""),
+            err: (e as Error)?.message ?? String(e),
+          },
+          timestamp: Date.now(),
+          hypothesisId: "H2-i64-account-size-mismatch",
+        }),
+      }).catch(() => {});
+    } catch {}
+    // #endregion
+    throw e;
+  }
+}
+
+export async function fetchOptionAccount(
+  rpc: KitRpc,
+  optionAccount: AddressLike
+): Promise<OptionAccount | null> {
+  return decodeAccount(rpc, optionAccount, getOptionAccountDecoder());
+}
+
+export async function fetchOptionPool(
+  rpc: KitRpc,
+  optionPool: AddressLike
+): Promise<OptionPool | null> {
+  return decodeAccount(rpc, optionPool, getOptionPoolDecoder());
+}
+
+export async function fetchCollateralPool(
+  rpc: KitRpc,
+  collateralPool: AddressLike
+): Promise<CollateralPool | null> {
+  return decodeAccount(rpc, collateralPool, getCollateralPoolDecoder());
+}
+
+export async function fetchWriterPosition(
+  rpc: KitRpc,
+  writerPosition: AddressLike
+): Promise<WriterPosition | null> {
+  return decodeAccount(rpc, writerPosition, getWriterPositionDecoder());
+}
+
+export async function fetchLenderPosition(
+  rpc: KitRpc,
+  lenderPosition: AddressLike
+): Promise<LenderPosition | null> {
+  return decodeAccount(rpc, lenderPosition, getLenderPositionDecoder());
+}
+
+export async function fetchBuyerPosition(
+  rpc: KitRpc,
+  buyerPosition: AddressLike
+): Promise<PositionAccount | null> {
+  return decodeAccount(rpc, buyerPosition, getPositionAccountDecoder());
+}
+
+export async function fetchVault(
+  rpc: KitRpc,
+  vault: AddressLike
+): Promise<Vault | null> {
+  return decodeAccount(rpc, vault, getVaultDecoder());
+}
+
+export async function fetchMarketDataAccount(
+  rpc: KitRpc,
+  marketData: AddressLike
+): Promise<MarketDataAccount | null> {
+  return decodeAccount(rpc, marketData, getMarketDataAccountDecoder());
+}
+
+export async function fetchPoolLoan(
+  rpc: KitRpc,
+  poolLoan: AddressLike
+): Promise<PoolLoan | null> {
+  return decodeAccount(rpc, poolLoan, getPoolLoanDecoder());
+}
+
+export async function accountExists(
+  rpc: KitRpc,
+  address: AddressLike
+): Promise<boolean> {
+  const response = await rpc.getAccountInfo(toAddress(address), { encoding: "base64" }).send();
+  return response.value !== null;
+}
+
+export async function fetchManyAccounts(
+  rpc: KitRpc,
+  addresses: AddressLike[]
+): Promise<Array<{ address: Address; exists: boolean }>> {
+  const keys = addresses.map((value) => toAddress(value));
+  const response = await rpc.getMultipleAccounts(keys, { encoding: "base64" }).send();
+  const infos = response.value;
+  return keys.map((key, index) => ({
+    address: key,
+    exists: infos[index] !== null,
+  }));
+}
+
+const optionDecoder = getOptionAccountDecoder();
+
+/**
+ * Batch-fetches option accounts via getMultipleAccounts (one RPC round-trip).
+ * Returns a Map from address to OptionAccount or null if missing/invalid.
+ */
+export async function fetchOptionAccounts(
+  rpc: KitRpc,
+  addresses: AddressLike[]
+): Promise<Map<Address, OptionAccount | null>> {
+  if (addresses.length === 0) return new Map();
+  const keys = addresses.map((value) => toAddress(value));
+  const response = await rpc.getMultipleAccounts(keys, { encoding: "base64" }).send();
+  const infos = response.value;
+  const result = new Map<Address, OptionAccount | null>();
+  for (let i = 0; i < keys.length; i++) {
+    const accountInfo = infos[i];
+    if (!accountInfo) {
+      result.set(keys[i], null);
+      continue;
+    }
+    const [b64] = accountInfo.data;
+    if (!b64) {
+      result.set(keys[i], null);
+      continue;
+    }
+    const binary = atob(b64);
+    const data = new Uint8Array(binary.length);
+    for (let j = 0; j < binary.length; j++) data[j] = binary.charCodeAt(j);
+    try {
+      result.set(keys[i], optionDecoder.decode(data));
+    } catch {
+      result.set(keys[i], null);
+    }
+  }
+  return result;
+}

package/accounts/list.ts

@@ -0,0 +1,184 @@
+import bs58 from "bs58";
+import type { Address } from "@solana/kit";
+import {
+  OPTION_POOL_DISCRIMINATOR,
+  POOL_LOAN_DISCRIMINATOR,
+  POSITION_ACCOUNT_DISCRIMINATOR,
+  VAULT_DISCRIMINATOR,
+  WRITER_POSITION_DISCRIMINATOR,
+  getOptionPoolDecoder,
+  getOptionPoolSize,
+  getPoolLoanDecoder,
+  getPoolLoanSize,
+  getPositionAccountDecoder,
+  getPositionAccountSize,
+  getVaultDecoder,
+  getVaultSize,
+  getWriterPositionDecoder,
+  getWriterPositionSize,
+  type OptionPool,
+  type PoolLoan,
+  type PositionAccount,
+  type Vault,
+  type WriterPosition,
+} from "../generated/accounts";
+import { PROGRAM_ID, toAddress } from "../client/program";
+import type { AddressLike, KitRpc } from "../client/types";
+
+const DISCRIMINATOR_OFFSET = 0n;
+const OWNER_OFFSET = 8n;
+/** WriterPosition layout: discriminator(8) + writer_authority(32) + option_pool(32). Used for getProgramAccounts memcmp. */
+const WRITER_POSITION_OPTION_POOL_OFFSET = 40n;
+const ACTIVE_POOL_LOAN_STATUS = 1;
+
+type ListedAccount<T> = {
+  address: Address;
+  data: T;
+};
+
+type ProgramAccountResponse = {
+  pubkey: Address;
+  account: {
+    data: [string, string] | string;
+  };
+};
+
+function decodeBase64Data(data: string): Uint8Array {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+function discriminatorFilter(discriminator: Uint8Array) {
+  return {
+    memcmp: {
+      offset: DISCRIMINATOR_OFFSET,
+      encoding: "base58",
+      bytes: bs58.encode(discriminator),
+    },
+  } as const;
+}
+
+function ownerFilter(owner: AddressLike) {
+  return {
+    memcmp: {
+      offset: OWNER_OFFSET,
+      encoding: "base58",
+      bytes: toAddress(owner),
+    },
+  } as const;
+}
+
+function optionPoolFilter(optionPool: AddressLike) {
+  return {
+    memcmp: {
+      offset: WRITER_POSITION_OPTION_POOL_OFFSET,
+      encoding: "base58",
+      bytes: toAddress(optionPool),
+    },
+  } as const;
+}
+
+async function fetchAndDecodeProgramAccounts<T>(
+  rpc: KitRpc,
+  decoder: { decode: (value: Uint8Array) => T },
+  filters: ReadonlyArray<unknown>,
+  programAddress: AddressLike = PROGRAM_ID
+): Promise<Array<ListedAccount<T>>> {
+  const response = await rpc
+    .getProgramAccounts(toAddress(programAddress), {
+      encoding: "base64",
+      filters: filters as never,
+    })
+    .send();
+
+  const rawAccounts = Array.isArray(response)
+    ? (response as Array<ProgramAccountResponse>)
+    : (response as { value: Array<ProgramAccountResponse> }).value;
+
+  return rawAccounts.map(({ pubkey, account }) => {
+    const base64Data =
+      Array.isArray(account.data) ? account.data[0] : account.data;
+    return {
+      address: pubkey,
+      data: decoder.decode(decodeBase64Data(base64Data)),
+    };
+  });
+}
+
+export async function fetchWriterPositionsByWriter(
+  rpc: KitRpc,
+  writer: AddressLike
+): Promise<Array<ListedAccount<WriterPosition>>> {
+  return fetchAndDecodeProgramAccounts(rpc, getWriterPositionDecoder(), [
+    discriminatorFilter(WRITER_POSITION_DISCRIMINATOR),
+    ownerFilter(writer),
+    { dataSize: BigInt(getWriterPositionSize()) },
+  ]);
+}
+
+/**
+ * Fetches all WriterPosition accounts for a single option pool.
+ * WriterPosition layout: option_pool at offset 40, 32 bytes (memcmp filter).
+ */
+export async function fetchWriterPositionsForPool(
+  rpc: KitRpc,
+  optionPool: AddressLike,
+  programId?: AddressLike
+): Promise<Array<ListedAccount<WriterPosition>>> {
+  return fetchAndDecodeProgramAccounts(
+    rpc,
+    getWriterPositionDecoder(),
+    [
+      discriminatorFilter(WRITER_POSITION_DISCRIMINATOR),
+      optionPoolFilter(optionPool),
+      { dataSize: BigInt(getWriterPositionSize()) },
+    ],
+    programId ?? PROGRAM_ID
+  );
+}
+
+export async function fetchPositionAccountsByBuyer(
+  rpc: KitRpc,
+  buyer: AddressLike
+): Promise<Array<ListedAccount<PositionAccount>>> {
+  return fetchAndDecodeProgramAccounts(rpc, getPositionAccountDecoder(), [
+    discriminatorFilter(POSITION_ACCOUNT_DISCRIMINATOR),
+    ownerFilter(buyer),
+    { dataSize: BigInt(getPositionAccountSize()) },
+  ]);
+}
+
+export async function fetchPoolLoansByMaker(
+  rpc: KitRpc,
+  maker: AddressLike
+): Promise<Array<ListedAccount<PoolLoan>>> {
+  const decoded = await fetchAndDecodeProgramAccounts(rpc, getPoolLoanDecoder(), [
+    discriminatorFilter(POOL_LOAN_DISCRIMINATOR),
+    ownerFilter(maker),
+    { dataSize: BigInt(getPoolLoanSize()) },
+  ]);
+  return decoded.filter(
+    (item: { address: Address; data: PoolLoan }) =>
+      item.data.status === ACTIVE_POOL_LOAN_STATUS
+  );
+}
+
+export async function fetchAllOptionPools(
+  rpc: KitRpc
+): Promise<Array<ListedAccount<OptionPool>>> {
+  return fetchAndDecodeProgramAccounts(rpc, getOptionPoolDecoder(), [
+    discriminatorFilter(OPTION_POOL_DISCRIMINATOR),
+    { dataSize: BigInt(getOptionPoolSize()) },
+  ]);
+}
+
+export async function fetchAllVaults(
+  rpc: KitRpc
+): Promise<Array<ListedAccount<Vault>>> {
+  return fetchAndDecodeProgramAccounts(rpc, getVaultDecoder(), [
+    discriminatorFilter(VAULT_DISCRIMINATOR),
+    { dataSize: BigInt(getVaultSize()) },
+  ]);
+}

package/accounts/pdas.ts

@@ -0,0 +1,325 @@
+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 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)),
+    ],
+  });
+}
+
+/**
+ * Derives the PoolLoan PDA using the canonical seeds: vault, maker, nonce.
+ * Matches the program's derivation in omlp_context.rs (BorrowFromPool).
+ *
+ * @param vault - OMLP vault PDA (from deriveVaultPda)
+ * @param maker - Writer/borrower pubkey
+ * @param nonce - Loan nonce (u64)
+ * @param programId - Optional program ID
+ */
+export async function derivePoolLoanPdaFromVault(
+  vault: AddressLike,
+  maker: 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(vault)),
+      addressEncoder.encode(toAddress(maker)),
+      u64ToLeBytes(nonce),
+    ],
+  });
+}
+
+/**
+ * Derives the PoolLoan PDA using writer position and nonce.
+ *
+ * @deprecated This derivation does not match the program. Use {@link derivePoolLoanPdaFromVault}
+ * with (vault, maker, nonce) instead. Program seeds are: pool_loan, vault, maker, nonce (u64 le).
+ */
+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;
+}