@picon-finance/dlmm-sdk 1.18.3 → 2.0.0

package/src/events.ts

@@ -1,199 +1,54 @@
-// Hand-written event decoding — Codama's Anchor-IDL conversion (`@codama/nodes-from-anchor`)
-// currently drops the IDL's `events` field entirely, so there's nothing to generate this from
-// yet (confirmed: `SwapEvent` etc. don't even survive as plain defined types in the
-// intermediate Codama IDL, let alone get rendered). Once Codama adds event support, this file
-// should be deleted in favor of the generated equivalent — the codec style below matches
-// `generated/types/*.ts` exactly for that reason.
+// Event shapes/codecs/discriminators are generated (src/generated/events/*, via Codama's
+// event-rendering support added in @codama/renderers-js 2.4.0 + @codama/nodes-from-anchor's
+// eventNodeFromAnchorV01). What stays hand-written here — and always will — is the log-parsing
+// and subscription layer: none of it is IDL-derivable. The IDL says nothing about Anchor's
+// `emit!` writing events as `Program data: <base64>` log lines, about how to scope those lines
+// to this program specifically when a transaction's logs interleave multiple programs' output
+// via CPI, or about how to actually subscribe to get logs over the wire in the first place —
+// those are runtime/RPC-client facts, not data-shape facts, and no IDL revision could add them.
+//
+// Re-exported here under the IDL's own single-"Event" names (SwapEvent, not the generated
+// module's SwapEventEvent — Codama appends its own "Event" suffix on top of names that already
+// end in one) so nothing downstream needs to change on this migration.
 import {
   type Address,
   type Commitment,
   type createSolanaRpcSubscriptions,
-  getAddressDecoder,
   getBase64Encoder,
-  getBooleanDecoder,
-  getI32Decoder,
-  getStructDecoder,
-  getU16Decoder,
-  getU32Decoder,
-  getU64Decoder,
-  type FixedSizeDecoder,
   type ReadonlyUint8Array,
 } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS } from "./generated";
