@hodlmarkets/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2357 @@
+'use strict';
+
+var web3_js = require('@solana/web3.js');
+var BN2 = require('bn.js');
+var anchor = require('@coral-xyz/anchor');
+var splToken = require('@solana/spl-token');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var BN2__default = /*#__PURE__*/_interopDefault(BN2);
+
+// src/constants.ts
+var BPS_DENOMINATOR = 1e4;
+var PROGRAM_ID = new web3_js.PublicKey("hodLrUfwyK3Z7Td5hdZhyojyznG1rqbHVex11y5s4yG");
+var PROTOCOL_AUTHORITY = new web3_js.PublicKey("EFAquDGAHjkoPB6TGKVibD3BYhbFXNDjuXKpiBHdYzji");
+var VIRTUAL_SOL = new BN2__default.default("30000000000");
+var TOTAL_SUPPLY = new BN2__default.default("1000000000000000");
+var PROTOCOL_MINT_FEE = new BN2__default.default("100000000");
+var DECIMALS = 6;
+var SEEDS = {
+  POOL: Buffer.from("pool"),
+  VAULT_AUTHORITY: Buffer.from("vault_authority"),
+  SOL_VAULT: Buffer.from("sol_vault"),
+  POSITION: Buffer.from("position"),
+  PROTOCOL_FEES: Buffer.from("protocol_fees"),
+  EVENT_AUTHORITY: Buffer.from("__event_authority")
+};
+var MAINNET_CONFIG = {
+  programId: PROGRAM_ID,
+  virtualSol: VIRTUAL_SOL,
+  protocolAuthority: PROTOCOL_AUTHORITY,
+  protocolMintFee: PROTOCOL_MINT_FEE,
+  decimals: DECIMALS,
+  totalSupply: TOTAL_SUPPLY
+};
+var DEVNET_CONFIG = {
+  programId: PROGRAM_ID,
+  virtualSol: VIRTUAL_SOL,
+  protocolAuthority: PROTOCOL_AUTHORITY,
+  protocolMintFee: PROTOCOL_MINT_FEE,
+  decimals: DECIMALS,
+  totalSupply: TOTAL_SUPPLY
+};
+var TRADE_FEE_BPS = 25;
+var VEST_DURATION = {
+  ONE_MINUTE: 60,
+  TEN_MINUTES: 600
+};
+var LIMITS = {
+  NAME: { min: 1, max: 32 },
+  SYMBOL: { min: 1, max: 16 },
+  URI: { min: 10, max: 100 },
+  DESCRIPTION: { min: 0, max: 200 }
+};
+
+// src/errors.ts
+var HodlError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "HodlError";
+  }
+};
+var HODL_ERRORS = {
+  7005: "Insufficient token reserves in vault",
+  7100: "Arithmetic overflow",
+  7102: "Division by zero or invalid division",
+  7104: "Token calculation overflow",
+  7105: "Token calculation underflow",
+  7200: "Slippage exceeded: output below minimum threshold",
+  7312: "Accrual calculation overflow",
+  7315: "Position is not empty, must sell all tokens first",
+  7319: "Invalid protocol authority",
+  7321: "Position must have tokens to perform this operation",
+  7500: "Position not owned by signer",
+  7505: "SOL vault PDA derivation mismatch",
+  7601: "Invalid vesting type",
+  7604: "Invalid percentage value (must be 0-100)",
+  7901: "Not authorized",
+  8014: "Insufficient liquidity",
+  8018: "vAMM is not active",
+  8020: "Invalid amount"
+};
+function parseHodlError(err) {
+  if (err && typeof err === "object" && "code" in err) {
+    const code = err.code;
+    if (code in HODL_ERRORS) return new HodlError(code, HODL_ERRORS[code]);
+  }
+  return null;
+}
+function getPoolStatePDA(mint, programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.POOL, mint.toBuffer()], programId);
+}
+function getVaultAuthorityPDA(poolState, programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.VAULT_AUTHORITY, poolState.toBuffer()], programId);
+}
+function getSolVaultPDA(poolState, programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.SOL_VAULT, poolState.toBuffer()], programId);
+}
+function getPositionPDA(poolState, owner, programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.POSITION, poolState.toBuffer(), owner.toBuffer()], programId);
+}
+function getProtocolFeesPDA(programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.PROTOCOL_FEES], programId);
+}
+function getEventAuthorityPDA(programId) {
+  return web3_js.PublicKey.findProgramAddressSync([SEEDS.EVENT_AUTHORITY], programId);
+}
+var ZERO = new BN2__default.default(0);
+var BPS = new BN2__default.default(1e4);
+var BASE_TRADABLE_PCT = 40;
+var PCT_PER_BAND = 5;
+var BAND_SIZE = new BN2__default.default("50000000000000");
+var MAX_TRADABLE_PCT = 100;
+function calculateBuyAmount(solIn, vammRealSol, vammTokens, vammK) {
+  if (solIn.isZero() || solIn.isNeg()) return ZERO;
+  const currentSolSide = vammRealSol.add(VIRTUAL_SOL);
+  const newSolSide = currentSolSide.add(solIn);
+  const newTokenSide = vammK.div(newSolSide);
+  return vammTokens.sub(newTokenSide);
+}
+function calculateSellAmount(tokensIn, vammRealSol, vammTokens, vammK) {
+  if (tokensIn.isZero() || tokensIn.isNeg()) return ZERO;
+  const newTokenSide = vammTokens.add(tokensIn);
+  const newRealSol = vammK.div(newTokenSide).sub(VIRTUAL_SOL);
+  return vammRealSol.sub(newRealSol);
+}
+function calculateSolForExactTokens(tokensOut, vammRealSol, vammTokens, vammK) {
+  if (tokensOut.isZero() || tokensOut.isNeg()) return ZERO;
+  if (tokensOut.gte(vammTokens)) throw new Error("tokensOut exceeds available vAMM liquidity");
+  const newTokenSide = vammTokens.sub(tokensOut);
+  const newSolSide = vammK.div(newTokenSide);
+  const currentSolSide = vammRealSol.add(VIRTUAL_SOL);
+  return newSolSide.sub(currentSolSide);
+}
+function applySlippage(amount, slippageBps) {
+  return amount.mul(new BN2__default.default(1e4 - slippageBps)).div(BPS);
+}
+function calculateTradableVaultedSplit(tokensOut, tokensSold, bandSize = BAND_SIZE) {
+  if (tokensOut.isZero()) return { tradable: ZERO, vaulted: ZERO, tradablePct: 0 };
+  const bandIndex = bandSize.isZero() ? 0 : tokensSold.div(bandSize).toNumber();
+  const tradablePct = Math.min(BASE_TRADABLE_PCT + PCT_PER_BAND * bandIndex, MAX_TRADABLE_PCT);
+  const tradable = tokensOut.mul(new BN2__default.default(tradablePct)).div(new BN2__default.default(100));
+  const vaulted = tokensOut.sub(tradable);
+  return { tradable, vaulted, tradablePct };
+}
+function calculateAccruedTokens(initialVaulted, tokensTransferred, entryTimestamp, vestDuration, currentTimestamp) {
+  if (initialVaulted.isZero()) return ZERO;
+  const remaining = initialVaulted.sub(tokensTransferred);
+  if (vestDuration.isZero()) return remaining;
+  const elapsed = currentTimestamp.sub(entryTimestamp);
+  if (elapsed.isNeg()) return ZERO;
+  if (elapsed.gte(vestDuration)) return remaining;
+  const totalAccrued = initialVaulted.mul(elapsed).div(vestDuration);
+  const claimable = totalAccrued.sub(tokensTransferred);
+  return claimable.isNeg() ? ZERO : claimable;
+}
+function calculateSpotPrice(vammRealSol, vammTokens) {
+  if (vammTokens.isZero()) return ZERO;
+  return vammRealSol.add(VIRTUAL_SOL).mul(new BN2__default.default(1e6)).div(vammTokens);
+}
+function calculatePriceImpact(solIn, tokensOut, vammRealSol, vammTokens) {
+  if (solIn.isZero() || tokensOut.isZero() || vammTokens.isZero()) return 0;
+  const solSide = vammRealSol.add(VIRTUAL_SOL);
+  const numerator = solIn.mul(vammTokens).mul(BPS);
+  const denominator = tokensOut.mul(solSide);
+  if (denominator.isZero()) return 0;
+  const ratioBps = numerator.div(denominator);
+  return ratioBps.sub(BPS).toNumber();
+}
+
+// src/idl/hodl.json
+var hodl_default = {
+  address: "hodLrUfwyK3Z7Td5hdZhyojyznG1rqbHVex11y5s4yG",
+  metadata: {
+    name: "hodl",
+    version: "0.1.0",
+    spec: "0.1.0"
+  },
+  instructions: [
+    {
+      name: "buy",
+      docs: [
+        "Buy tokens from the vAMM",
+        "",
+        "Tokens are split into tradable (immediate) and vaulted (accrue linearly).",
+        "Allocation is based on token-amount range bands: 40/60 at 0-50M, +5% per 50M band, 100/0 at 600M+.",
+        "After vest_duration passes, all buys are 100% tradable."
+      ],
+      discriminator: [
+        102,
+        6,
+        61,
+        18,
+        1,
+        218,
+        235,
+        234
+      ],
+      accounts: [
+        {
+          name: "buyer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_vault",
+          writable: true
+        },
+        {
+          name: "vault_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "buyer_token_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "buyer"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "pool_sol_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  111,
+                  108,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "position",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              },
+              {
+                kind: "account",
+                path: "buyer"
+              }
+            ]
+          }
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: [
+        {
+          name: "sol_amount",
+          type: "u64"
+        },
+        {
+          name: "min_tokens_out",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "claim_accrued",
+      docs: [
+        "Claim accrued tokens",
+        "Transfers tokens that have accrued from vaulted to tradable from vault to wallet"
+      ],
+      discriminator: [
+        209,
+        92,
+        30,
+        216,
+        89,
+        249,
+        122,
+        243
+      ],
+      accounts: [
+        {
+          name: "owner",
+          signer: true
+        },
+        {
+          name: "pool_state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state.mint",
+                account: "PoolState"
+              }
+            ]
+          }
+        },
+        {
+          name: "position",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              },
+              {
+                kind: "account",
+                path: "owner"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_vault",
+          writable: true
+        },
+        {
+          name: "vault_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "user_token_account",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "close_position",
+      docs: [
+        "Close an empty position account and reclaim rent"
+      ],
+      discriminator: [
+        123,
+        134,
+        81,
+        0,
+        49,
+        68,
+        98,
+        98
+      ],
+      accounts: [
+        {
+          name: "owner",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_state",
+          writable: true
+        },
+        {
+          name: "position",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              },
+              {
+                kind: "account",
+                path: "owner"
+              }
+            ]
+          }
+        },
+        {
+          name: "user_token_account",
+          writable: true
+        },
+        {
+          name: "mint"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_token",
+      docs: [
+        "Create a new token and initialize vAMM pool"
+      ],
+      discriminator: [
+        84,
+        52,
+        204,
+        228,
+        24,
+        140,
+        234,
+        75
+      ],
+      accounts: [
+        {
+          name: "creator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "protocol_authority"
+        },
+        {
+          name: "mint",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_vault",
+          writable: true
+        },
+        {
+          name: "vault_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "metadata",
+          writable: true
+        },
+        {
+          name: "pool_sol_account",
+          writable: true
+        },
+        {
+          name: "protocol_fee_wallet",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  114,
+                  111,
+                  116,
+                  111,
+                  99,
+                  111,
+                  108,
+                  95,
+                  102,
+                  101,
+                  101,
+                  115
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "rent",
+          address: "SysvarRent111111111111111111111111111111111"
+        },
+        {
+          name: "metadata_program"
+        },
+        {
+          name: "sysvar_instructions"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "symbol",
+          type: "string"
+        },
+        {
+          name: "uri",
+          type: "string"
+        },
+        {
+          name: "pool_description",
+          type: "string"
+        },
+        {
+          name: "vest_duration",
+          type: "i64"
+        }
+      ]
+    },
+    {
+      name: "emergency_withdraw_sol",
+      docs: [
+        "Emergency withdraw SOL from a pool's sol_vault"
+      ],
+      discriminator: [
+        219,
+        156,
+        123,
+        176,
+        91,
+        105,
+        30,
+        160
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_state"
+        },
+        {
+          name: "sol_vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  111,
+                  108,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "sell",
+      docs: [
+        "Sell tokens back to the vAMM",
+        "If sell_percentage is provided, it overrides token_amount"
+      ],
+      discriminator: [
+        51,
+        230,
+        133,
+        164,
+        1,
+        127,
+        131,
+        173
+      ],
+      accounts: [
+        {
+          name: "seller",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_state",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "position",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              },
+              {
+                kind: "account",
+                path: "seller"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_vault",
+          writable: true
+        },
+        {
+          name: "vault_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "seller_token_account",
+          writable: true
+        },
+        {
+          name: "pool_sol_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  111,
+                  108,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool_state"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: [
+        {
+          name: "token_amount",
+          type: "u64"
+        },
+        {
+          name: "min_sol_out",
+          type: "u64"
+        },
+        {
+          name: "sell_percentage",
+          type: {
+            option: "u8"
+          }
+        }
+      ]
+    },
+    {
+      name: "withdraw_protocol_fees",
+      docs: [
+        "Withdraw accumulated protocol fees"
+      ],
+      discriminator: [
+        11,
+        68,
+        165,
+        98,
+        18,
+        208,
+        134,
+        73
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "protocol_fee_wallet",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  114,
+                  111,
+                  116,
+                  111,
+                  99,
+                  111,
+                  108,
+                  95,
+                  102,
+                  101,
+                  101,
+                  115
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "PoolState",
+      discriminator: [
+        247,
+        237,
+        227,
+        245,
+        215,
+        195,
+        222,
+        70
+      ]
+    },
+    {
+      name: "Position",
+      discriminator: [
+        170,
+        188,
+        143,
+        228,
+        122,
+        64,
+        247,
+        208
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AccrualClaimed",
+      discriminator: [
+        86,
+        99,
+        51,
+        211,
+        226,
+        48,
+        235,
+        238
+      ]
+    },
+    {
+      name: "PositionClosed",
+      discriminator: [
+        157,
+        163,
+        227,
+        228,
+        13,
+        97,
+        138,
+        121
+      ]
+    },
+    {
+      name: "TokenCreated",
+      discriminator: [
+        236,
+        19,
+        41,
+        255,
+        130,
+        78,
+        147,
+        172
+      ]
+    },
+    {
+      name: "TokenPurchased",
+      discriminator: [
+        3,
+        73,
+        186,
+        50,
+        15,
+        181,
+        213,
+        37
+      ]
+    },
+    {
+      name: "TokenSold",
+      discriminator: [
+        88,
+        61,
+        1,
+        247,
+        185,
+        6,
+        252,
+        86
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 7005,
+      name: "InsufficientTokens",
+      msg: "Insufficient token reserves in vault"
+    },
+    {
+      code: 7100,
+      name: "ArithmeticOverflow",
+      msg: "Arithmetic overflow"
+    },
+    {
+      code: 7102,
+      name: "DivisionError",
+      msg: "Division by zero or invalid division"
+    },
+    {
+      code: 7104,
+      name: "TokenOverflow",
+      msg: "Token calculation overflow"
+    },
+    {
+      code: 7105,
+      name: "TokenUnderflow",
+      msg: "Token calculation underflow"
+    },
+    {
+      code: 7200,
+      name: "SlippageExceeded",
+      msg: "Slippage exceeded: output below minimum threshold"
+    },
+    {
+      code: 7312,
+      name: "AccrualCalculationOverflow",
+      msg: "Accrual calculation overflow"
+    },
+    {
+      code: 7315,
+      name: "PositionNotEmpty",
+      msg: "Position is not empty, must sell all tokens first"
+    },
+    {
+      code: 7319,
+      name: "InvalidProtocolAuthority",
+      msg: "Invalid protocol authority - must match PROTOCOL_AUTHORITY constant"
+    },
+    {
+      code: 7321,
+      name: "MustHaveUnlockedPortion",
+      msg: "Position must have tokens to perform this operation"
+    },
+    {
+      code: 7500,
+      name: "PositionNotOwnedBySigner",
+      msg: "Position not owned by signer"
+    },
+    {
+      code: 7505,
+      name: "InvalidSolVaultPDA",
+      msg: "SOL vault PDA derivation mismatch"
+    },
+    {
+      code: 7601,
+      name: "InvalidVestingType",
+      msg: "Invalid vesting type"
+    },
+    {
+      code: 7604,
+      name: "InvalidPercentage",
+      msg: "Invalid percentage value (must be 0-100)"
+    },
+    {
+      code: 7901,
+      name: "NotAuthorized",
+      msg: "Not authorized"
+    },
+    {
+      code: 8014,
+      name: "InsufficientLiquidity",
+      msg: "Insufficient liquidity"
+    },
+    {
+      code: 8018,
+      name: "VammNotActive",
+      msg: "vAMM is not active"
+    },
+    {
+      code: 8020,
+      name: "InvalidAmount",
+      msg: "Invalid amount"
+    }
+  ],
+  types: [
+    {
+      name: "AccrualClaimed",
+      docs: [
+        "Event emitted when accrued tokens are claimed"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "position",
+            type: "pubkey"
+          },
+          {
+            name: "tokens_claimed",
+            type: "u64"
+          },
+          {
+            name: "new_tradable_tokens",
+            type: "u64"
+          },
+          {
+            name: "remaining_vaulted_tokens",
+            type: "u64"
+          },
+          {
+            name: "tokens_transferred",
+            type: "u64"
+          },
+          {
+            name: "initial_vaulted",
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "PoolMetadata",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "name",
+            docs: [
+              "Optional pool name"
+            ],
+            type: "string"
+          },
+          {
+            name: "description",
+            docs: [
+              "Optional pool description"
+            ],
+            type: "string"
+          },
+          {
+            name: "version",
+            docs: [
+              "Pool version"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "PoolState",
+      docs: [
+        "Pool state account - main state for a vAMM pool"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            docs: [
+              "Pool authority (creator)"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            docs: [
+              "Token mint for this pool"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "token_vault",
+            docs: [
+              "Token vault (holds unsold tokens)"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "vault_authority",
+            docs: [
+              "Vault authority (PDA)"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "sol_vault",
+            docs: [
+              "Pool SOL vault (holds raised SOL)"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "total_positions",
+            docs: [
+              "Total number of positions in this pool"
+            ],
+            type: "u64"
+          },
+          {
+            name: "creation_timestamp",
+            docs: [
+              "Pool creation timestamp (Unix timestamp)"
+            ],
+            type: "i64"
+          },
+          {
+            name: "last_update_timestamp",
+            docs: [
+              "Last update timestamp (Unix timestamp)"
+            ],
+            type: "i64"
+          },
+          {
+            name: "metadata",
+            docs: [
+              "Pool metadata"
+            ],
+            type: {
+              defined: {
+                name: "PoolMetadata"
+              }
+            }
+          },
+          {
+            name: "vest_duration",
+            docs: [
+              "=== ACCRUAL SYSTEM FIELDS ===",
+              "Dev-set unlock duration in seconds (applies to all traders)"
+            ],
+            type: "i64"
+          },
+          {
+            name: "next_position_number",
+            docs: [
+              "Next position number to assign (sequential counter for display/identity)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vamm_active",
+            docs: [
+              "=== VAMM STATE ===",
+              "vAMM is active for trading"
+            ],
+            type: "bool"
+          },
+          {
+            name: "vamm_real_sol",
+            docs: [
+              "Real SOL in the vAMM"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vamm_tokens",
+            docs: [
+              "Real tokens in the vAMM"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vamm_k",
+            docs: [
+              "The invariant k (set at creation, never changes)",
+              "k = (vamm_real_sol + VIRTUAL_SOL) * vamm_tokens"
+            ],
+            type: "u128"
+          },
+          {
+            name: "tokens_sold",
+            docs: [
+              "Cumulative tokens bought from vAMM (increases on buy, decreases on sell)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "tokens_reserved_for_claims",
+            docs: [
+              "Vault tokens reserved for position claims (not available for vAMM liquidity)",
+              "Incremented on buy (vaulted portion), decremented on claim_accrued"
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump_vault_auth",
+            docs: [
+              "Bump seeds for PDAs"
+            ],
+            type: "u8"
+          },
+          {
+            name: "bump_pool",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "Position",
+      docs: [
+        "Position in a vAMM pool",
+        "Tokens split into tradable (immediate) and vaulted (accrue linearly over vest_duration)"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            docs: [
+              "Owner's public key"
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "pool",
+            docs: [
+              "Pool this position belongs to"
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "tradable_tokens",
+            docs: [
+              "Tradable tokens (can be sold immediately)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vaulted_tokens",
+            docs: [
+              "Vaulted tokens (accruing linearly to tradable)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "sol_spent",
+            docs: [
+              "SOL spent on this position"
+            ],
+            type: "u64"
+          },
+          {
+            name: "tokens_transferred",
+            docs: [
+              "Cumulative tokens transferred to wallet (for claim_accrued tracking)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "entry_timestamp",
+            docs: [
+              "Entry timestamp (for accrual calculation)"
+            ],
+            type: "i64"
+          },
+          {
+            name: "initial_vaulted",
+            docs: [
+              "Cumulative initial vaulted tokens from all buys (for accrual calculation)",
+              "This tracks the total vaulted amount at buy time, used to calculate accrual progress"
+            ],
+            type: "u64"
+          },
+          {
+            name: "position_number",
+            docs: [
+              "Position number in the pool (sequential counter for display/identity)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "last_update_timestamp",
+            docs: [
+              "Last update timestamp"
+            ],
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "PositionClosed",
+      docs: [
+        "Event emitted when a position account is closed"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "position",
+            type: "pubkey"
+          },
+          {
+            name: "rent_reclaimed",
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "TokenCreated",
+      docs: [
+        "Event emitted when a new token and vAMM pool is created"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "creator",
+            type: "pubkey"
+          },
+          {
+            name: "name",
+            type: "string"
+          },
+          {
+            name: "symbol",
+            type: "string"
+          },
+          {
+            name: "total_supply",
+            type: "u64"
+          },
+          {
+            name: "initial_k",
+            type: "u128"
+          },
+          {
+            name: "vamm_tokens",
+            type: "u64"
+          },
+          {
+            name: "vest_duration",
+            type: "i64"
+          },
+          {
+            name: "creation_timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "TokenPurchased",
+      docs: [
+        "Event emitted when tokens are bought"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "buyer",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "sol_amount",
+            type: "u64"
+          },
+          {
+            name: "tokens_received",
+            type: "u64"
+          },
+          {
+            name: "vamm_real_sol",
+            type: "u64"
+          },
+          {
+            name: "vamm_tokens",
+            type: "u64"
+          },
+          {
+            name: "tokens_sold",
+            type: "u64"
+          },
+          {
+            name: "position",
+            type: "pubkey"
+          },
+          {
+            name: "position_number",
+            type: "u64"
+          },
+          {
+            name: "vest_duration",
+            type: "i64"
+          },
+          {
+            name: "unlock_time_seconds",
+            type: "i64"
+          },
+          {
+            name: "tradable_tokens",
+            docs: [
+              "Position state after buy"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vaulted_tokens",
+            type: "u64"
+          },
+          {
+            name: "sol_spent",
+            type: "u64"
+          },
+          {
+            name: "tokens_transferred",
+            type: "u64"
+          },
+          {
+            name: "initial_vaulted",
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "TokenSold",
+      docs: [
+        "Event emitted when tokens are sold"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "seller",
+            type: "pubkey"
+          },
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            type: "pubkey"
+          },
+          {
+            name: "token_amount",
+            type: "u64"
+          },
+          {
+            name: "sol_received",
+            type: "u64"
+          },
+          {
+            name: "vamm_real_sol",
+            type: "u64"
+          },
+          {
+            name: "vamm_tokens",
+            type: "u64"
+          },
+          {
+            name: "tokens_sold",
+            type: "u64"
+          },
+          {
+            name: "position",
+            type: "pubkey"
+          },
+          {
+            name: "position_number",
+            type: "u64"
+          },
+          {
+            name: "vest_duration",
+            type: "i64"
+          },
+          {
+            name: "unlock_time_seconds",
+            type: "i64"
+          },
+          {
+            name: "tradable_tokens",
+            docs: [
+              "Position state after sell"
+            ],
+            type: "u64"
+          },
+          {
+            name: "vaulted_tokens",
+            type: "u64"
+          },
+          {
+            name: "sol_spent",
+            type: "u64"
+          },
+          {
+            name: "tokens_transferred",
+            type: "u64"
+          },
+          {
+            name: "initial_vaulted",
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/program.ts
+var DUMMY_WALLET = {
+  publicKey: web3_js.PublicKey.default,
+  signTransaction: async (tx) => tx,
+  signAllTransactions: async (txs) => txs
+};
+function getProgram(connection) {
+  const provider = new anchor.AnchorProvider(connection, DUMMY_WALLET, { commitment: "confirmed" });
+  return new anchor.Program(hodl_default, provider);
+}
+
+// src/accounts.ts
+async function fetchPoolState(connection, mint, config) {
+  const program = getProgram(connection);
+  const [poolStatePDA] = getPoolStatePDA(mint, config.programId);
+  return program.account.poolState.fetch(poolStatePDA);
+}
+async function fetchPosition(connection, poolState, owner, config) {
+  const program = getProgram(connection);
+  const [positionPDA] = getPositionPDA(poolState, owner, config.programId);
+  return program.account.position.fetch(positionPDA);
+}
+async function fetchPoolStateByAddress(connection, poolStatePDA) {
+  const program = getProgram(connection);
+  return program.account.poolState.fetch(poolStatePDA);
+}
+var METADATA_PROGRAM_ID = new web3_js.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+function getMetadataPDA(mint) {
+  const [pda] = web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("metadata"), METADATA_PROGRAM_ID.toBuffer(), mint.toBuffer()],
+    METADATA_PROGRAM_ID
+  );
+  return pda;
+}
+async function buildBuyInstruction(params) {
+  const { buyer, mint, solAmount, minTokensOut, connection, config } = params;
+  const program = getProgram(connection);
+  const [poolState] = getPoolStatePDA(mint, config.programId);
+  const [vaultAuthority] = getVaultAuthorityPDA(poolState, config.programId);
+  const tokenVault = splToken.getAssociatedTokenAddressSync(mint, vaultAuthority, true);
+  const buyerTokenAccount = splToken.getAssociatedTokenAddressSync(mint, buyer);
+  const [poolSolAccount] = getSolVaultPDA(poolState, config.programId);
+  const [position] = getPositionPDA(poolState, buyer, config.programId);
+  const [eventAuthority] = getEventAuthorityPDA(config.programId);
+  return program.methods.buy(solAmount, minTokensOut).accountsPartial({
+    buyer,
+    poolState,
+    tokenVault,
+    vaultAuthority,
+    buyerTokenAccount,
+    poolSolAccount,
+    mint,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    position,
+    eventAuthority,
+    program: config.programId
+  }).instruction();
+}
+async function buildSellInstruction(params) {
+  const { seller, mint, tokenAmount, minSolOut, sellPercentage, connection, config } = params;
+  const program = getProgram(connection);
+  const [poolState] = getPoolStatePDA(mint, config.programId);
+  const [vaultAuthority] = getVaultAuthorityPDA(poolState, config.programId);
+  const tokenVault = splToken.getAssociatedTokenAddressSync(mint, vaultAuthority, true);
+  const sellerTokenAccount = splToken.getAssociatedTokenAddressSync(mint, seller);
+  const [poolSolAccount] = getSolVaultPDA(poolState, config.programId);
+  const [position] = getPositionPDA(poolState, seller, config.programId);
+  const [eventAuthority] = getEventAuthorityPDA(config.programId);
+  return program.methods.sell(tokenAmount, minSolOut, sellPercentage ?? null).accountsPartial({
+    seller,
+    poolState,
+    position,
+    tokenVault,
+    vaultAuthority,
+    sellerTokenAccount,
+    poolSolAccount,
+    mint,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    eventAuthority,
+    program: config.programId
+  }).instruction();
+}
+async function buildCreateTokenInstruction(params) {
+  const { creator, mint, name, symbol, uri, poolDescription, vestDuration, connection, config } = params;
+  const program = getProgram(connection);
+  const [poolState] = getPoolStatePDA(mint, config.programId);
+  const [vaultAuthority] = getVaultAuthorityPDA(poolState, config.programId);
+  const tokenVault = splToken.getAssociatedTokenAddressSync(mint, vaultAuthority, true);
+  const metadata = getMetadataPDA(mint);
+  const [poolSolAccount] = getSolVaultPDA(poolState, config.programId);
+  const [protocolFeeWallet] = getProtocolFeesPDA(config.programId);
+  const [eventAuthority] = getEventAuthorityPDA(config.programId);
+  return program.methods.createToken(name, symbol, uri, poolDescription, vestDuration).accountsPartial({
+    creator,
+    protocolAuthority: config.protocolAuthority,
+    mint,
+    poolState,
+    tokenVault,
+    vaultAuthority,
+    metadata,
+    poolSolAccount,
+    protocolFeeWallet,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    rent: web3_js.SYSVAR_RENT_PUBKEY,
+    metadataProgram: METADATA_PROGRAM_ID,
+    sysvarInstructions: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
+    eventAuthority,
+    program: config.programId
+  }).instruction();
+}
+async function buildClaimAccruedInstruction(params) {
+  const { owner, poolState, connection, config } = params;
+  const program = getProgram(connection);
+  const poolData = await program.account.poolState.fetch(poolState);
+  const mint = poolData.mint;
+  const [vaultAuthority] = getVaultAuthorityPDA(poolState, config.programId);
+  const tokenVault = splToken.getAssociatedTokenAddressSync(mint, vaultAuthority, true);
+  const userTokenAccount = splToken.getAssociatedTokenAddressSync(mint, owner);
+  const [position] = getPositionPDA(poolState, owner, config.programId);
+  const [eventAuthority] = getEventAuthorityPDA(config.programId);
+  return program.methods.claimAccrued().accountsPartial({
+    owner,
+    poolState,
+    position,
+    tokenVault,
+    vaultAuthority,
+    userTokenAccount,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    eventAuthority,
+    program: config.programId
+  }).instruction();
+}
+async function buildClosePositionInstruction(params) {
+  const { owner, poolState, mint, userTokenAccount, connection, config } = params;
+  const program = getProgram(connection);
+  const [position] = getPositionPDA(poolState, owner, config.programId);
+  const [eventAuthority] = getEventAuthorityPDA(config.programId);
+  return program.methods.closePosition().accountsPartial({
+    owner,
+    poolState,
+    position,
+    userTokenAccount,
+    mint,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId,
+    eventAuthority,
+    program: config.programId
+  }).instruction();
+}
+function parseTransactionEvents(input, config) {
+  if (!input) return [];
+  const logs = Array.isArray(input) ? input : input.meta?.logMessages ?? [];
+  if (logs.length === 0) return [];
+  const coder = new anchor.BorshCoder(hodl_default);
+  const parser = new anchor.EventParser(config.programId, coder);
+  const events = [];
+  try {
+    for (const event of parser.parseLogs(logs)) {
+      events.push({ name: event.name, data: event.data });
+    }
+  } catch {
+  }
+  return events;
+}
+async function fetchAndParseTransaction(connection, signature, config) {
+  const tx = await connection.getTransaction(signature, {
+    commitment: "confirmed",
+    maxSupportedTransactionVersion: 0
+  });
+  return parseTransactionEvents(tx, config);
+}
+function subscribeToEvents(connection, config, onEvent, opts = {}) {
+  const commitment = opts.commitment ?? "confirmed";
+  const coder = new anchor.BorshCoder(hodl_default);
+  const parser = new anchor.EventParser(config.programId, coder);
+  return connection.onLogs(
+    config.programId,
+    ({ logs, err, signature }, context) => {
+      if (err) {
+        opts.onError?.(new Error(`Log subscription error: ${JSON.stringify(err)}`));
+        return;
+      }
+      try {
+        for (const event of parser.parseLogs(logs)) {
+          onEvent(
+            { name: event.name, data: event.data },
+            context.slot,
+            signature
+          );
+        }
+      } catch (e) {
+        opts.onError?.(e instanceof Error ? e : new Error(String(e)));
+      }
+    },
+    commitment
+  );
+}
+function unsubscribeFromEvents(connection, subscriptionId) {
+  return connection.removeOnLogsListener(subscriptionId);
+}
+function subscribeToTokenPurchased(connection, config, onEvent, opts) {
+  return subscribeToEvents(connection, config, (event, slot, sig) => {
+    if (event.name === "tokenPurchased") onEvent(event.data, slot, sig);
+  }, opts);
+}
+function subscribeToTokenSold(connection, config, onEvent, opts) {
+  return subscribeToEvents(connection, config, (event, slot, sig) => {
+    if (event.name === "tokenSold") onEvent(event.data, slot, sig);
+  }, opts);
+}
+function subscribeToTokenCreated(connection, config, onEvent, opts) {
+  return subscribeToEvents(connection, config, (event, slot, sig) => {
+    if (event.name === "tokenCreated") onEvent(event.data, slot, sig);
+  }, opts);
+}
+function subscribeToAccrualClaimed(connection, config, onEvent, opts) {
+  return subscribeToEvents(connection, config, (event, slot, sig) => {
+    if (event.name === "accrualClaimed") onEvent(event.data, slot, sig);
+  }, opts);
+}
+function subscribeToPositionClosed(connection, config, onEvent, opts) {
+  return subscribeToEvents(connection, config, (event, slot, sig) => {
+    if (event.name === "positionClosed") onEvent(event.data, slot, sig);
+  }, opts);
+}
+async function buildTransaction(connection, instructions, payer, opts = {}) {
+  const cuLimit = opts.computeUnits ?? 2e5;
+  const priorityFee = opts.priorityFee ?? 1e3;
+  const computeIxs = [
+    web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: cuLimit }),
+    web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee })
+  ];
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const message = new web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions: [...computeIxs, ...instructions]
+  }).compileToV0Message();
+  return new web3_js.VersionedTransaction(message);
+}
+async function sendTransaction(connection, tx, opts = {}) {
+  const sig = await connection.sendTransaction(tx, {
+    skipPreflight: opts.skipPreflight ?? false,
+    maxRetries: 3
+  });
+  const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+  await connection.confirmTransaction({
+    signature: sig,
+    ...latestBlockhash
+  }, "confirmed");
+  return sig;
+}
+
+// src/client.ts
+var HodlClient = class {
+  connection;
+  config;
+  constructor({ connection, config }) {
+    this.connection = connection;
+    this.config = config ?? MAINNET_CONFIG;
+  }
+  fetchPool(mint) {
+    return fetchPoolState(this.connection, mint, this.config);
+  }
+  fetchPosition(poolState, owner) {
+    return fetchPosition(this.connection, poolState, owner, this.config);
+  }
+  async buy(params, opts) {
+    const ix = await buildBuyInstruction({ ...params, connection: this.connection, config: this.config });
+    return buildTransaction(this.connection, [ix], params.buyer, opts);
+  }
+  async sell(params, opts) {
+    const ix = await buildSellInstruction({ ...params, connection: this.connection, config: this.config });
+    return buildTransaction(this.connection, [ix], params.seller, opts);
+  }
+  async createToken(params, opts) {
+    const ix = await buildCreateTokenInstruction({ ...params, connection: this.connection, config: this.config });
+    return buildTransaction(this.connection, [ix], params.creator, opts);
+  }
+  async claimAccrued(params, opts) {
+    const ix = await buildClaimAccruedInstruction({ ...params, connection: this.connection, config: this.config });
+    return buildTransaction(this.connection, [ix], params.owner, opts);
+  }
+  async closePosition(params, opts) {
+    const ix = await buildClosePositionInstruction({ ...params, connection: this.connection, config: this.config });
+    return buildTransaction(this.connection, [ix], params.owner, opts);
+  }
+  send(tx, opts) {
+    return sendTransaction(this.connection, tx, opts);
+  }
+  subscribeToEvents(onEvent, opts) {
+    return subscribeToEvents(this.connection, this.config, onEvent, opts);
+  }
+  unsubscribe(subscriptionId) {
+    return unsubscribeFromEvents(this.connection, subscriptionId);
+  }
+  fetchAndParseTransaction(signature) {
+    return fetchAndParseTransaction(this.connection, signature, this.config);
+  }
+};
+
+exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
+exports.DECIMALS = DECIMALS;
+exports.DEVNET_CONFIG = DEVNET_CONFIG;
+exports.HODL_ERRORS = HODL_ERRORS;
+exports.HodlClient = HodlClient;
+exports.HodlError = HodlError;
+exports.LIMITS = LIMITS;
+exports.MAINNET_CONFIG = MAINNET_CONFIG;
+exports.PROGRAM_ID = PROGRAM_ID;
+exports.PROTOCOL_AUTHORITY = PROTOCOL_AUTHORITY;
+exports.PROTOCOL_MINT_FEE = PROTOCOL_MINT_FEE;
+exports.SEEDS = SEEDS;
+exports.TOTAL_SUPPLY = TOTAL_SUPPLY;
+exports.TRADE_FEE_BPS = TRADE_FEE_BPS;
+exports.VEST_DURATION = VEST_DURATION;
+exports.VIRTUAL_SOL = VIRTUAL_SOL;
+exports.applySlippage = applySlippage;
+exports.buildBuyInstruction = buildBuyInstruction;
+exports.buildClaimAccruedInstruction = buildClaimAccruedInstruction;
+exports.buildClosePositionInstruction = buildClosePositionInstruction;
+exports.buildCreateTokenInstruction = buildCreateTokenInstruction;
+exports.buildSellInstruction = buildSellInstruction;
+exports.buildTransaction = buildTransaction;
+exports.calculateAccruedTokens = calculateAccruedTokens;
+exports.calculateBuyAmount = calculateBuyAmount;
+exports.calculatePriceImpact = calculatePriceImpact;
+exports.calculateSellAmount = calculateSellAmount;
+exports.calculateSolForExactTokens = calculateSolForExactTokens;
+exports.calculateSpotPrice = calculateSpotPrice;
+exports.calculateTradableVaultedSplit = calculateTradableVaultedSplit;
+exports.fetchAndParseTransaction = fetchAndParseTransaction;
+exports.fetchPoolState = fetchPoolState;
+exports.fetchPoolStateByAddress = fetchPoolStateByAddress;
+exports.fetchPosition = fetchPosition;
+exports.getEventAuthorityPDA = getEventAuthorityPDA;
+exports.getPoolStatePDA = getPoolStatePDA;
+exports.getPositionPDA = getPositionPDA;
+exports.getProtocolFeesPDA = getProtocolFeesPDA;
+exports.getSolVaultPDA = getSolVaultPDA;
+exports.getVaultAuthorityPDA = getVaultAuthorityPDA;
+exports.parseHodlError = parseHodlError;
+exports.parseTransactionEvents = parseTransactionEvents;
+exports.sendTransaction = sendTransaction;
+exports.subscribeToAccrualClaimed = subscribeToAccrualClaimed;
+exports.subscribeToEvents = subscribeToEvents;
+exports.subscribeToPositionClosed = subscribeToPositionClosed;
+exports.subscribeToTokenCreated = subscribeToTokenCreated;
+exports.subscribeToTokenPurchased = subscribeToTokenPurchased;
+exports.subscribeToTokenSold = subscribeToTokenSold;
+exports.unsubscribeFromEvents = unsubscribeFromEvents;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map