@voltr/vault-sdk 2.0.0 → 2.1.1

package/src/extensions/events.ts

@@ -0,0 +1,339 @@
+import { getBase64Encoder, type Decoder } from "@solana/kit";
+
+import {
+  getAcceptProtocolAdminEventDecoder,
+  getAcceptVaultAdminEventDecoder,
+  getAddAdaptorEventDecoder,
+  getCalibrateHighWaterMarkEventDecoder,
+  getCalibrateHighWaterMarkUnsafeEventDecoder,
+  getCancelRequestWithdrawVaultEventDecoder,
+  getCloseStrategyEventDecoder,
+  getDepositStrategyEventDecoder,
+  getDepositVaultEventDecoder,
+  getDirectWithdrawStrategyEventDecoder,
+  getHarvestFeeEventDecoder,
+  getInitializeDirectWithdrawStrategyEventDecoder,
+  getInitializeStrategyEventDecoder,
+  getInitializeVaultEventDecoder,
+  getInitProtocolEventDecoder,
+  getInstantWithdrawStrategyEventDecoder,
+  getInstantWithdrawVaultEventDecoder,
+  getRemoveAdaptorEventDecoder,
+  getRequestWithdrawVaultEventDecoder,
+  getUpdateProtocolEventDecoder,
+  getUpdateVaultAdaptorPolicyEventDecoder,
+  getUpdateVaultConfigEventDecoder,
+  getUpdateVaultEventDecoder,
+  getUpdateVaultProtocolFeeEventDecoder,
+  getWithdrawStrategyEventDecoder,
+  getWithdrawVaultEventDecoder,
+  type AcceptProtocolAdminEvent,
+  type AcceptVaultAdminEvent,
+  type AddAdaptorEvent,
+  type CalibrateHighWaterMarkEvent,
+  type CalibrateHighWaterMarkUnsafeEvent,
+  type CancelRequestWithdrawVaultEvent,
+  type CloseStrategyEvent,
+  type DepositStrategyEvent,
+  type DepositVaultEvent,
+  type DirectWithdrawStrategyEvent,
+  type HarvestFeeEvent,
+  type InitializeDirectWithdrawStrategyEvent,
+  type InitializeStrategyEvent,
+  type InitializeVaultEvent,
+  type InitProtocolEvent,
+  type InstantWithdrawStrategyEvent,
+  type InstantWithdrawVaultEvent,
+  type RemoveAdaptorEvent,
+  type RequestWithdrawVaultEvent,
+  type UpdateProtocolEvent,
+  type UpdateVaultAdaptorPolicyEvent,
+  type UpdateVaultConfigEvent,
+  type UpdateVaultEvent,
+  type UpdateVaultProtocolFeeEvent,
+  type WithdrawStrategyEvent,
+  type WithdrawVaultEvent,
+} from "../generated/types";
+
+/**
+ * Discriminated union of every Voltr Vault event Codama can decode. The first
+ * 8 bytes of each Anchor `emit!` payload identify the variant via
+ * `sha256("event:<EventName>")[..8]`; the remainder is the borsh-encoded
+ * payload for the named struct.
+ */
+export type ParsedVoltrEvent =
+  | ParsedEventOf<"AcceptProtocolAdminEvent", AcceptProtocolAdminEvent>
+  | ParsedEventOf<"AcceptVaultAdminEvent", AcceptVaultAdminEvent>
+  | ParsedEventOf<"AddAdaptorEvent", AddAdaptorEvent>
+  | ParsedEventOf<"CalibrateHighWaterMarkEvent", CalibrateHighWaterMarkEvent>
+  | ParsedEventOf<
+      "CalibrateHighWaterMarkUnsafeEvent",
+      CalibrateHighWaterMarkUnsafeEvent
+    >
+  | ParsedEventOf<
+      "CancelRequestWithdrawVaultEvent",
+      CancelRequestWithdrawVaultEvent
+    >
+  | ParsedEventOf<"CloseStrategyEvent", CloseStrategyEvent>
+  | ParsedEventOf<"DepositStrategyEvent", DepositStrategyEvent>
+  | ParsedEventOf<"DepositVaultEvent", DepositVaultEvent>
+  | ParsedEventOf<"DirectWithdrawStrategyEvent", DirectWithdrawStrategyEvent>
+  | ParsedEventOf<"HarvestFeeEvent", HarvestFeeEvent>
+  | ParsedEventOf<"InitProtocolEvent", InitProtocolEvent>
+  | ParsedEventOf<
+      "InitializeDirectWithdrawStrategyEvent",
+      InitializeDirectWithdrawStrategyEvent
+    >
+  | ParsedEventOf<"InitializeStrategyEvent", InitializeStrategyEvent>
+  | ParsedEventOf<"InitializeVaultEvent", InitializeVaultEvent>
+  | ParsedEventOf<"InstantWithdrawStrategyEvent", InstantWithdrawStrategyEvent>
+  | ParsedEventOf<"InstantWithdrawVaultEvent", InstantWithdrawVaultEvent>
+  | ParsedEventOf<"RemoveAdaptorEvent", RemoveAdaptorEvent>
+  | ParsedEventOf<"RequestWithdrawVaultEvent", RequestWithdrawVaultEvent>
+  | ParsedEventOf<"UpdateProtocolEvent", UpdateProtocolEvent>
+  | ParsedEventOf<
+      "UpdateVaultAdaptorPolicyEvent",
+      UpdateVaultAdaptorPolicyEvent
+    >
+  | ParsedEventOf<"UpdateVaultConfigEvent", UpdateVaultConfigEvent>
+  | ParsedEventOf<"UpdateVaultEvent", UpdateVaultEvent>
+  | ParsedEventOf<"UpdateVaultProtocolFeeEvent", UpdateVaultProtocolFeeEvent>
+  | ParsedEventOf<"WithdrawStrategyEvent", WithdrawStrategyEvent>
+  | ParsedEventOf<"WithdrawVaultEvent", WithdrawVaultEvent>;
+
+type ParsedEventOf<Name extends string, Payload> = {
+  name: Name;
+  payload: Payload;
+  /** Top-level instruction index this event was emitted under. */
+  ixIndex: number;
+  /** Sequential index of this event within the transaction (0-based). */
+  eventIndex: number;
+};
+
+/**
+ * Minimal structural shape of a transaction `meta` object — narrow enough
+ * that callers can pass `meta` from any RPC client (web3.js legacy,
+ * @solana/kit, or a hand-rolled fixture) without conversion.
+ */
+export type TransactionMetaForEvents = {
+  logMessages?: readonly string[] | null;
+};
+
+type DispatchEntry = {
+  name: ParsedVoltrEvent["name"];
+  decoder: Decoder<unknown>;
+};
+
+// Discriminators are sha256("event:<EventName>")[..8] — stable, fixed by the
+// Anchor IDL. Hardcoded so this module has no runtime hashing dependency.
+const EVENT_TABLE: ReadonlyArray<
+  readonly [ParsedVoltrEvent["name"], readonly number[], Decoder<unknown>]
+> = [
+  [
+    "AcceptProtocolAdminEvent",
+    [0xc4, 0x5d, 0xad, 0xfd, 0xaf, 0x8c, 0x79, 0x20],
+    getAcceptProtocolAdminEventDecoder(),
+  ],
+  [
+    "AcceptVaultAdminEvent",
+    [0x8c, 0xff, 0x1d, 0x44, 0x10, 0xc2, 0xfb, 0x23],
+    getAcceptVaultAdminEventDecoder(),
+  ],
+  [
+    "AddAdaptorEvent",
+    [0x18, 0xb5, 0xc9, 0x94, 0xf0, 0xb7, 0xeb, 0x0c],
+    getAddAdaptorEventDecoder(),
+  ],
+  [
+    "CalibrateHighWaterMarkEvent",
+    [0x8c, 0x4c, 0xc3, 0x90, 0xb4, 0xb2, 0x00, 0x9b],
+    getCalibrateHighWaterMarkEventDecoder(),
+  ],
+  [
+    "CalibrateHighWaterMarkUnsafeEvent",
+    [0xcd, 0x4c, 0xa9, 0xff, 0x25, 0xe4, 0x41, 0x82],
+    getCalibrateHighWaterMarkUnsafeEventDecoder(),
+  ],
+  [
+    "CancelRequestWithdrawVaultEvent",
+    [0x2e, 0xa5, 0x18, 0x72, 0x01, 0x50, 0xcd, 0x88],
+    getCancelRequestWithdrawVaultEventDecoder(),
+  ],
+  [
+    "CloseStrategyEvent",
+    [0xd5, 0x5f, 0xdb, 0xa1, 0x11, 0xd0, 0x5d, 0xff],
+    getCloseStrategyEventDecoder(),
+  ],
+  [
+    "DepositStrategyEvent",
+    [0xca, 0xc9, 0x76, 0x31, 0x1d, 0xb4, 0x74, 0xaa],
+    getDepositStrategyEventDecoder(),
+  ],
+  [
+    "DepositVaultEvent",
+    [0x0b, 0x0f, 0x07, 0x5c, 0x96, 0x64, 0xa5, 0xe8],
+    getDepositVaultEventDecoder(),
+  ],
+  [
+    "DirectWithdrawStrategyEvent",
+    [0x71, 0xca, 0x97, 0x7c, 0x89, 0xff, 0x99, 0x65],
+    getDirectWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "HarvestFeeEvent",
+    [0x45, 0x30, 0xc0, 0x17, 0xe8, 0x16, 0x17, 0x1e],
+    getHarvestFeeEventDecoder(),
+  ],
+  [
+    "InitProtocolEvent",
+    [0x0d, 0x51, 0xb7, 0x84, 0x58, 0x2b, 0xca, 0xd5],
+    getInitProtocolEventDecoder(),
+  ],
+  [
+    "InitializeDirectWithdrawStrategyEvent",
+    [0xa9, 0x16, 0x39, 0x08, 0x0f, 0x49, 0xff, 0x73],
+    getInitializeDirectWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "InitializeStrategyEvent",
+    [0x1e, 0xe9, 0xd3, 0xf9, 0x53, 0xbc, 0xea, 0x98],
+    getInitializeStrategyEventDecoder(),
+  ],
+  [
+    "InitializeVaultEvent",
+    [0xb3, 0x4b, 0x32, 0xa1, 0xbf, 0x1c, 0xf5, 0x6b],
+    getInitializeVaultEventDecoder(),
+  ],
+  [
+    "InstantWithdrawStrategyEvent",
+    [0xdd, 0x17, 0x0c, 0xd7, 0x64, 0x2a, 0x61, 0x95],
+    getInstantWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "InstantWithdrawVaultEvent",
+    [0x2e, 0x39, 0x3c, 0x14, 0x06, 0xa0, 0xa4, 0xf7],
+    getInstantWithdrawVaultEventDecoder(),
+  ],
+  [
+    "RemoveAdaptorEvent",
+    [0x9b, 0xb2, 0x02, 0x1d, 0xf5, 0x56, 0xf6, 0x99],
+    getRemoveAdaptorEventDecoder(),
+  ],
+  [
+    "RequestWithdrawVaultEvent",
+    [0x3b, 0x5e, 0x1a, 0x26, 0x2f, 0x83, 0x9e, 0xa2],
+    getRequestWithdrawVaultEventDecoder(),
+  ],
+  [
+    "UpdateProtocolEvent",
+    [0x0e, 0xe3, 0xcc, 0xd9, 0x3e, 0x2e, 0xf1, 0xed],
+    getUpdateProtocolEventDecoder(),
+  ],
+  [
+    "UpdateVaultAdaptorPolicyEvent",
+    [0xd8, 0xbe, 0x81, 0xb6, 0xb5, 0x7b, 0xed, 0xbd],
+    getUpdateVaultAdaptorPolicyEventDecoder(),
+  ],
+  [
+    "UpdateVaultConfigEvent",
+    [0x3d, 0x5c, 0xce, 0x97, 0xa2, 0x28, 0xed, 0x67],
+    getUpdateVaultConfigEventDecoder(),
+  ],
+  [
+    "UpdateVaultEvent",
+    [0x7b, 0x1f, 0x1b, 0xbd, 0x66, 0x01, 0x79, 0x39],
+    getUpdateVaultEventDecoder(),
+  ],
+  [
+    "UpdateVaultProtocolFeeEvent",
+    [0xac, 0x01, 0xad, 0xe6, 0xe4, 0x3d, 0x4d, 0xf4],
+    getUpdateVaultProtocolFeeEventDecoder(),
+  ],
+  [
+    "WithdrawStrategyEvent",
+    [0x70, 0x2d, 0x10, 0xac, 0xaa, 0x21, 0x16, 0xd4],
+    getWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "WithdrawVaultEvent",
+    [0xc4, 0x7b, 0x4f, 0xd7, 0x04, 0xd6, 0x14, 0xc5],
+    getWithdrawVaultEventDecoder(),
+  ],
+];
+
+const DISPATCH: ReadonlyMap<string, DispatchEntry> = new Map(
+  EVENT_TABLE.map(([name, disc, decoder]) => [
+    discriminatorKey(disc),
+    { name, decoder },
+  ])
+);
+
+const PROGRAM_DATA_PREFIX = "Program data: ";
+// Top-level instructions log "Program <id> invoke [1]" — depth >1 is a CPI.
+const TOP_LEVEL_INVOKE_RE = /^Program \S+ invoke \[1\]$/;
+
+const base64Encoder = getBase64Encoder();
+
+/**
+ * Walk a transaction's `meta.logMessages`, decode every Voltr event emitted
+ * via Anchor's `emit!`, and return them in emission order. Lines whose
+ * discriminator doesn't belong to a Voltr event are skipped, so logs from
+ * other programs in the same tx are safe to pass through.
+ */
+export function parseTransactionEvents(
+  meta: TransactionMetaForEvents | null | undefined
+): ParsedVoltrEvent[] {
+  const logs = meta?.logMessages;
+  if (!logs || logs.length === 0) return [];
+
+  const out: ParsedVoltrEvent[] = [];
+  let ixIndex = -1;
+  let eventIndex = 0;
+
+  for (const line of logs) {
+    if (TOP_LEVEL_INVOKE_RE.test(line)) {
+      ixIndex++;
+      continue;
+    }
+    if (!line.startsWith(PROGRAM_DATA_PREFIX)) continue;
+
+    const b64 = line.slice(PROGRAM_DATA_PREFIX.length);
+    let bytes: Uint8Array;
+    try {
+      bytes = base64Encoder.encode(b64) as Uint8Array;
+    } catch {
+      continue;
+    }
+    if (bytes.length < 8) continue;
+
+    const entry = DISPATCH.get(discriminatorKey(bytes.subarray(0, 8)));
+    if (!entry) continue;
+
+    // The discriminator is 8 bytes of sha256, so spurious matches from other
+    // programs are unlikely but possible — and corrupt fixtures happen too.
+    // Skip the line rather than aborting the whole parse if borsh decode fails.
+    let payload: unknown;
+    try {
+      payload = entry.decoder.decode(bytes, 8);
+    } catch {
+      continue;
+    }
+    out.push({
+      name: entry.name,
+      payload,
+      ixIndex: ixIndex < 0 ? 0 : ixIndex,
+      eventIndex: eventIndex++,
+    } as ParsedVoltrEvent);
+  }
+
+  return out;
+}
+
+function discriminatorKey(disc: ArrayLike<number>): string {
+  let s = "";
+  for (let i = 0; i < disc.length; i++) {
+    const b = disc[i] & 0xff;
+    s += (b < 16 ? "0" : "") + b.toString(16);
+  }
+  return s;
+}