-
-export type CreatePoolEvent = {
-  pool: Address;
-  binStep: number;
-  feeRate: number;
-  tokenMintX: Address;
-  tokenMintY: Address;
-};
-
-export type OpenPositionEvent = {
-  pool: Address;
-  position: Address;
-  owner: Address;
-  lowerBinId: number;
-  upperBinId: number;
-};
-
-export type ClosePositionEvent = {
-  pool: Address;
-  position: Address;
-  owner: Address;
-  lowerBinId: number;
-  upperBinId: number;
-};
-
-export type DepositEvent = {
-  pool: Address;
-  position: Address;
-  owner: Address;
-  lowerBinId: number;
-  upperBinId: number;
-  amountX: bigint;
-  amountY: bigint;
-  transferFeeX: bigint;
-  transferFeeY: bigint;
-};
-
-export type WithdrawEvent = {
-  pool: Address;
-  position: Address;
-  owner: Address;
-  lowerBinId: number;
-  upperBinId: number;
-  bpsRemoved: number;
-  amountX: bigint;
-  amountY: bigint;
-  transferFeeX: bigint;
-  transferFeeY: bigint;
-};
-
-export type ClaimFeeEvent = {
-  pool: Address;
-  position: Address;
-  owner: Address;
-  lowerBinId: number;
-  upperBinId: number;
-  amountX: bigint;
-  amountY: bigint;
-  transferFeeX: bigint;
-  transferFeeY: bigint;
-};
-
-export type SwapEvent = {
-  pool: Address;
-  xToY: boolean;
-  preBinId: number;
-  postBinId: number;
-  amountIn: bigint;
-  amountOut: bigint;
-  inputTransferFee: bigint;
-  outputTransferFee: bigint;
-  lpFee: bigint;
-  protocolFee: bigint;
-};
-
-function getCreatePoolEventDecoder(): FixedSizeDecoder<CreatePoolEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["binStep", getU16Decoder()],
-    ["feeRate", getU32Decoder()],
-    ["tokenMintX", getAddressDecoder()],
-    ["tokenMintY", getAddressDecoder()],
-  ]);
-}
-
-function getOpenPositionEventDecoder(): FixedSizeDecoder<OpenPositionEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["position", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
-    ["lowerBinId", getI32Decoder()],
-    ["upperBinId", getI32Decoder()],
-  ]);
-}
-
-function getClosePositionEventDecoder(): FixedSizeDecoder<ClosePositionEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["position", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
-    ["lowerBinId", getI32Decoder()],
-    ["upperBinId", getI32Decoder()],
-  ]);
-}
-
-function getDepositEventDecoder(): FixedSizeDecoder<DepositEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["position", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
-    ["lowerBinId", getI32Decoder()],
-    ["upperBinId", getI32Decoder()],
-    ["amountX", getU64Decoder()],
-    ["amountY", getU64Decoder()],
-    ["transferFeeX", getU64Decoder()],
-    ["transferFeeY", getU64Decoder()],
-  ]);
-}
-
-function getWithdrawEventDecoder(): FixedSizeDecoder<WithdrawEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["position", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
-    ["lowerBinId", getI32Decoder()],
-    ["upperBinId", getI32Decoder()],
-    ["bpsRemoved", getU16Decoder()],
-    ["amountX", getU64Decoder()],
-    ["amountY", getU64Decoder()],
-    ["transferFeeX", getU64Decoder()],
-    ["transferFeeY", getU64Decoder()],
-  ]);
-}
-
-function getClaimFeeEventDecoder(): FixedSizeDecoder<ClaimFeeEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["position", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
-    ["lowerBinId", getI32Decoder()],
-    ["upperBinId", getI32Decoder()],
-    ["amountX", getU64Decoder()],
-    ["amountY", getU64Decoder()],
-    ["transferFeeX", getU64Decoder()],
-    ["transferFeeY", getU64Decoder()],
-  ]);
-}
-
-function getSwapEventDecoder(): FixedSizeDecoder<SwapEvent> {
-  return getStructDecoder([
-    ["pool", getAddressDecoder()],
-    ["xToY", getBooleanDecoder()],
-    ["preBinId", getI32Decoder()],
-    ["postBinId", getI32Decoder()],
-    ["amountIn", getU64Decoder()],
-    ["amountOut", getU64Decoder()],
-    ["inputTransferFee", getU64Decoder()],
-    ["outputTransferFee", getU64Decoder()],
-    ["lpFee", getU64Decoder()],
-    ["protocolFee", getU64Decoder()],
-  ]);
-}
-
-// Discriminators are the first 8 bytes of sha256("event:<EventName>") — copied from the IDL's
-// `events` array (`ts-sdk/src/picon_dlmm.json`), same derivation Anchor uses for accounts.
-const DISCRIMINATORS = {
-  CreatePoolEvent: [177, 49, 12, 210, 160, 118, 167, 116],
-  OpenPositionEvent: [83, 43, 164, 147, 169, 87, 81, 172],
-  ClosePositionEvent: [198, 217, 115, 95, 191, 120, 142, 137],
-  DepositEvent: [120, 248, 61, 83, 31, 142, 107, 144],
-  WithdrawEvent: [22, 9, 133, 26, 160, 44, 71, 192],
-  ClaimFeeEvent: [173, 80, 235, 15, 116, 19, 144, 33],
-  SwapEvent: [64, 198, 205, 232, 38, 8, 113, 226],
-} as const satisfies Record<string, number[]>;
+import { PICON_DLMM_PROGRAM_ADDRESS } from "./generated/index.js";
+import {
+  type ClaimFeeEventEvent,
+  type ClosePositionEventEvent,
+  type CreatePoolEventEvent,
+  type DepositEventEvent,
+  type OpenPositionEventEvent,
+  type SwapEventEvent,
+  type WithdrawEventEvent,
+  getClaimFeeEventEventDecoder,
+  getClosePositionEventEventDecoder,
+  getCreatePoolEventEventDecoder,
+  getDepositEventEventDecoder,
+  getOpenPositionEventEventDecoder,
+  getSwapEventEventDecoder,
+  getWithdrawEventEventDecoder,
+  CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR,
+  CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR,
+  CREATE_POOL_EVENT_EVENT_DISCRIMINATOR,
+  DEPOSIT_EVENT_EVENT_DISCRIMINATOR,
+  OPEN_POSITION_EVENT_EVENT_DISCRIMINATOR,
+  SWAP_EVENT_EVENT_DISCRIMINATOR,
+  WITHDRAW_EVENT_EVENT_DISCRIMINATOR,
+} from "./generated/events/index.js";
+
+export type CreatePoolEvent = CreatePoolEventEvent;
+export type OpenPositionEvent = OpenPositionEventEvent;
+export type ClosePositionEvent = ClosePositionEventEvent;
+export type DepositEvent = DepositEventEvent;
+export type WithdrawEvent = WithdrawEventEvent;
+export type ClaimFeeEvent = ClaimFeeEventEvent;
+export type SwapEvent = SwapEventEvent;
 
 export type DlmmEvent =
   | { name: "CreatePoolEvent", data: CreatePoolEvent }
