@veilo/sdk-core 0.4.0 → 0.6.0

package/dist/cjs/compactNote.d.ts

@@ -44,6 +44,21 @@ export type CompactNoteCipher = {
     /** 1-byte scan filter. */
     viewTag: number;
 };
+/** The optional pair of compact note ciphers carried by `transact` instructions. */
+export type NoteCiphers = {
+    note0EphemeralKey: Uint8Array;
+    note0Encrypted: Uint8Array;
+    note0ViewTag: number;
+    note1EphemeralKey: Uint8Array;
+    note1Encrypted: Uint8Array;
+    note1ViewTag: number;
+};
+/** Plaintext note material needed to create one compact on-chain cipher. */
+export type NoteCipherInput = {
+    recipientWalletPubkey: Uint8Array;
+    blinding: Uint8Array;
+    amount: bigint;
+};
 /**
  * Test-only determinism hook. NOT part of the public contract — it exists so
  * golden vectors can pin exact bytes against the sibling implementations, which
@@ -105,3 +120,9 @@ export declare function matchesViewTag(walletSecretKey: Uint8Array, ephemeralPub
 export declare function toX25519Private(walletSecretKey: Uint8Array): Uint8Array;
 /** The all-zero cipher the program treats as "no note here". */
 export declare function emptyNoteCipher(): CompactNoteCipher;
+/**
+ * Build the two-note payload accepted by `transact` and `transact_swap`.
+ * A missing side is encoded with the program's all-zero sentinel. If both
+ * sides are missing, `null` is returned so Anchor encodes `Option::None`.
+ */
+export declare function createNoteCiphers(note0: NoteCipherInput | null, note1: NoteCipherInput | null): NoteCiphers | null;

package/dist/cjs/compactNote.js

@@ -9,8 +9,9 @@ exports.decryptCompactNoteCipher = decryptCompactNoteCipher;
 exports.matchesViewTag = matchesViewTag;
 exports.toX25519Private = toX25519Private;
 exports.emptyNoteCipher = emptyNoteCipher;
+exports.createNoteCiphers = createNoteCiphers;
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const utxo_js_1 = require("./utxo.js");
+const mailbox_js_1 = require("./notes/mailbox.js");
 const random_js_1 = require("./random.js");
 /**
  * Compact note ciphers — the 80-byte payload carried inside the on-chain
@@ -82,7 +83,7 @@ function createCompactNoteCipher(recipientWalletPubkey, blinding, amount,
     const ephemeralSeed = __det?.ephemeralSeed ?? (0, random_js_1.randomBytes)(32);
     const ephemeralPublicKey = tweetnacl_1.default.sign.keyPair.fromSeed(ephemeralSeed).publicKey;
     const sharedSecret = deriveSharedSecret(ephemeralSeed, recipientWalletPubkey);
-    const key = (0, utxo_js_1.kdfSHA512_256)(sharedSecret);
+    const key = (0, mailbox_js_1.kdfSHA512_256)(sharedSecret);
     const plaintext = new Uint8Array(COMPACT_PLAINTEXT_LENGTH);
     plaintext.set(blinding.slice(0, 32), 0);
     let amt = amount;
@@ -114,9 +115,9 @@ function decryptCompactNoteCipher(walletSecretKey, ephemeralPublicKey, compactBl
         return null;
     const sharedSecret = precomputed?.sharedSecret ??
         (precomputed?.x25519Private
-            ? tweetnacl_1.default.scalarMult(precomputed.x25519Private, (0, utxo_js_1.ed25519PublicKeyToX25519)(ephemeralPublicKey))
+            ? tweetnacl_1.default.scalarMult(precomputed.x25519Private, (0, mailbox_js_1.ed25519PublicKeyToX25519)(ephemeralPublicKey))
             : deriveSharedSecret(walletSecretKey, ephemeralPublicKey));
-    const key = (0, utxo_js_1.kdfSHA512_256)(sharedSecret);
+    const key = (0, mailbox_js_1.kdfSHA512_256)(sharedSecret);
     const nonce = compactBlob.slice(0, NONCE_LENGTH);
     const encrypted = compactBlob.slice(NONCE_LENGTH);
     const plaintext = tweetnacl_1.default.secretbox.open(encrypted, nonce, key);
@@ -138,7 +139,7 @@ function decryptCompactNoteCipher(walletSecretKey, ephemeralPublicKey, compactBl
  */
 function matchesViewTag(walletSecretKey, ephemeralPublicKey, viewTag, precomputed) {
     const sharedSecret = precomputed?.x25519Private
-        ? tweetnacl_1.default.scalarMult(precomputed.x25519Private, (0, utxo_js_1.ed25519PublicKeyToX25519)(ephemeralPublicKey))
+        ? tweetnacl_1.default.scalarMult(precomputed.x25519Private, (0, mailbox_js_1.ed25519PublicKeyToX25519)(ephemeralPublicKey))
         : deriveSharedSecret(walletSecretKey, ephemeralPublicKey);
     return { matches: tweetnacl_1.default.hash(sharedSecret)[0] === viewTag, sharedSecret };
 }