package/src/extensions/index.ts

@@ -1,5 +1,7 @@
+export * from "./adaptors";
 export * from "./batchFetchers";
 export * from "./decimal";
+export * from "./events";
 export * from "./fees";
 export * from "./lpEconomics";
 export * from "./math";

package/src/generated/accounts/protocol.ts

@@ -53,7 +53,7 @@ export type Protocol = {
   admin: Address;
   /** The operational state of the protocol. */
   operationalState: number;
-  /** previously used for fee, now unused */
+  /** Padding after the operational-state flags. */
   padding1: ReadonlyUint8Array;
   /** The bump for the protocol. */
   bump: number;
@@ -61,8 +61,8 @@ export type Protocol = {
   padding0: ReadonlyUint8Array;
   /** The pending admin for admin transfer. */
   pendingAdmin: Address;
-  /** Reserved space for future fields */
-  reserved: ReadonlyUint8Array;
+  /** The treasury that receives protocol fees. */
+  treasury: Address;
 };
 
 export type ProtocolArgs = {
@@ -70,7 +70,7 @@ export type ProtocolArgs = {
   admin: Address;
   /** The operational state of the protocol. */
   operationalState: number;
-  /** previously used for fee, now unused */
+  /** Padding after the operational-state flags. */
   padding1: ReadonlyUint8Array;
   /** The bump for the protocol. */
   bump: number;
@@ -78,8 +78,8 @@ export type ProtocolArgs = {
   padding0: ReadonlyUint8Array;
   /** The pending admin for admin transfer. */
   pendingAdmin: Address;
-  /** Reserved space for future fields */
-  reserved: ReadonlyUint8Array;
+  /** The treasury that receives protocol fees. */
+  treasury: Address;
 };
 
 /** Gets the encoder for {@link ProtocolArgs} account data. */
@@ -93,7 +93,7 @@ export function getProtocolEncoder(): FixedSizeEncoder<ProtocolArgs> {
       ["bump", getU8Encoder()],
       ["padding0", fixEncoderSize(getBytesEncoder(), 1)],
       ["pendingAdmin", getAddressEncoder()],
-      ["reserved", fixEncoderSize(getBytesEncoder(), 32)],
+      ["treasury", getAddressEncoder()],
     ]),
     (value) => ({ ...value, discriminator: PROTOCOL_DISCRIMINATOR }),
   );
@@ -109,7 +109,7 @@ export function getProtocolDecoder(): FixedSizeDecoder<Protocol> {
     ["bump", getU8Decoder()],
     ["padding0", fixDecoderSize(getBytesDecoder(), 1)],
     ["pendingAdmin", getAddressDecoder()],
-    ["reserved", fixDecoderSize(getBytesDecoder(), 32)],
+    ["treasury", getAddressDecoder()],
   ]);
 }
 