@@ -204,14 +59,27 @@ export type DlmmEvent =
   | { name: "ClaimFeeEvent", data: ClaimFeeEvent }
   | { name: "SwapEvent", data: SwapEvent };
 
-const DECODERS: { [K in DlmmEvent["name"]]: FixedSizeDecoder<Extract<DlmmEvent, { name: K }>["data"]> } = {
-  CreatePoolEvent: getCreatePoolEventDecoder(),
-  OpenPositionEvent: getOpenPositionEventDecoder(),
-  ClosePositionEvent: getClosePositionEventDecoder(),
-  DepositEvent: getDepositEventDecoder(),
-  WithdrawEvent: getWithdrawEventDecoder(),
-  ClaimFeeEvent: getClaimFeeEventDecoder(),
-  SwapEvent: getSwapEventDecoder(),
+// Each generated decoder is a getHiddenPrefixDecoder wrapping its struct decoder — it expects
+// the discriminator bytes still present at the front and verifies+strips them itself, so
+// decodeEventBytes below feeds it the full byte range, not a pre-sliced body.
+const DECODERS = {
+  CreatePoolEvent: getCreatePoolEventEventDecoder(),
+  OpenPositionEvent: getOpenPositionEventEventDecoder(),
+  ClosePositionEvent: getClosePositionEventEventDecoder(),
+  DepositEvent: getDepositEventEventDecoder(),
+  WithdrawEvent: getWithdrawEventEventDecoder(),
+  ClaimFeeEvent: getClaimFeeEventEventDecoder(),
+  SwapEvent: getSwapEventEventDecoder(),
+} satisfies { [K in DlmmEvent["name"]]: { decode(bytes: ReadonlyUint8Array): Extract<DlmmEvent, { name: K }>["data"] } };
+
+const DISCRIMINATORS: Record<DlmmEvent["name"], ReadonlyUint8Array> = {
+  CreatePoolEvent: CREATE_POOL_EVENT_EVENT_DISCRIMINATOR,
+  OpenPositionEvent: OPEN_POSITION_EVENT_EVENT_DISCRIMINATOR,
+  ClosePositionEvent: CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR,
+  DepositEvent: DEPOSIT_EVENT_EVENT_DISCRIMINATOR,
+  WithdrawEvent: WITHDRAW_EVENT_EVENT_DISCRIMINATOR,
+  ClaimFeeEvent: CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR,
+  SwapEvent: SWAP_EVENT_EVENT_DISCRIMINATOR,
 };
 
 const PROGRAM_DATA_PREFIX = "Program data: ";
@@ -220,12 +88,11 @@ const PROGRAM_DATA_PREFIX = "Program data: ";
 // base64 payload is [8-byte discriminator][borsh-encoded fields], same layout as an account.
 function decodeEventBytes(bytes: ReadonlyUint8Array): DlmmEvent | undefined {
   const discriminator = bytes.subarray(0, 8);
-  const body = bytes.subarray(8);
 
   for (const name of Object.keys(DISCRIMINATORS) as DlmmEvent["name"][]) {
     const expected = DISCRIMINATORS[name];
     if (expected.every((byte, i) => byte === discriminator[i])) {
-      return { name, data: DECODERS[name].decode(body) } as DlmmEvent;
+      return { name, data: DECODERS[name].decode(bytes) } as DlmmEvent;
     }
   }
 

package/src/generated/accounts/binArray.ts

@@ -38,7 +38,12 @@ import {
   type MaybeEncodedAccount,
   type ReadonlyUint8Array,
 } from "@solana/kit";
-import { getBinDecoder, getBinEncoder, type Bin, type BinArgs } from "../types";
+import {
+  getBinDecoder,
+  getBinEncoder,
+  type Bin,
+  type BinArgs,
+} from "../types/index.js";
 
 export const BIN_ARRAY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
   92, 142, 92, 220, 5, 148, 70, 181,

package/src/generated/accounts/index.ts

@@ -6,7 +6,7 @@
  * @see https://github.com/codama-idl/codama
  */
 
-export * from "./adminConfig";
-export * from "./binArray";
-export * from "./pool";
-export * from "./position";
+export * from "./adminConfig.js";
+export * from "./binArray.js";
+export * from "./pool.js";
+export * from "./position.js";

package/src/generated/accounts/pool.ts

@@ -47,7 +47,7 @@ import {
   getDynamicFeeStateEncoder,
   type DynamicFeeState,
   type DynamicFeeStateArgs,
-} from "../types";
+} from "../types/index.js";
 
 export const POOL_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
   241, 154, 109, 4, 17, 177, 109, 188,

package/src/generated/accounts/position.ts

@@ -43,7 +43,7 @@ import {
   getFeeStateEncoder,
   type FeeState,
   type FeeStateArgs,
-} from "../types";
+} from "../types/index.js";
 
 export const POSITION_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
   170, 188, 143, 228, 122, 64, 247, 208,