@@ -147,7 +148,7 @@ function matchesViewTag(walletSecretKey, ephemeralPublicKey, viewTag, precompute
  * across a scan loop.
  */
 function toX25519Private(walletSecretKey) {
-    return (0, utxo_js_1.ed25519SeedToX25519Private)(seedOf(walletSecretKey));
+    return (0, mailbox_js_1.ed25519SeedToX25519Private)(seedOf(walletSecretKey));
 }
 /** The all-zero cipher the program treats as "no note here". */
 function emptyNoteCipher() {
@@ -157,11 +158,34 @@ function emptyNoteCipher() {
         viewTag: 0,
     };
 }
+/**
+ * Build the two-note payload accepted by `transact` and `transact_swap`.
+ * A missing side is encoded with the program's all-zero sentinel. If both
+ * sides are missing, `null` is returned so Anchor encodes `Option::None`.
+ */
+function createNoteCiphers(note0, note1) {
+    if (!note0 && !note1)
+        return null;
+    const cipher0 = note0
+        ? createCompactNoteCipher(note0.recipientWalletPubkey, note0.blinding, note0.amount)
+        : emptyNoteCipher();
+    const cipher1 = note1
+        ? createCompactNoteCipher(note1.recipientWalletPubkey, note1.blinding, note1.amount)
+        : emptyNoteCipher();
+    return {
+        note0EphemeralKey: cipher0.ephemeralPublicKey,
+        note0Encrypted: cipher0.compactBlob,
+        note0ViewTag: cipher0.viewTag,
+        note1EphemeralKey: cipher1.ephemeralPublicKey,
+        note1Encrypted: cipher1.compactBlob,
+        note1ViewTag: cipher1.viewTag,
+    };
+}
 // -- internal -----------------------------------------------------------------
 /** Accept either a 32-byte Ed25519 seed or a 64-byte secret key, as the siblings do. */
 function seedOf(secretKey) {
     return secretKey.length === 64 ? secretKey.slice(0, 32) : secretKey;
 }
 function deriveSharedSecret(mySecretKey, theirEd25519PublicKey) {
-    return tweetnacl_1.default.scalarMult((0, utxo_js_1.ed25519SeedToX25519Private)(seedOf(mySecretKey)), (0, utxo_js_1.ed25519PublicKeyToX25519)(theirEd25519PublicKey));
+    return tweetnacl_1.default.scalarMult((0, mailbox_js_1.ed25519SeedToX25519Private)(seedOf(mySecretKey)), (0, mailbox_js_1.ed25519PublicKeyToX25519)(theirEd25519PublicKey));
 }

package/dist/cjs/events/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./parsing.js";
+export * from "./position.js";
+export * from "./recovery.js";
+export * from "./scanning.js";
+export * from "./tree.js";

package/dist/cjs/events/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./parsing.js"), exports);
+__exportStar(require("./position.js"), exports);
+__exportStar(require("./recovery.js"), exports);
+__exportStar(require("./scanning.js"), exports);
+__exportStar(require("./tree.js"), exports);

package/dist/cjs/events/parsing.d.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from "@solana/web3.js";
+import { type VersionedPrivacyPoolIdl } from "../idl/index.js";
+import type { CommitmentEvent, NullifierSpentEvent, ParsedVeiloEvent } from "./types.js";
+/**
+ * Decode logs using the current, legacy, and legacy-2 IDLs.
+ *
+ * IDLs are evaluated in the relayer's current/legacy/legacy-2 order. Anchor's
+ * Borsh decoder accepts trailing bytes, however, so every successful parse is
+ * considered and the richest result wins. That preserves the compact fields
+ * in legacy-2 events instead of misclassifying them as the shorter legacy form.
+ * Ties retain the relayer's order.
+ */
+export declare function parseVeiloEventsWithFallback(logMessages: readonly string[] | null | undefined, programId: PublicKey, idls?: readonly VersionedPrivacyPoolIdl[]): ParsedVeiloEvent[];
+export declare function parseCommitmentEventsFromLogs(params: {
+    logMessages: readonly string[] | null | undefined;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+}): CommitmentEvent[];
+export declare function parseNullifierEventsFromLogs(params: {
+    logMessages: readonly string[] | null | undefined;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+}): NullifierSpentEvent[];

package/dist/cjs/events/parsing.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVeiloEventsWithFallback = parseVeiloEventsWithFallback;
+exports.parseCommitmentEventsFromLogs = parseCommitmentEventsFromLogs;
+exports.parseNullifierEventsFromLogs = parseNullifierEventsFromLogs;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const web3_js_1 = require("@solana/web3.js");
+const index_js_1 = require("../idl/index.js");
+/**
+ * Decode logs using the current, legacy, and legacy-2 IDLs.
+ *
+ * IDLs are evaluated in the relayer's current/legacy/legacy-2 order. Anchor's
+ * Borsh decoder accepts trailing bytes, however, so every successful parse is
+ * considered and the richest result wins. That preserves the compact fields
+ * in legacy-2 events instead of misclassifying them as the shorter legacy form.
+ * Ties retain the relayer's order.
+ */
+function parseVeiloEventsWithFallback(logMessages, programId, idls = index_js_1.PRIVACY_POOL_IDLS) {
+    if (!logMessages?.length)
+        return [];
+    let best = [];
+    let bestScore = -1;
+    for (const candidate of idls) {
+        try {
+            const parser = new anchor.EventParser(programId, new anchor.BorshCoder(candidate.idl));
+            const parsed = Array.from(parser.parseLogs([...logMessages])).map((event) => ({
+                name: event.name,
+                data: event.data,
+                idlVersion: candidate.version,
+            }));
+            const score = parsed.reduce((total, event) => total + decodedFieldCount(event.data), 0);
+            if (score > bestScore) {
+                best = parsed;
+                bestScore = score;
+            }
+        }
+        catch {
+            // The discriminator is shared while historical payload lengths differ.
+        }
+    }
+    return best;
+}
+function parseCommitmentEventsFromLogs(params) {
+    const { logMessages, programId, txSignature, slot } = params;
+    const out = [];
+    for (const event of parseVeiloEventsWithFallback(logMessages, programId)) {
+        if (event.name.toLowerCase() !== "commitmentevent")
+            continue;
+        const data = event.data;
+        const mintAddress = toPublicKey(field(data, "mintAddress", "mint_address"));
+        const ephemeralPublicKey = optionalBytes(field(data, "ephemeralPublicKey", "ephemeral_public_key"));
+        const encryptedBlob = optionalBytes(field(data, "encryptedBlob", "encrypted_blob"));
+        const rawViewTag = field(data, "viewTag", "view_tag");
+        out.push({
+            commitment: toBytes(field(data, "commitment"), 32, "commitment"),
+            leafIndex: toSafeNumber(field(data, "leafIndex", "leaf_index"), "leafIndex"),
+            newRoot: toBytes(field(data, "newRoot", "new_root"), 32, "newRoot"),
+            timestamp: toSafeNumber(field(data, "timestamp"), "timestamp"),
+            mintAddress,
+            treeId: toSafeNumber(field(data, "treeId", "tree_id"), "treeId"),
+            txSignature,
+            slot,
+            ...(ephemeralPublicKey ? { ephemeralPublicKey } : {}),
+            ...(encryptedBlob ? { encryptedBlob } : {}),
+            ...(rawViewTag !== undefined
+                ? { viewTag: toSafeNumber(rawViewTag, "viewTag") }
+                : {}),
+            source: "emitted",
+            idlVersion: event.idlVersion,
+        });
+    }
+    return out;
+}
+function parseNullifierEventsFromLogs(params) {
+    const { logMessages, programId, txSignature, slot } = params;
+    const out = [];
+    for (const event of parseVeiloEventsWithFallback(logMessages, programId)) {
+        if (event.name.toLowerCase() !== "nullifierspent")
+            continue;
+        const data = event.data;
+        out.push({
+            nullifier: toBytes(field(data, "nullifier"), 32, "nullifier"),
+            timestamp: toSafeNumber(field(data, "timestamp"), "timestamp"),
+            mintAddress: toPublicKey(field(data, "mintAddress", "mint_address")),
+            treeId: toSafeNumber(field(data, "treeId", "tree_id"), "treeId"),
+            txSignature,
+            slot,
+            idlVersion: event.idlVersion,
+        });
+    }
+    return out;
+}
+function field(data, camel, snake) {
+    return data[camel] ?? (snake ? data[snake] : undefined);
+}
+function optionalBytes(value) {
+    return value === undefined || value === null
+        ? undefined
+        : new Uint8Array(value);
+}
+function decodedFieldCount(value) {
+    return value && typeof value === "object" ? Object.keys(value).length : 0;
+}
+function toBytes(value, length, label) {
+    const bytes = new Uint8Array(value);
+    if (bytes.length !== length) {
+        throw new Error(`${label} must be ${length} bytes, got ${bytes.length}`);
+    }
+    return bytes;
+}
+function toPublicKey(value) {
+    if (value instanceof web3_js_1.PublicKey)
+        return value;
+    return new web3_js_1.PublicKey(value);
+}
+function toSafeNumber(value, label) {
+    if (value === undefined || value === null) {
+        throw new Error(`Missing ${label} in decoded event`);
+    }
+    const numeric = typeof value === "number" ? value : Number(value);
+    if (!Number.isSafeInteger(numeric)) {
+        throw new Error(`${label} is outside JavaScript's safe integer range`);
+    }
+    return numeric;
+}

package/dist/cjs/events/position.d.ts

@@ -0,0 +1,26 @@
+import type { Idl, Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import type { CommitmentEvent } from "./types.js";
+/**
+ * Privacy-pool mints copied from the relayer's global position-tree classifier.
+ * Position commitments use non-pool destination mints at the same tree ID.
+ */
+export declare const POSITION_TREE_POOL_MINTS: readonly PublicKey[];
+export declare function isGlobalPositionCommitment(event: CommitmentEvent): boolean;
+/**
+ * Rebuild the one global position tree shared across every position mint.
+ * This mirrors the relayer: scan all mints for the position tree ID, then drop
+ * normal privacy-pool mint events before sorting by the global leaf index.
+ */
+export declare function buildGlobalPositionTreeFromEvents<T extends Idl>(params: {
+    program: Program<T>;
+    positionTreeId?: number;
+    depth?: number;
+    additionalEvents?: readonly CommitmentEvent[];
+    includeProtectedEvents?: boolean;
+    strictLeafIndices?: boolean;
+}): Promise<{
+    tree: import("../merkle.js").MerkleTree;
+    events: CommitmentEvent[];
+    latestSignature: string;
+}>;

package/dist/cjs/events/position.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSITION_TREE_POOL_MINTS = void 0;
+exports.isGlobalPositionCommitment = isGlobalPositionCommitment;
+exports.buildGlobalPositionTreeFromEvents = buildGlobalPositionTreeFromEvents;
+const web3_js_1 = require("@solana/web3.js");
+const recovery_js_1 = require("./recovery.js");
+const scanning_js_1 = require("./scanning.js");
+const tree_js_1 = require("./tree.js");
+/**
+ * Privacy-pool mints copied from the relayer's global position-tree classifier.
+ * Position commitments use non-pool destination mints at the same tree ID.
+ */
+exports.POSITION_TREE_POOL_MINTS = [
+    web3_js_1.PublicKey.default,
+    new web3_js_1.PublicKey("So11111111111111111111111111111111111111112"),
+    new web3_js_1.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+    new web3_js_1.PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"),
+    new web3_js_1.PublicKey("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB"),
+    new web3_js_1.PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"),
+    new web3_js_1.PublicKey("ARXwZkNAtzPfdcoqQiduJn8EPv9fKiDfGn2KyggyDrFs"),
+];
+const POOL_MINTS = new Set(exports.POSITION_TREE_POOL_MINTS.map((mint) => mint.toBase58()));
+function isGlobalPositionCommitment(event) {
+    return !POOL_MINTS.has(event.mintAddress.toBase58());
+}
+/**
+ * Rebuild the one global position tree shared across every position mint.
+ * This mirrors the relayer: scan all mints for the position tree ID, then drop
+ * normal privacy-pool mint events before sorting by the global leaf index.
+ */
+async function buildGlobalPositionTreeFromEvents(params) {
+    const { program, positionTreeId = 0, depth = 22, additionalEvents = [], includeProtectedEvents = true, strictLeafIndices = true, } = params;
+    const emitted = await (0, scanning_js_1.scanAllCommitmentEvents)({ program });
+    const protectedEvents = includeProtectedEvents
+        ? (0, recovery_js_1.getAllProtectedCommitmentEvents)()
+        : [];
+    const events = (0, tree_js_1.dedupeCommitmentEvents)([
+        ...emitted,
+        ...additionalEvents,
+        ...protectedEvents,
+    ])
+        .filter((event) => event.treeId === positionTreeId && isGlobalPositionCommitment(event))
+        .sort((a, b) => a.leafIndex - b.leafIndex);
+    return {
+        tree: (0, tree_js_1.reconstructTreeFromCommitmentEvents)(events, {
+            depth,
+            strictLeafIndices,
+        }),
+        events,
+        latestSignature: events[events.length - 1]?.txSignature,
+    };
+}

package/dist/cjs/events/recovery.d.ts

@@ -0,0 +1,87 @@
+import type { Connection } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import { MerkleTree } from "../merkle.js";
+import type { CommitmentEvent } from "./types.js";
+/**
+ * Historical leaves repaired manually in the relayer.
+ *
+ * The deployed `open_position` instruction appended these commitments without
+ * emitting CommitmentEvent. They must be retained when rebuilding history.
+ * Values are copied byte-for-byte from relayer-server/src/db/service.ts.
+ */
+export declare const PROTECTED_COMMITMENT_EVENTS: readonly [{
+    readonly leafIndex: 3738;
+    readonly commitmentHex: "0c7850c9360e041ceeba27297e0fd49fa6a224a651c2fff8c56b22c70a319a94";
+}, {
+    readonly leafIndex: 4;
+    readonly commitmentHex: "15e182d12e044ef2a469ccda88d903304a4e3e69f72765a29e4e6df9c206b0bf";
+    readonly mintAddressHex: "e272b88fb18eaf1994acb885bdba76820c567c3467300f0cd320a0c15ebf9d2f";
+    readonly onChainTreeId: 0;
+}];
+/** @deprecated Use PROTECTED_COMMITMENT_EVENTS. */
+export declare const PROTECTED_COMMITMENT_EVENT: {
+    readonly leafIndex: 3738;
+    readonly commitmentHex: "0c7850c9360e041ceeba27297e0fd49fa6a224a651c2fff8c56b22c70a319a94";
+};
+/** Return protected records as normal SDK events for a particular tree. */
+export declare function getProtectedCommitmentEvents(params: {
+    mintAddress: PublicKey;
+    treeId?: number;
+}): CommitmentEvent[];
+/** Return every protected leaf, including the global position-tree repair. */
+export declare function getAllProtectedCommitmentEvents(): CommitmentEvent[];
+/**
+ * Add the protected historical leaves without duplicating records already read
+ * from an indexer. A conflicting commitment at a protected index is rejected.
+ */
+export declare function mergeProtectedCommitmentEvents(events: readonly CommitmentEvent[], params: {
+    mintAddress: PublicKey;
+    treeId?: number;
+}): CommitmentEvent[];
+/**
+ * Insert expected commitments and prefer authoritative emitted metadata when it
+ * exists. Missing events are computed from the local tree exactly like the
+ * relayer's `insertAndPersistCommitments` fallback.
+ *
+ * This function mutates `tree`.
+ */
+export declare function resolveCommitmentEvents(params: {
+    commitments: readonly Uint8Array[];
+    tree: MerkleTree;
+    logMessages?: readonly string[] | null;
+    programId: PublicKey;
+    mintAddress: PublicKey;
+    treeId: number;
+    txSignature: string;
+    slot: number;
+    timestamp?: number;
+    requireAllInLogs?: boolean;
+}): CommitmentEvent[];
+export type EventlessOpenPositionCommitments = {
+    sourceMint: PublicKey;
+    sourceTreeId: number;
+    sourceCommitment: Uint8Array;
+    positionMint: PublicKey;
+    positionTreeId: number;
+    positionCommitment: Uint8Array;
+    positionPdaKey: Uint8Array;
+};
+/** Decode the two commitments hidden in a current `open_position` instruction. */
+export declare function decodeEventlessOpenPositionCommitments(instructionData: Uint8Array): EventlessOpenPositionCommitments | null;
+export declare function getPositionPda(programId: PublicKey, positionPdaKey: Uint8Array): PublicKey;
+/** Read PositionPDA.leaf_index at the same byte offset used by the relayer. */
+export declare function readPositionLeafIndex(accountData: Uint8Array): number;
+/**
+ * Recover the two events omitted by the deployed `open_position` instruction.
+ * The source tree must already contain every earlier source-mint commitment.
+ * This function inserts the source commitment into that tree.
+ */
+export declare function recoverEventlessOpenPositionEvents(params: {
+    instructionData: Uint8Array;
+    sourceTree: MerkleTree;
+    connection: Pick<Connection, "getAccountInfo">;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+    timestamp?: number;
+}): Promise<CommitmentEvent[]>;