package/src/generated/accounts/vault.ts

@@ -112,7 +112,9 @@ export type Vault = {
   lastUpdatedTs: bigint;
   /** The version of the vault. */
   version: number;
-  /** padding to align future 8-byte fields on 8-byte boundaries. */
+  /** Protocol-admin-controlled adaptor allowlist bypass. */
+  allowAnyAdaptor: number;
+  /** Padding to keep `locked_profit_state` at its existing 8-byte-aligned offset. */
   padding0: ReadonlyUint8Array;
   /** The locked profit state of the vault. */
   lockedProfitState: LockedProfitState;
@@ -150,7 +152,9 @@ export type VaultArgs = {
   lastUpdatedTs: number | bigint;
   /** The version of the vault. */
   version: number;
-  /** padding to align future 8-byte fields on 8-byte boundaries. */
+  /** Protocol-admin-controlled adaptor allowlist bypass. */
+  allowAnyAdaptor: number;
+  /** Padding to keep `locked_profit_state` at its existing 8-byte-aligned offset. */
   padding0: ReadonlyUint8Array;
   /** The locked profit state of the vault. */
   lockedProfitState: LockedProfitStateArgs;
@@ -178,7 +182,8 @@ export function getVaultEncoder(): FixedSizeEncoder<VaultArgs> {
       ["highWaterMark", getHighWaterMarkEncoder()],
       ["lastUpdatedTs", getU64Encoder()],
       ["version", getU8Encoder()],
-      ["padding0", fixEncoderSize(getBytesEncoder(), 7)],
+      ["allowAnyAdaptor", getU8Encoder()],
+      ["padding0", fixEncoderSize(getBytesEncoder(), 6)],
       ["lockedProfitState", getLockedProfitStateEncoder()],
       ["reserved", fixEncoderSize(getBytesEncoder(), 240)],
     ]),
@@ -205,7 +210,8 @@ export function getVaultDecoder(): FixedSizeDecoder<Vault> {
     ["highWaterMark", getHighWaterMarkDecoder()],
     ["lastUpdatedTs", getU64Decoder()],
     ["version", getU8Decoder()],
-    ["padding0", fixDecoderSize(getBytesDecoder(), 7)],
+    ["allowAnyAdaptor", getU8Decoder()],
+    ["padding0", fixDecoderSize(getBytesDecoder(), 6)],
     ["lockedProfitState", getLockedProfitStateDecoder()],
     ["reserved", fixDecoderSize(getBytesDecoder(), 240)],
   ]);