package/src/generated/constants/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from "./piconDlmm.js";

package/src/generated/constants/piconDlmm.ts

@@ -0,0 +1,25 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export const BINS_PER_BIN_ARRAY: number = 100;
+
+export const DYNAMIC_FEE_DIVISOR: bigint = 100000000000n;
+
+export const FEE_PRECISION: bigint = 1000000000n;
+
+export const MAX_BASIS_POINTS: number = 10000;
+
+export const MAX_BIN_ARRAYS_PER_POSITION: number = 2;
+
+export const MAX_BIN_ARRAYS_PER_TRAVERSAL: number = 6;
+
+export const MAX_FEE_RATE: bigint = 100000000n;
+
+export const MAX_PROTOCOL_SHARE: number = 2500;
+
+export const ONE_BPS_FEE_RATE: number = 100000;

package/src/generated/errors/index.ts

@@ -6,4 +6,4 @@
  * @see https://github.com/codama-idl/codama
  */
 
-export * from "./piconDlmm";
+export * from "./piconDlmm.js";

package/src/generated/errors/piconDlmm.ts

@@ -12,7 +12,7 @@ import {
   type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM,
   type SolanaError,
 } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS } from "../programs";
+import { PICON_DLMM_PROGRAM_ADDRESS } from "../programs/index.js";
 
 /** LiquidityError: Liquidity error */
 export const PICON_DLMM_ERROR__LIQUIDITY_ERROR = 0x1770; // 6000

package/src/generated/events/claimFeeEvent.ts

@@ -0,0 +1,123 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  containsBytes,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBytesEncoder,
+  getConstantDecoder,
+  getConstantEncoder,
+  getHiddenPrefixDecoder,
+  getHiddenPrefixEncoder,
+  getI32Decoder,
+  getI32Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  type Address,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR: ReadonlyUint8Array =
+  new Uint8Array([173, 80, 235, 15, 116, 19, 144, 33]);
+
+export function getClaimFeeEventEventDiscriminatorBytes(): ReadonlyUint8Array {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR,
+  );
+}
+
+export type ClaimFeeEventEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+  amountX: bigint;
+  amountY: bigint;
+  transferFeeX: bigint;
+  transferFeeY: bigint;
+};
+
+export type ClaimFeeEventEventArgs = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+  amountX: number | bigint;
+  amountY: number | bigint;
+  transferFeeX: number | bigint;
+  transferFeeY: number | bigint;
+};
+
+/** Gets the encoder for {@link ClaimFeeEventEventArgs} event data. */
+export function getClaimFeeEventEventEncoder(): FixedSizeEncoder<ClaimFeeEventEventArgs> {
+  return getHiddenPrefixEncoder(
+    getStructEncoder([
+      ["pool", getAddressEncoder()],
+      ["position", getAddressEncoder()],
+      ["owner", getAddressEncoder()],
+      ["lowerBinId", getI32Encoder()],
+      ["upperBinId", getI32Encoder()],
+      ["amountX", getU64Encoder()],
+      ["amountY", getU64Encoder()],
+      ["transferFeeX", getU64Encoder()],
+      ["transferFeeY", getU64Encoder()],
+    ]),
+    [getConstantEncoder(CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR)],
+  );
+}
+
+/** Gets the decoder for {@link ClaimFeeEventEvent} event data. */
+export function getClaimFeeEventEventDecoder(): FixedSizeDecoder<ClaimFeeEventEvent> {
+  return getHiddenPrefixDecoder(
+    getStructDecoder([
+      ["pool", getAddressDecoder()],
+      ["position", getAddressDecoder()],
+      ["owner", getAddressDecoder()],
+      ["lowerBinId", getI32Decoder()],
+      ["upperBinId", getI32Decoder()],
+      ["amountX", getU64Decoder()],
+      ["amountY", getU64Decoder()],
+      ["transferFeeX", getU64Decoder()],
+      ["transferFeeY", getU64Decoder()],
+    ]),
+    [getConstantDecoder(CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR)],
+  );
+}
+
+/** Gets the codec for {@link ClaimFeeEventEvent} event data. */
+export function getClaimFeeEventEventCodec(): FixedSizeCodec<
+  ClaimFeeEventEventArgs,
+  ClaimFeeEventEvent
+> {
+  return combineCodec(
+    getClaimFeeEventEventEncoder(),
+    getClaimFeeEventEventDecoder(),
+  );
+}
+
+/** Parses the provided bytes into {@link ClaimFeeEventEvent} event data. */
+export function parseClaimFeeEventEvent(
+  data: ReadonlyUint8Array | Uint8Array,
+): ClaimFeeEventEvent {
+  if (containsBytes(data, CLAIM_FEE_EVENT_EVENT_DISCRIMINATOR, 0)) {
+    return getClaimFeeEventEventDecoder().decode(data);
+  }
+  throw new Error(
+    'The provided data does not match the "ClaimFeeEventEvent" event discriminators.',
+  );
+}

