@perena/vault-sdk 1.0.43 → 1.0.46

package/dist/browser/nest.mjs

@@ -0,0 +1,757 @@
+// src/services/nestWithdrawalService.ts
+import { address as address4 } from "@solana/kit";
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID as ASSOCIATED_TOKEN_PROGRAM_ID2,
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2,
+  TOKEN_PROGRAM_ID
+} from "@solana/spl-token";
+import {
+  ComputeBudgetProgram,
+  PublicKey as PublicKey3,
+  TransactionMessage as TransactionMessage2,
+  VersionedTransaction as VersionedTransaction2
+} from "@solana/web3.js";
+
+// ../common/src/utils/accounts/ata.ts
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddressSync
+} from "@solana/spl-token";
+
+// ../common/src/utils/compat.ts
+import {
+  AccountRole,
+  address
+} from "@solana/kit";
+import {
+  PublicKey,
+  TransactionInstruction
+} from "@solana/web3.js";
+function toKitInstruction(ix) {
+  return {
+    programAddress: ix.programId.toBase58(),
+    data: new Uint8Array(ix.data),
+    accounts: ix.keys.map((key) => ({
+      address: key.pubkey.toBase58(),
+      role: key.isWritable ? key.isSigner ? AccountRole.WRITABLE_SIGNER : AccountRole.WRITABLE : key.isSigner ? AccountRole.READONLY_SIGNER : AccountRole.READONLY
+    }))
+  };
+}
+
+// ../common/src/utils/accounts/roles.ts
+import {
+  AccountRole as AccountRole2,
+  upgradeRoleToSigner,
+  upgradeRoleToWritable
+} from "@solana/kit";
+
+// ../common/src/utils/cpi/refs.ts
+import {
+  upgradeRoleToSigner as upgradeRoleToSigner2,
+  upgradeRoleToWritable as upgradeRoleToWritable2
+} from "@solana/kit";
+
+// ../common/src/utils/numbers.ts
+function toUiAmount(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const wholePart = amount / divisor;
+  const remainder = amount % divisor;
+  return Number(wholePart) + Number(remainder) / 10 ** decimals;
+}
+function fromUiAmount(amount, decimals) {
+  return BigInt(Math.round(amount * 10 ** decimals));
+}
+
+// ../common/src/utils/transaction.ts
+import {
+  PublicKey as PublicKey2,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+
+// ../common/src/services/mints/constants.ts
+import { address as address2 } from "@solana/kit";
+var SOL_MINT = address2("So11111111111111111111111111111111111111112");
+var WBTC_MINT = address2(
+  "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"
+);
+var CBBTC_MINT = address2(
+  "cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij"
+);
+var WETH_MINT = address2(
+  "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"
+);
+var JLP_MINT = address2("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4");
+var SPYX_MINT = address2("XsoCS1TfEyfFhfvj8EtZ528L3CaKBDBRqRapnBbDF2W");
+var QQQX_MINT = address2("Xs8S1uUs1zvS2p7iwtsG3b6fkhpvmwz4GYU3gWAmWHZ");
+var USDC_MINT = address2(
+  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+);
+var USDT_MINT = address2(
+  "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
+);
+var USDS_MINT = address2("USDSwr9ApdHk5bvJKMjzff41FfuX8bSxdKcR81vTwcA");
+var USDG_MINT = address2(
+  "2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH"
+);
+var PYUSD_MINT = address2(
+  "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo"
+);
+var CASH_MINT = address2(
+  "CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH"
+);
+var USD1_MINT = address2("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB");
+var JITOSOL_MINT = address2(
+  "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"
+);
+var JUPSOL_MINT = address2(
+  "jupSoLaHXQiZZTSfEWMTRRgpnyFm8f6sZdosWBjx93v"
+);
+var USD_STAR_MINT = address2(
+  "star9agSpjiFe3M49B3RniVU4CMBBEK3Qnaqn3RGiFM"
+);
+var USD_STAR_JUNIOR_MINT = address2(
+  "3AJYCjrhKitmBd8tRUurPA5dGHCAQh6A8L9DkuSC37Rm"
+);
+var PST_MINT = address2("59obFNBzyTBGowrkif5uK7ojS58vsuWz3ZCvg6tfZAGw");
+var PRIME_MINT = address2(
+  "3b8X44fLF9ooXaUm3hhSgjpmVs6rZZ3pPoGnGahc3Uu7"
+);
+var NEST_RWA_SHARE_MINT = address2(
+  "VyXKJnVhkSkB6KAozSZCiLQbuB1k1r6Nu4etNYVo5LJ"
+);
+
+// ../common/src/services/mints/defaults.ts
+var DEFAULT_MINTS = [
+  {
+    address: SOL_MINT,
+    symbol: "SOL",
+    name: "Solana",
+    decimals: 9,
+    assetType: "Standard"
+  },
+  {
+    address: USDC_MINT,
+    symbol: "USDC",
+    name: "USD Coin",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: USDT_MINT,
+    symbol: "USDT",
+    name: "Tether USD",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: USDS_MINT,
+    symbol: "USDS",
+    decimals: 6,
+    assetType: "Stablecoin"
+  },
+  {
+    address: USDG_MINT,
+    symbol: "USDG",
+    name: "Global Dollar",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: PYUSD_MINT,
+    symbol: "PYUSD",
+    name: "PayPal USD",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: CASH_MINT,
+    symbol: "CASH",
+    decimals: 6,
+    assetType: "Stablecoin",
+    isToken2022: true
+  },
+  {
+    address: USD_STAR_MINT,
+    symbol: "USD*",
+    name: "USD Star",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: USD_STAR_JUNIOR_MINT,
+    symbol: "USD*-J",
+    name: "USD Star Junior",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: PST_MINT,
+    symbol: "PST",
+    name: "PayFi Strategy Token",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: PRIME_MINT,
+    symbol: "PRIME",
+    name: "Hastra PRIME",
+    decimals: 6,
+    assetType: "YBA"
+  },
+  {
+    address: NEST_RWA_SHARE_MINT,
+    symbol: "nPERENA",
+    name: "Nest Vault",
+    decimals: 6,
+    assetType: "YBA"
+  }
+];
+
+// ../common/src/services/mints/registry.ts
+import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
+var MintRegistry = class {
+  constructor(options = {}) {
+    this.byAddress = /* @__PURE__ */ new Map();
+    this.bySymbol = /* @__PURE__ */ new Map();
+    const { includeDefaults = true, custom = [] } = options;
+    if (includeDefaults) {
+      for (const config of DEFAULT_MINTS) {
+        this.register(config);
+      }
+    }
+    for (const config of custom) {
+      this.register(config);
+    }
+  }
+  register(config) {
+    const mintInfo = {
+      ...config,
+      tokenProgram: config.isToken2022 ? TOKEN_2022_PROGRAM_ADDRESS : TOKEN_PROGRAM_ADDRESS,
+      toUiAmount: (amount) => toUiAmount(amount, config.decimals),
+      fromUiAmount: (amount) => fromUiAmount(amount, config.decimals)
+    };
+    this.byAddress.set(config.address, mintInfo);
+    this.bySymbol.set(config.symbol.toUpperCase(), mintInfo);
+  }
+  get(mint) {
+    const key = mint.toString();
+    const bySymbol = this.bySymbol.get(key.toUpperCase());
+    if (bySymbol) {
+      return bySymbol;
+    }
+    return this.byAddress.get(key);
+  }
+  all() {
+    return Array.from(this.byAddress.values());
+  }
+  standardAssets() {
+    return this.filterAssetsByType("Standard");
+  }
+  stablecoins() {
+    return this.filterAssetsByType("Stablecoin");
+  }
+  lsts() {
+    return this.filterAssetsByType("LST");
+  }
+  yieldBearingAssets() {
+    return this.filterAssetsByType("YBA");
+  }
+  filterAssetsByType(assetType) {
+    return Array.from(this.byAddress.values()).filter(
+      (mint) => mint.assetType === assetType
+    );
+  }
+  symbols() {
+    return Array.from(this.bySymbol.keys());
+  }
+  addresses() {
+    return this.all().map((mint) => mint.address);
+  }
+};
+var mints = new MintRegistry();
+
+// ../common/src/services/baseAccountClient.ts
+import { fetchMaybeToken } from "@solana-program/token";
+var DEFAULT_SPL_ATA_TTL_MS = 6e4 * 10;
+
+// ../nest/src/priceApi.ts
+var NEST_API_BASE_URL = "https://api.nest.credit/v1";
+
+// ../nest/src/redemptionApi.ts
+var NestApiError = class extends Error {
+  constructor(status, message) {
+    super(`Nest API (${status}): ${message}`);
+    this.status = status;
+    this.name = "NestApiError";
+  }
+};
+function assertNestShareAmount(amount) {
+  if (typeof amount !== "bigint" || amount <= 0n || amount > 0xffffffffffffffffn) {
+    throw new Error(
+      "Nest share amount must be a positive u64 bigint in base units"
+    );
+  }
+}
+async function request(path, options, body) {
+  const response = await (options.fetchFn ?? fetch)(
+    `${(options.baseUrl ?? NEST_API_BASE_URL).replace(/\/$/, "")}${path}`,
+    {
+      method: body ? "POST" : "GET",
+      headers: body ? { "Content-Type": "application/json" } : void 0,
+      body: body ? JSON.stringify(body) : void 0,
+      signal: options.signal
+    }
+  );
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new NestApiError(
+      response.status,
+      typeof payload?.error === "string" ? payload.error : response.statusText
+    );
+  }
+  if (!payload || typeof payload !== "object" || !payload.data) {
+    throw new Error("Nest API returned an invalid response");
+  }
+  return payload.data;
+}
+async function fetchNestRedemptionTransaction(args, options = {}) {
+  assertNestShareAmount(args.rawAmountNestToken);
+  const data = await request(
+    "/solana/nest/async-redeem/request/build-tx",
+    options,
+    {
+      ...args,
+      rawAmountNestToken: args.rawAmountNestToken.toString(),
+      // Squads must sign both the token authority and LayerZero fee payer at execution.
+      feePayer: args.owner
+    }
+  );
+  if (typeof data.txBase64 !== "string" || !data.txBase64.length) {
+    throw new Error("Nest API returned no transaction");
+  }
+  return data.txBase64;
+}
+async function fetchNestRedemptionQuote(args, options = {}) {
+  assertNestShareAmount(args.rawAmountNestToken);
+  const data = await request("/solana/nest/async-redeem/quote", options, {
+    ...args,
+    rawAmountNestToken: args.rawAmountNestToken.toString()
+  });
+  if (data.nestVaultSlug !== args.nestVaultSlug || data.redemptionAsset !== "USDC" || data.shareAmount !== args.rawAmountNestToken.toString() || !Number.isInteger(data.shareDecimals) || data.shareDecimals < 0 || data.shareDecimals > 18 || data.redemptionDecimals !== 6 || typeof data.redemptionAmount !== "string" || typeof data.feeAmount !== "string" || !/^\d+$/.test(data.redemptionAmount) || !/^\d+$/.test(data.feeAmount)) {
+    throw new Error("Nest API returned an invalid redemption quote");
+  }
+  return data;
+}
+async function fetchNestRedemptionStatus(signature, options = {}) {
+  if (!/^[1-9A-HJ-NP-Za-km-z]{64,88}$/.test(signature)) {
+    throw new Error("Enter a Solana withdrawal execution signature");
+  }
+  let data;
+  try {
+    data = await request(
+      `/solana/redeem-status/${encodeURIComponent(signature)}`,
+      options
+    );
+  } catch (error) {
+    if (error instanceof NestApiError && error.status === 404) return null;
+    throw error;
+  }
+  if (data.solanaBurnSignature !== signature || typeof data.solanaWallet !== "string" || typeof data.overallStatus !== "string" || !["solanaBurn", "plumeProcessing", "cctpAttestation", "solanaClaim"].every(
+    (key) => typeof data.steps?.[key]?.status === "string"
+  )) {
+    throw new Error("Nest API returned an invalid redemption status");
+  }
+  return data;
+}
+
+// src/services/consensusOracle/sources/nestPriceSource.ts
+import { address as address3 } from "@solana/kit";
+var NEST_VAULT_SLUG = "nest-perena-vault";
+var NEST_RWA_SHARE_MINT2 = address3(
+  "VyXKJnVhkSkB6KAozSZCiLQbuB1k1r6Nu4etNYVo5LJ"
+);
+
+// src/services/nestWithdrawalService.ts
+var NestOftProgram = new PublicKey3(
+  "ChEfPd3RzLeYiRwp1K9evimmaFSd6DV1S4Mv5q5Aj1th"
+);
+var NestOftStore = new PublicKey3(
+  "k8mJj8Gyw2gFAqut21AFVUUZhxb4RVDMnb4PrSYiDhV"
+);
+var UsdcMint = new PublicKey3("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var NestPerenaComposer = Buffer.from(
+  "000000000000000000000000908dcb5531691c2124c54e30bb645cf11647090d",
+  "hex"
+);
+async function buildNestWithdrawalRequest(args) {
+  const txBase64 = await fetchNestRedemptionTransaction(
+    {
+      owner: args.owner.toBase58(),
+      nestVaultSlug: NEST_VAULT_SLUG,
+      rawAmountNestToken: args.rawAmountNestToken
+    },
+    args.apiOptions
+  );
+  return decodeNestWithdrawalRequest({ ...args, txBase64 });
+}
+async function decodeNestWithdrawalRequest(args) {
+  const transaction = VersionedTransaction2.deserialize(
+    Buffer.from(args.txBase64, "base64")
+  );
+  const message = transaction.message;
+  if (!message.staticAccountKeys[0].equals(args.owner) || message.header.numRequiredSignatures !== 1) {
+    throw new Error(
+      "Nest withdrawal must use the Squads vault as its only signer and fee payer"
+    );
+  }
+  const tables = await Promise.all(
+    message.addressTableLookups.map(async (lookup) => {
+      const { value } = await args.connection.getAddressLookupTable(
+        lookup.accountKey
+      );
+      if (!value)
+        throw new Error(
+          `Nest lookup table not found: ${lookup.accountKey.toBase58()}`
+        );
+      return value;
+    })
+  );
+  const decoded = TransactionMessage2.decompile(message, {
+    addressLookupTableAccounts: tables
+  });
+  const nestMint = new PublicKey3(NEST_RWA_SHARE_MINT2);
+  const sourceAta = getAssociatedTokenAddressSync2(nestMint, args.owner, true);
+  const usdcAta = getAssociatedTokenAddressSync2(UsdcMint, args.owner, true);
+  const instructions2 = decoded.instructions.filter(
+    (ix) => !ix.programId.equals(ComputeBudgetProgram.programId)
+  );
+  let sends = 0;
+  for (const ix of instructions2) {
+    if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID2)) {
+      if (ix.data.length !== 1 || ix.data[0] !== 1 || !ix.keys[0]?.pubkey.equals(args.owner) || !ix.keys[1]?.pubkey.equals(usdcAta) || !ix.keys[2]?.pubkey.equals(args.owner) || !ix.keys[3]?.pubkey.equals(UsdcMint) || !ix.keys[5]?.pubkey.equals(TOKEN_PROGRAM_ID)) {
+        throw new Error("Unexpected token account creation in Nest withdrawal");
+      }
+      continue;
+    }
+    if (!ix.programId.equals(NestOftProgram) || ix.data.length < 52 || !ix.data.subarray(0, 8).equals(Buffer.from([102, 251, 20, 187, 65, 75, 12, 69])) || !ix.data.subarray(12, 44).equals(NestPerenaComposer) || ix.data.readBigUInt64LE(44) !== args.rawAmountNestToken || ![args.owner, nestMint, sourceAta, NestOftStore].every(
+      (key) => ix.keys.some((meta) => meta.pubkey.equals(key))
+    )) {
+      throw new Error(
+        "Unexpected instruction or share amount in Nest withdrawal"
+      );
+    }
+    sends += 1;
+  }
+  if (sends !== 1)
+    throw new Error("Nest withdrawal must contain exactly one OFT send");
+  return {
+    instructions: instructions2.map(toKitInstruction),
+    lookupTables: tables.map((table) => address4(table.key.toBase58()))
+  };
+}
+
+// src/utils/squads.ts
+import * as squads from "@sqds/multisig";
+import {
+  PublicKey as PublicKey4,
+  Transaction,
+  TransactionMessage as TransactionMessage3,
+  VersionedTransaction as VersionedTransaction3
+} from "@solana/web3.js";
+var SQUADS_SIMULATION_COMMITMENT = "processed";
+var SquadsProposalExecutionSimulationError = class extends Error {
+  constructor(transactionError, logs, unitsConsumed) {
+    const programLogs = logs.length > 0 ? `
+${logs.join("\n")}` : "";
+    super(
+      `Squads proposal execution simulation failed: ${JSON.stringify(
+        transactionError
+      )}${programLogs}`
+    );
+    this.name = "SquadsProposalExecutionSimulationError";
+    this.transactionError = transactionError;
+    this.logs = [...logs];
+    this.unitsConsumed = unitsConsumed;
+  }
+};
+function validateVaultIndex(vaultIndex) {
+  if (!Number.isSafeInteger(vaultIndex) || vaultIndex < 0) {
+    throw new Error("Squads vaultIndex must be a non-negative safe integer");
+  }
+}
+function resolveSquadsWalletRoute(route) {
+  validateVaultIndex(route.vaultIndex);
+  const wallet = new PublicKey4(route.wallet);
+  const multisigPda = new PublicKey4(route.multisigPda);
+  const [vaultPda] = squads.getVaultPda({
+    multisigPda,
+    index: route.vaultIndex
+  });
+  return { ...route, wallet, multisigPda, vaultPda };
+}
+function findSquadsWalletRoute(wallet, routes) {
+  const walletKey = typeof wallet === "string" ? new PublicKey4(wallet) : wallet;
+  const route = routes.find(
+    (candidate) => candidate.wallet === walletKey.toBase58()
+  );
+  return route ? resolveSquadsWalletRoute(route) : void 0;
+}
+function validateSquadsWalletRoutes(routes) {
+  const wallets = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const resolved = resolveSquadsWalletRoute(route);
+    const wallet = resolved.wallet.toBase58();
+    if (wallets.has(wallet)) {
+      throw new Error(`Duplicate Squads route for wallet ${wallet}`);
+    }
+    wallets.add(wallet);
+  }
+}
+function vaultAuthorityForWallet(wallet, routes) {
+  const walletKey = typeof wallet === "string" ? new PublicKey4(wallet) : wallet;
+  return findSquadsWalletRoute(walletKey, routes)?.vaultPda ?? walletKey;
+}
+async function simulateSquadsProposalExecution(args) {
+  const { connection, feePayer, instructions: instructions2 } = args;
+  const recentBlockhash = args.recentBlockhash ?? (await connection.getLatestBlockhash(SQUADS_SIMULATION_COMMITMENT)).blockhash;
+  const message = new TransactionMessage3({
+    payerKey: feePayer,
+    recentBlockhash,
+    instructions: [...instructions2]
+  }).compileToV0Message(args.addressLookupTableAccounts);
+  const transaction = new VersionedTransaction3(message);
+  const { value } = await connection.simulateTransaction(transaction, {
+    sigVerify: false,
+    commitment: SQUADS_SIMULATION_COMMITMENT,
+    innerInstructions: true
+  });
+  if (value.err) {
+    throw new SquadsProposalExecutionSimulationError(
+      value.err,
+      value.logs ?? [],
+      value.unitsConsumed
+    );
+  }
+  return value;
+}
+async function prepareVaultTransaction(args) {
+  const { connection, proposer, instructions: instructions2 } = args;
+  const route = findSquadsWalletRoute(proposer, args.squadsRoutes ?? []);
+  if (!route) {
+    return {
+      kind: "direct",
+      transaction: new Transaction().add(...instructions2),
+      authority: proposer
+    };
+  }
+  const multisig = await squads.accounts.Multisig.fromAccountAddress(
+    connection,
+    route.multisigPda
+  );
+  const member = multisig.members.find(
+    (candidate) => candidate.key.equals(proposer)
+  );
+  if (!member) {
+    throw new Error(
+      `Wallet ${proposer.toBase58()} is not a member of Squads multisig ${route.multisigPda.toBase58()}`
+    );
+  }
+  if (!squads.types.Permissions.has(
+    member.permissions,
+    squads.types.Permission.Initiate
+  )) {
+    throw new Error(
+      `Wallet ${proposer.toBase58()} cannot initiate proposals for Squads multisig ${route.multisigPda.toBase58()}`
+    );
+  }
+  const transactionIndex = BigInt(multisig.transactionIndex.toString()) + 1n;
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  if (!args.skipSimulation) {
+    await simulateSquadsProposalExecution({
+      connection,
+      feePayer: proposer,
+      instructions: instructions2,
+      recentBlockhash: blockhash,
+      addressLookupTableAccounts: args.addressLookupTableAccounts
+    });
+  }
+  const transactionMessage = new TransactionMessage3({
+    payerKey: route.vaultPda,
+    recentBlockhash: blockhash,
+    instructions: [...instructions2]
+  });
+  const createVaultTransactionIx = squads.instructions.vaultTransactionCreate({
+    multisigPda: route.multisigPda,
+    transactionIndex,
+    creator: proposer,
+    vaultIndex: route.vaultIndex,
+    ephemeralSigners: 0,
+    transactionMessage,
+    addressLookupTableAccounts: args.addressLookupTableAccounts,
+    memo: route.memo
+  });
+  const createProposalIx = squads.instructions.proposalCreate({
+    multisigPda: route.multisigPda,
+    transactionIndex,
+    creator: proposer
+  });
+  const [proposalPda] = squads.getProposalPda({
+    multisigPda: route.multisigPda,
+    transactionIndex
+  });
+  const [vaultTransactionPda] = squads.getTransactionPda({
+    multisigPda: route.multisigPda,
+    index: transactionIndex
+  });
+  return {
+    kind: "squads",
+    transaction: new Transaction().add(
+      createVaultTransactionIx,
+      createProposalIx
+    ),
+    authority: route.vaultPda,
+    multisigPda: route.multisigPda,
+    vaultIndex: route.vaultIndex,
+    transactionIndex,
+    proposalPda,
+    vaultTransactionPda
+  };
+}
+
+// src/utils/squadsBuffer.ts
+import * as squads2 from "@sqds/multisig";
+import {
+  PublicKey as PublicKey5,
+  SystemProgram,
+  Transaction as Transaction2
+} from "@solana/web3.js";
+var PacketSize = 1232;
+var BufferChunkSize = 700;
+var MaxBufferSize = 4e3;
+async function prepareSquadsProposalUpload(args) {
+  const { connection, proposer, prepared } = args;
+  const transaction = prepared.transaction;
+  const sizeProbe = new Transaction2({
+    feePayer: proposer,
+    recentBlockhash: PublicKey5.default.toBase58()
+  }).add(...transaction.instructions);
+  let fits = false;
+  try {
+    fits = sizeProbe.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    }).length <= PacketSize;
+  } catch {
+  }
+  if (fits) return { setupTransactions: [], proposalTransaction: transaction };
+  const [decoded] = squads2.generated.vaultTransactionCreateStruct.deserialize(
+    transaction.instructions[0].data
+  );
+  const bytes = decoded.args.transactionMessage;
+  if (bytes.length > MaxBufferSize)
+    throw new Error("Squads proposal exceeds the 4,000-byte message limit");
+  let bufferPda;
+  let bufferIndex = 0;
+  for (; bufferIndex <= 255; bufferIndex++) {
+    const [candidate] = PublicKey5.findProgramAddressSync(
+      [
+        Buffer.from("multisig"),
+        prepared.multisigPda.toBuffer(),
+        Buffer.from("transaction_buffer"),
+        proposer.toBuffer(),
+        Buffer.from([bufferIndex])
+      ],
+      squads2.PROGRAM_ID
+    );
+    if (!await connection.getAccountInfo(candidate, "confirmed")) {
+      bufferPda = candidate;
+      break;
+    }
+  }
+  if (!bufferPda)
+    throw new Error(
+      "All Squads upload buffers are occupied; close an old upload first"
+    );
+  const finalBufferHash = Array.from(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)))
+  );
+  const accounts2 = {
+    multisig: prepared.multisigPda,
+    transactionBuffer: bufferPda,
+    creator: proposer
+  };
+  const setupTransactions = [
+    new Transaction2().add(
+      squads2.generated.createTransactionBufferCreateInstruction(
+        {
+          ...accounts2,
+          rentPayer: proposer
+        },
+        {
+          args: {
+            bufferIndex,
+            vaultIndex: prepared.vaultIndex,
+            finalBufferHash,
+            finalBufferSize: bytes.length,
+            buffer: bytes.slice(0, BufferChunkSize)
+          }
+        }
+      )
+    )
+  ];
+  for (let offset = BufferChunkSize; offset < bytes.length; offset += BufferChunkSize) {
+    setupTransactions.push(
+      new Transaction2().add(
+        squads2.generated.createTransactionBufferExtendInstruction(accounts2, {
+          args: { buffer: bytes.slice(offset, offset + BufferChunkSize) }
+        })
+      )
+    );
+  }
+  const finalize = squads2.generated.createVaultTransactionCreateFromBufferInstruction(
+    {
+      vaultTransactionCreateItemMultisig: prepared.multisigPda,
+      vaultTransactionCreateItemTransaction: prepared.vaultTransactionPda,
+      vaultTransactionCreateItemCreator: proposer,
+      vaultTransactionCreateItemRentPayer: proposer,
+      vaultTransactionCreateItemSystemProgram: SystemProgram.programId,
+      transactionBuffer: bufferPda,
+      creator: proposer
+    },
+    { args: { ...decoded.args, transactionMessage: new Uint8Array(6) } }
+  );
+  const closeBufferInstruction = squads2.generated.createTransactionBufferCloseInstruction(accounts2);
+  closeBufferInstruction.keys.find(
+    (key) => key.pubkey.equals(proposer)
+  ).isWritable = true;
+  return {
+    setupTransactions,
+    proposalTransaction: new Transaction2().add(
+      finalize,
+      ...transaction.instructions.slice(1)
+    ),
+    bufferPda,
+    closeBufferInstruction
+  };
+}
+export {
+  NEST_RWA_SHARE_MINT2 as NEST_RWA_SHARE_MINT,
+  NEST_VAULT_SLUG,
+  NestApiError,
+  SquadsProposalExecutionSimulationError,
+  buildNestWithdrawalRequest,
+  decodeNestWithdrawalRequest,
+  fetchNestRedemptionQuote,
+  fetchNestRedemptionStatus,
+  findSquadsWalletRoute,
+  prepareSquadsProposalUpload,
+  prepareVaultTransaction,
+  resolveSquadsWalletRoute,
+  simulateSquadsProposalExecution,
+  validateSquadsWalletRoutes,
+  vaultAuthorityForWallet
+};