package/src/generated/errors/voltrVault.ts

@@ -46,13 +46,19 @@ export const VOLTR_VAULT_ERROR__INVALID_INPUT = 0x177d; // 6013
 export const VOLTR_VAULT_ERROR__DIVISION_BY_ZERO = 0x177e; // 6014
 /** InstantWithdrawNotAllowed: Instant withdraw not allowed. */
 export const VOLTR_VAULT_ERROR__INSTANT_WITHDRAW_NOT_ALLOWED = 0x177f; // 6015
+/** AdaptorProgramNotWhitelisted: Adaptor program not whitelisted. */
+export const VOLTR_VAULT_ERROR__ADAPTOR_PROGRAM_NOT_WHITELISTED = 0x1780; // 6016
+/** InvalidAdaptorPolicy: Invalid adaptor policy. */
+export const VOLTR_VAULT_ERROR__INVALID_ADAPTOR_POLICY = 0x1781; // 6017
 
 export type VoltrVaultError =
   | typeof VOLTR_VAULT_ERROR__ADAPTOR_EPOCH_INVALID
+  | typeof VOLTR_VAULT_ERROR__ADAPTOR_PROGRAM_NOT_WHITELISTED
   | typeof VOLTR_VAULT_ERROR__DIVISION_BY_ZERO
   | typeof VOLTR_VAULT_ERROR__FEE_EXCEEDS_TOTAL_ASSET_VALUE
   | typeof VOLTR_VAULT_ERROR__INSTANT_WITHDRAW_NOT_ALLOWED
   | typeof VOLTR_VAULT_ERROR__INVALID_ACCOUNT_INPUT