package/src/generated/events/closePositionEvent.ts

@@ -0,0 +1,99 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  containsBytes,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBytesEncoder,
+  getConstantDecoder,
+  getConstantEncoder,
+  getHiddenPrefixDecoder,
+  getHiddenPrefixEncoder,
+  getI32Decoder,
+  getI32Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Address,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR: ReadonlyUint8Array =
+  new Uint8Array([198, 217, 115, 95, 191, 120, 142, 137]);
+
+export function getClosePositionEventEventDiscriminatorBytes(): ReadonlyUint8Array {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR,
+  );
+}
+
+export type ClosePositionEventEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+};
+
+export type ClosePositionEventEventArgs = ClosePositionEventEvent;
+
+/** Gets the encoder for {@link ClosePositionEventEventArgs} event data. */
+export function getClosePositionEventEventEncoder(): FixedSizeEncoder<ClosePositionEventEventArgs> {
+  return getHiddenPrefixEncoder(
+    getStructEncoder([
+      ["pool", getAddressEncoder()],
+      ["position", getAddressEncoder()],
+      ["owner", getAddressEncoder()],
+      ["lowerBinId", getI32Encoder()],
+      ["upperBinId", getI32Encoder()],
+    ]),
+    [getConstantEncoder(CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR)],
+  );
+}
+
+/** Gets the decoder for {@link ClosePositionEventEvent} event data. */
+export function getClosePositionEventEventDecoder(): FixedSizeDecoder<ClosePositionEventEvent> {
+  return getHiddenPrefixDecoder(
+    getStructDecoder([
+      ["pool", getAddressDecoder()],
+      ["position", getAddressDecoder()],
+      ["owner", getAddressDecoder()],
+      ["lowerBinId", getI32Decoder()],
+      ["upperBinId", getI32Decoder()],
+    ]),
+    [getConstantDecoder(CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR)],
+  );
+}
+
+/** Gets the codec for {@link ClosePositionEventEvent} event data. */
+export function getClosePositionEventEventCodec(): FixedSizeCodec<
+  ClosePositionEventEventArgs,
+  ClosePositionEventEvent
+> {
+  return combineCodec(
+    getClosePositionEventEventEncoder(),
+    getClosePositionEventEventDecoder(),
+  );
+}
+
+/** Parses the provided bytes into {@link ClosePositionEventEvent} event data. */
+export function parseClosePositionEventEvent(
+  data: ReadonlyUint8Array | Uint8Array,
+): ClosePositionEventEvent {
+  if (containsBytes(data, CLOSE_POSITION_EVENT_EVENT_DISCRIMINATOR, 0)) {
+    return getClosePositionEventEventDecoder().decode(data);
+  }
+  throw new Error(
+    'The provided data does not match the "ClosePositionEventEvent" event discriminators.',
+  );
+}