+  | typeof VOLTR_VAULT_ERROR__INVALID_ADAPTOR_POLICY
   | typeof VOLTR_VAULT_ERROR__INVALID_AMOUNT
   | typeof VOLTR_VAULT_ERROR__INVALID_FEE_CONFIGURATION
   | typeof VOLTR_VAULT_ERROR__INVALID_INPUT
@@ -69,10 +75,12 @@ let voltrVaultErrorMessages: Record<VoltrVaultError, string> | undefined;
 if (process.env.NODE_ENV !== "production") {
   voltrVaultErrorMessages = {
     [VOLTR_VAULT_ERROR__ADAPTOR_EPOCH_INVALID]: `Adaptor epoch invalid.`,
+    [VOLTR_VAULT_ERROR__ADAPTOR_PROGRAM_NOT_WHITELISTED]: `Adaptor program not whitelisted.`,
     [VOLTR_VAULT_ERROR__DIVISION_BY_ZERO]: `Division by zero.`,
     [VOLTR_VAULT_ERROR__FEE_EXCEEDS_TOTAL_ASSET_VALUE]: `Fee exceeds total asset value.`,
     [VOLTR_VAULT_ERROR__INSTANT_WITHDRAW_NOT_ALLOWED]: `Instant withdraw not allowed.`,
     [VOLTR_VAULT_ERROR__INVALID_ACCOUNT_INPUT]: `Invalid account input.`,
+    [VOLTR_VAULT_ERROR__INVALID_ADAPTOR_POLICY]: `Invalid adaptor policy.`,
     [VOLTR_VAULT_ERROR__INVALID_AMOUNT]: `Invalid amount provided.`,
     [VOLTR_VAULT_ERROR__INVALID_FEE_CONFIGURATION]: `Fee configuration invalid.`,
     [VOLTR_VAULT_ERROR__INVALID_INPUT]: `Invalid input.`,