@ercworldio/blockchain-shared 1.0.5-dev.7.PROJ-1464.0 → 1.0.5-dev.8

package/build/services/solana/escrow/services/EscrowAdminUtility.js

@@ -56,10 +56,188 @@ const TransactionsService_1 = require("./TransactionsService");
 const Errors_1 = __importDefault(require("./Errors"));
 const TokenAccountService_1 = require("./TokenAccountService");
 const SolanaTokenProgramCache_1 = require("./SolanaTokenProgramCache");
+const TreasuryWithdrawalSignature_1 = require("./TreasuryWithdrawalSignature");
 class EscrowAdminUtility {
-    constructor(program, provider) {
+    constructor(program, provider, lookupTableAddress) {
         this.program = program;
         this.provider = provider;
+        if (lookupTableAddress)
+            this.lookupTableAddress = new web3_js_1.PublicKey(lookupTableAddress);
+    }
+    /** Accounts that are identical on every batch withdrawal — the ALT payload. */
+    lookup_table_addresses(mints) {
+        const programId = this.program.programId;
+        const global = [
+            EscrowService.findEscrowConfigPda(programId),
+            EscrowService.findVaultAuthorityPda(programId),
+            web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("treasury-config")], programId)[0],
+            web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("timelock-config")], programId)[0],
+            spl_token_1.TOKEN_PROGRAM_ID,
+            web3_js_1.SystemProgram.programId,
+            web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        ];
+        const perMint = mints.flatMap(m => {
+            const mint = new web3_js_1.PublicKey(m);
+            return [
+                mint,
+                EscrowService.findVaultAta(mint, programId),
+                web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token-threshold"), mint.toBytes()], programId)[0],
+                web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("token-timelock"), mint.toBytes()], programId)[0],
+            ];
+        });
+        return [...global, ...perMint];
+    }
+    /**
+     * Idempotently guarantees a lookup table covering `mints` exists and is usable.
+     *
+     * Deliberately keeps no external state: tables are discovered on-chain by their authority
+     * (the funding wallet), so there is nothing to persist, migrate, or keep in sync across
+     * environments and worker instances. Extends a table that is missing addresses, creates one
+     * when none exists, and returns the usable address.
+     *
+     * Returns null if provisioning fails — the lookup table is an optimisation, so callers fall
+     * back to legacy transactions rather than failing a withdrawal that would otherwise succeed.
+     */
+    ensure_lookup_table(mints, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const required = this.lookup_table_addresses(mints);
+            const existing = this.lookupTableAddress
+                ? yield this.fetchLookupTable(this.lookupTableAddress)
+                : yield this.discoverLookupTable();
+            let table;
+            if (existing) {
+                const missing = this.missingAddresses(existing.state.addresses, required);
+                if (missing.length)
+                    yield this.extendLookupTable(existing.key, missing, signer);
+                table = existing.key;
+            }
+            else {
+                table = yield this.createLookupTable(required, signer);
+            }
+            // Re-read and confirm the table actually covers what we need. A half-provisioned table
+            // (created but not extended) silently compiles to a v0 message with zero lookups, giving
+            // none of the size saving — so treat partial coverage as a hard failure rather than
+            // reporting success and overflowing later.
+            const settled = yield this.fetchLookupTable(table);
+            const stillMissing = settled ? this.missingAddresses(settled.state.addresses, required) : required;
+            if (stillMissing.length) {
+                throw new Error(`Lookup table ${table.toBase58()} is incomplete: ${stillMissing.length}/${required.length} addresses missing`);
+            }
+            this.lookupTableAddress = table;
+            this.lookupTableCache = undefined;
+            return table;
+        });
+    }
+    /** Back-compat wrapper for explicit one-time provisioning; prefer `ensure_lookup_table`. */
+    create_lookup_table(mints, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = yield this.ensure_lookup_table(mints, signer);
+            if (!table)
+                throw new Error("Failed to provision the escrow lookup table");
+            return table.toBase58();
+        });
+    }
+    fetchLookupTable(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { value } = yield this.provider.connection.getAddressLookupTable(key);
+            return value ? { key, state: value.state } : null;
+        });
+    }
+    /**
+     * Finds a live table already owned by this authority. `getProgramAccounts` is filtered
+     * server-side on the authority pubkey, which sits at a fixed offset in the table header:
+     * u32 typeIndex + u64 deactivationSlot + u64 lastExtendedSlot + u8 startIndex + u8 option tag.
+     */
+    discoverLookupTable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const AUTHORITY_OFFSET = 22;
+            const authority = this.provider.wallet.publicKey;
+            const accounts = yield this.provider.connection.getProgramAccounts(web3_js_1.AddressLookupTableProgram.programId, { filters: [{ memcmp: { offset: AUTHORITY_OFFSET, bytes: authority.toBase58() } }] });
+            const live = accounts
+                .map(a => {
+                try {
+                    return { key: a.pubkey, state: web3_js_1.AddressLookupTableAccount.deserialize(a.account.data) };
+                }
+                catch (_a) {
+                    return null;
+                }
+            })
+                .filter((t) => t !== null)
+                // A deactivated table cannot be used; MAX u64 means "never deactivated".
+                .filter(t => t.state.deactivationSlot === BigInt("18446744073709551615"));
+            if (!live.length)
+                return null;
+            // Prefer the most complete table so repeated runs converge on one.
+            return live.sort((a, b) => b.state.addresses.length - a.state.addresses.length)[0];
+        });
+    }
+    missingAddresses(present, required) {
+        const have = new Set(present.map(a => a.toBase58()));
+        const seen = new Set();
+        return required.filter(a => {
+            const k = a.toBase58();
+            if (have.has(k) || seen.has(k))
+                return false;
+            seen.add(k);
+            return true;
+        });
+    }
+    createLookupTable(addresses, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authority = this.provider.wallet.publicKey;
+            const slot = yield this.provider.connection.getSlot("finalized");
+            const [createIx, table] = web3_js_1.AddressLookupTableProgram.createLookupTable({
+                authority, payer: authority, recentSlot: slot,
+            });
+            yield this.sendLegacyTransaction([createIx], signer);
+            yield this.extendLookupTable(table, addresses, signer);
+            return table;
+        });
+    }
+    extendLookupTable(table, addresses, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authority = this.provider.wallet.publicKey;
+            // Chunked so the extend instruction itself stays under the transaction size limit.
+            for (let i = 0; i < addresses.length; i += 20) {
+                yield this.sendLegacyTransaction([
+                    web3_js_1.AddressLookupTableProgram.extendLookupTable({
+                        payer: authority, authority, lookupTable: table, addresses: addresses.slice(i, i + 20),
+                    }),
+                ], signer);
+            }
+            // A table is only usable from the slot after it was written; wait so the first v0
+            // transaction referencing it can actually resolve the accounts.
+            yield this.waitForLookupTableActivation(table);
+        });
+    }
+    waitForLookupTableActivation(table_1) {
+        return __awaiter(this, arguments, void 0, function* (table, timeoutMs = 30000) {
+            const startSlot = yield this.provider.connection.getSlot("confirmed");
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() < deadline) {
+                const [{ value }, slot] = yield Promise.all([
+                    this.provider.connection.getAddressLookupTable(table),
+                    this.provider.connection.getSlot("confirmed"),
+                ]);
+                if (value && slot > startSlot)
+                    return;
+                yield new Promise(r => setTimeout(r, 1000));
+            }
+        });
+    }
+    /** Resolves (and caches) the configured lookup table; [] when none is set or it's missing. */
+    resolveLookupTables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.lookupTableAddress)
+                return [];
+            if (this.lookupTableCache)
+                return [this.lookupTableCache];
+            const { value } = yield this.provider.connection.getAddressLookupTable(this.lookupTableAddress);
+            if (!value)
+                return [];
+            this.lookupTableCache = value;
+            return [value];
+        });
     }
     // ==========================
     // Admin View Methods
@@ -358,40 +536,284 @@ class EscrowAdminUtility {
     /**
      *  Accepts an array of receivers and amounts and performs a batch withdrawal to the specified receivers
      * for the specified token (SOL or SPL)
+     * @param chain_id Network's chain id
      * @param token_address Address of the token to withdraw
      * @param recipients Array of receivers and their amounts
      * @param signer optional signer keypair
      * @returns string - signature
      */
-    withdraw_batch(token_address, recipients, signer) {
+    withdraw_batch(chain_id, token_address, recipients, signer) {
         return __awaiter(this, void 0, void 0, function* () {
             const token_pubkey = new web3_js_1.PublicKey(token_address);
+            // A batch carrying treasury signatures only fits in 1232 bytes as a v0 transaction, so make
+            // sure the lookup table exists before building it. This is idempotent and self-healing: the
+            // first signature-gated withdrawal provisions the table, every later one reuses it, and a
+            // failure here simply leaves us on legacy transactions rather than blocking the withdrawal.
+            if (recipients.some(r => { var _a; return (_a = r.signatures) === null || _a === void 0 ? void 0 : _a.length; })) {
+                try {
+                    yield this.ensure_lookup_table([token_address], signer);
+                }
+                catch (_a) {
+                    // Degrade to legacy rather than block: two-signature batches still fit without it.
+                    // Larger ones will fail loudly on the size limit, which is the honest outcome.
+                    this.lookupTableAddress = undefined;
+                    this.lookupTableCache = undefined;
+                }
+            }
             switch (token_pubkey.toBase58()) {
                 case (web3_js_1.SystemProgram.programId.toBase58()):
-                    return this.batch_withdraw_sol(recipients, signer);
+                    return this.batch_withdraw_sol(chain_id, recipients, signer);
                 default:
-                    return this.batch_withdraw_spl(token_pubkey, recipients, signer);
+                    return this.batch_withdraw_spl(chain_id, token_pubkey, recipients, signer);
             }
         });
     }
-    /** @dev this might fail if the recipient does not have an ATA - take care of it in funding worker task */
-    batch_withdraw_spl(mint, recipients, signer) {
+    /**
+     * Executes previously-scheduled (timelocked) withdrawals whose delay has elapsed. The amounts
+     * and recipient are read from each commitment on-chain, so only the request ids + their
+     * commitment/recipient accounts are supplied. Pays out and closes each commitment.
+     *
+     * Sent as a v0 transaction over the escrow lookup table: a batch's per-request accounts
+     * (commitment + recipient [+ ATA]) plus the static config accounts overflow a legacy
+     * transaction beyond a handful of requests, so we reuse the same ALT as the withdraw path.
+     */
+    batch_execute_withdrawal(chain_id, token_address, receivers, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!receivers.length)
+                throw new Error("batch_execute_withdrawal: receivers must not be empty");
+            const token_pubkey = new web3_js_1.PublicKey(token_address);
+            // Provision/reuse the lookup table so larger execute batches fit in a v0 transaction.
+            try {
+                yield this.ensure_lookup_table([token_address], signer);
+            }
+            catch (_a) {
+                this.lookupTableAddress = undefined;
+                this.lookupTableCache = undefined;
+            }
+            return token_pubkey.equals(web3_js_1.SystemProgram.programId)
+                ? this.batch_execute_withdrawal_sol(chain_id, receivers, signer)
+                : this.batch_execute_withdrawal_spl(chain_id, token_pubkey, receivers, signer);
+        });
+    }
+    /** Builds the SOL batch-execute instruction. Shared by the send and simulate paths. */
+    build_batch_execute_sol_ixs(receivers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const escrowConfigPda = EscrowService.findEscrowConfigPda(this.program.programId);
+            const vaultAuthority = EscrowService.findVaultAuthorityPda(this.program.programId);
+            const requestIds = receivers.map(r => new anchor.BN(r.request_id));
+            // Per request: [commitment, recipient]
+            const remaining = receivers.flatMap(r => {
+                const wallet = new web3_js_1.PublicKey(r.receiver_pubkey);
+                const { commitment } = this.request_pdas(wallet, r.request_id);
+                return [
+                    { isSigner: false, pubkey: commitment, isWritable: true },
+                    { isSigner: false, pubkey: wallet, isWritable: true },
+                ];
+            });
+            const ix = yield this.program.methods
+                .batchExecuteWithdrawalSol(requestIds)
+                .accountsPartial({
+                escrowConfig: escrowConfigPda,
+                vaultAuthority,
+                caller: this.provider.wallet.publicKey,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            })
+                .remainingAccounts(remaining)
+                .instruction();
+            return [ix];
+        });
+    }
+    /** Builds the SPL batch-execute instruction. Shared by the send and simulate paths. */
+    build_batch_execute_spl_ixs(mint, receivers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const escrowConfigPda = EscrowService.findEscrowConfigPda(this.program.programId);
+            const vaultAuthority = EscrowService.findVaultAuthorityPda(this.program.programId);
+            const vaultTokenAccount = EscrowService.findVaultAta(mint, this.program.programId);
+            const requestIds = receivers.map(r => new anchor.BN(r.request_id));
+            // Per request: [commitment, recipient, recipient_token_account]
+            const remaining = receivers.flatMap(r => {
+                const wallet = new web3_js_1.PublicKey(r.receiver_pubkey);
+                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, wallet);
+                const { commitment } = this.request_pdas(wallet, r.request_id);
+                return [
+                    { isSigner: false, pubkey: commitment, isWritable: true },
+                    { isSigner: false, pubkey: wallet, isWritable: true },
+                    { isSigner: false, pubkey: ata, isWritable: true },
+                ];
+            });
+            const ix = yield this.program.methods
+                .batchExecuteWithdrawalSpl(requestIds)
+                .accountsPartial({
+                escrowConfig: escrowConfigPda,
+                mint,
+                vaultAuthority,
+                vaultTokenAccount,
+                caller: this.provider.wallet.publicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            })
+                .remainingAccounts(remaining)
+                .instruction();
+            return [ix];
+        });
+    }
+    batch_execute_withdrawal_sol(_chainId, receivers, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = yield this.build_batch_execute_sol_ixs(receivers);
+            const signature = yield this.sendTransaction(ixs, signer);
+            yield this.waitForConfirmation(signature, "confirmed");
+            return signature;
+        });
+    }
+    batch_execute_withdrawal_spl(_chainId, mint, receivers, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = yield this.build_batch_execute_spl_ixs(mint, receivers);
+            const signature = yield this.sendTransaction(ixs, signer);
+            yield this.waitForConfirmation(signature, "confirmed");
+            return signature;
+        });
+    }
+    /**
+     * Simulates a batch execute without sending, returning `{ ok, error }`. The funding worker
+     * uses it to quarantine requests that would revert (timelock not elapsed, commitment already
+     * executed, …) before committing the real batch — the program reverts the whole transaction
+     * without naming the offending request, so callers simulate one request at a time.
+     */
+    simulate_batch_execute_withdrawal(chain_id, token_address, receivers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token_pubkey = new web3_js_1.PublicKey(token_address);
+            try {
+                yield this.ensure_lookup_table([token_address]);
+            }
+            catch (_a) {
+                this.lookupTableAddress = undefined;
+                this.lookupTableCache = undefined;
+            }
+            const ixs = token_pubkey.equals(web3_js_1.SystemProgram.programId)
+                ? yield this.build_batch_execute_sol_ixs(receivers)
+                : yield this.build_batch_execute_spl_ixs(token_pubkey, receivers);
+            return this.simulateInstructions(ixs);
+        });
+    }
+    /**
+     * Builds an (unsigned) transaction from `ixs` and simulates it. Returns `{ ok:false, error }`
+     * with the revert reason from the program logs when it would fail. `sigVerify:false` skips the
+     * missing fee-payer signature; the Ed25519 program instruction still executes, so invalid or
+     * insufficient treasury signatures are caught here too.
+     */
+    simulateInstructions(ixs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const lookupTables = yield this.resolveLookupTables();
+                const message = new web3_js_1.TransactionMessage({
+                    payerKey: this.provider.wallet.publicKey,
+                    recentBlockhash: (yield this.provider.connection.getLatestBlockhash()).blockhash,
+                    instructions: ixs,
+                }).compileToV0Message(lookupTables);
+                const tx = new web3_js_1.VersionedTransaction(message);
+                const sim = yield this.provider.connection.simulateTransaction(tx, {
+                    sigVerify: false,
+                    replaceRecentBlockhash: true,
+                });
+                if (sim.value.err) {
+                    const logs = (_a = sim.value.logs) !== null && _a !== void 0 ? _a : [];
+                    const reason = (_b = logs.find(l => l.includes("Error") || l.includes("failed"))) !== null && _b !== void 0 ? _b : JSON.stringify(sim.value.err);
+                    return { ok: false, error: reason };
+                }
+                return { ok: true, error: null };
+            }
+            catch (error) {
+                return { ok: false, error: (_c = error === null || error === void 0 ? void 0 : error.message) !== null && _c !== void 0 ? _c : "simulation failed" };
+            }
+        });
+    }
+    /** Per-request PDAs the folded batch path expects: receiver timelock override + commitment. */
+    request_pdas(receiver, request_id) {
+        const ridBuf = Buffer.alloc(8);
+        ridBuf.writeBigUInt64LE(BigInt(request_id));
+        const [receiverTimelock] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('receiver-timelock'), receiver.toBytes()], this.program.programId);
+        const [commitment] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('withdrawal'), ridBuf], this.program.programId);
+        return { receiverTimelock, commitment };
+    }
+    /**
+     * The distinct replay-bitmap page accounts a batch touches. The program appends these AFTER
+     * the per-request accounts and locates each request's page by key, so a page shared by several
+     * requests is passed once. Metas are writable (the program may create/flip bits) and non-signer.
+     */
+    bitmap_page_accounts(request_ids) {
+        const pages = new Set();
+        const metas = [];
+        for (const id of request_ids) {
+            const page = BigInt(id) / EscrowAdminUtility.IDS_PER_PAGE;
+            const pageBuf = Buffer.alloc(8);
+            pageBuf.writeBigUInt64LE(page);
+            const [pda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('withdrawal-bitmap'), pageBuf], this.program.programId);
+            const key = pda.toBase58();
+            if (pages.has(key))
+                continue;
+            pages.add(key);
+            metas.push({ isSigner: false, pubkey: pda, isWritable: true });
+        }
+        return metas;
+    }
+    /**
+     * Builds the Ed25519SigVerify instruction the program scans to enforce treasury multisig.
+     * Each request contributes its signers' approvals over that request's message (which binds
+     * the committed amount + token + chain + request id). Returns null when no request carries
+     * signatures, so plain batches send just the withdraw instruction.
+     */
+    buildBatchTreasuryEd25519(chainId, tokenMint, recipients) {
+        var _a;
+        const entries = [];
+        for (const r of recipients) {
+            if (!((_a = r.signatures) === null || _a === void 0 ? void 0 : _a.length))
+                continue;
+            const message = (0, TreasuryWithdrawalSignature_1.buildWithdrawalApprovalMessage)({
+                recipient: new web3_js_1.PublicKey(r.receiver_pubkey),
+                tokenMint,
+                committedAmount: BigInt(r.amount_in_lamports),
+                chainId: BigInt(chainId),
+                requestId: BigInt(r.request_id),
+            });
+            for (const s of r.signatures) {
+                entries.push({
+                    publicKey: new web3_js_1.PublicKey(s.signer).toBytes(),
+                    signature: (0, TreasuryWithdrawalSignature_1.decodeEd25519Signature)(s.signature),
+                    message,
+                });
+            }
+        }
+        return entries.length ? (0, TreasuryWithdrawalSignature_1.buildTreasuryEd25519Instruction)(entries) : null;
+    }
+    /**
+     * Builds the instruction list for an SPL batch withdraw: an optional treasury Ed25519 proof
+     * followed by the batch instruction. Shared by the send and simulate paths so they never drift.
+     */
+    build_batch_withdraw_spl_ixs(chainId, mint, recipients) {
         return __awaiter(this, void 0, void 0, function* () {
             const escrowConfigPda = EscrowService.findEscrowConfigPda(this.program.programId);
             const vaultAuthority = EscrowService.findVaultAuthorityPda(this.program.programId);
             const vaultTokenAccount = EscrowService.findVaultAta(mint, this.program.programId);
             const amounts = recipients.map(r => new anchor.BN(r.amount_in_lamports));
+            const net_amounts = recipients.map(r => new anchor.BN(r.net_amount_in_lamports));
             const request_ids = recipients.map(r => new anchor.BN(r.request_id));
-            const receivers = recipients.map(r => {
-                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, new web3_js_1.PublicKey(r.receiver_pubkey));
-                return {
-                    isSigner: false,
-                    pubkey: ata,
-                    isWritable: true
-                };
+            // Per request: [recipient, recipient_token_account, receiver_timelock, commitment]
+            const receivers = recipients.flatMap(r => {
+                const wallet = new web3_js_1.PublicKey(r.receiver_pubkey);
+                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, wallet);
+                const { receiverTimelock, commitment } = this.request_pdas(wallet, r.request_id);
+                return [
+                    { isSigner: false, pubkey: wallet, isWritable: true },
+                    { isSigner: false, pubkey: ata, isWritable: true },
+                    { isSigner: false, pubkey: receiverTimelock, isWritable: false },
+                    { isSigner: false, pubkey: commitment, isWritable: true },
+                ];
             });
+            // Distinct replay-bitmap pages follow the per-request accounts.
+            receivers.push(...this.bitmap_page_accounts(recipients.map(r => r.request_id)));
             const ix = yield this.program.methods
-                .batchWithdrawTokens(request_ids, amounts)
+                .batchWithdrawTokens(new anchor.BN(chainId), request_ids, amounts, net_amounts)
                 .accountsPartial({
                 escrowConfig: escrowConfigPda,
                 vaultAuthority: vaultAuthority,
@@ -402,26 +824,41 @@ class EscrowAdminUtility {
             })
                 .remainingAccounts(receivers)
                 .instruction();
-            const signature = yield this.sendTransaction([ix], signer);
+            const ed25519 = this.buildBatchTreasuryEd25519(chainId, mint, recipients);
+            return ed25519 ? [ed25519, ix] : [ix];
+        });
+    }
+    /** @dev this might fail if the recipient does not have an ATA - take care of it in funding worker task */
+    batch_withdraw_spl(chainId, mint, recipients, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = yield this.build_batch_withdraw_spl_ixs(chainId, mint, recipients);
+            const signature = yield this.sendTransaction(ixs, signer);
             yield this.waitForConfirmation(signature, "confirmed");
             return signature;
         });
     }
-    batch_withdraw_sol(recipients, signer) {
+    /** Builds the instruction list for a SOL batch withdraw (optional treasury proof + batch ix). */
+    build_batch_withdraw_sol_ixs(chainId, recipients) {
         return __awaiter(this, void 0, void 0, function* () {
             const escrowConfigPda = EscrowService.findEscrowConfigPda(this.program.programId);
             const vaultAuthority = EscrowService.findVaultAuthorityPda(this.program.programId);
             const amounts = recipients.map(r => new anchor.BN(r.amount_in_lamports));
-            const receivers = recipients.map(r => {
-                return {
-                    isSigner: false,
-                    pubkey: new web3_js_1.PublicKey(r.receiver_pubkey),
-                    isWritable: true
-                };
-            });
+            const net_amounts = recipients.map(r => new anchor.BN(r.net_amount_in_lamports));
             const request_ids = recipients.map(r => new anchor.BN(r.request_id));
+            // Per request: [recipient, receiver_timelock, commitment]
+            const receivers = recipients.flatMap(r => {
+                const wallet = new web3_js_1.PublicKey(r.receiver_pubkey);
+                const { receiverTimelock, commitment } = this.request_pdas(wallet, r.request_id);
+                return [
+                    { isSigner: false, pubkey: wallet, isWritable: true },
+                    { isSigner: false, pubkey: receiverTimelock, isWritable: false },
+                    { isSigner: false, pubkey: commitment, isWritable: true },
+                ];
+            });
+            // Distinct replay-bitmap pages follow the per-request accounts.
+            receivers.push(...this.bitmap_page_accounts(recipients.map(r => r.request_id)));
             const ix = yield this.program.methods
-                .batchWithdrawSol(request_ids, amounts)
+                .batchWithdrawSol(new anchor.BN(chainId), request_ids, amounts, net_amounts)
                 .accountsPartial({
                 escrowConfig: escrowConfigPda,
                 vaultAuthority: vaultAuthority,
@@ -430,19 +867,38 @@ class EscrowAdminUtility {
             })
                 .remainingAccounts(receivers)
                 .instruction();
-            // let preimage = `global:batchWithdrawSol`;
-            // let ixBuffer = Buffer.from(sha256.hash(preimage)).slice(0, 8);
-            // const ixData = Buffer.concat([
-            //     new Uint8Array(ixBuffer),
-            //     new Uint8Array(ix.data)
-            // ])
-            // const transactionIx = new TransactionInstruction({
-            //     programId: this.program.programId,
-            //     data: ixData,
-            //     keys: ix.keys
-            // })
-            const signature = yield this.sendTransaction([ix], signer);
-            return signature;
+            const ed25519 = this.buildBatchTreasuryEd25519(chainId, web3_js_1.SystemProgram.programId, recipients);
+            return ed25519 ? [ed25519, ix] : [ix];
+        });
+    }
+    batch_withdraw_sol(chainId, recipients, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = yield this.build_batch_withdraw_sol_ixs(chainId, recipients);
+            return this.sendTransaction(ixs, signer);
+        });
+    }
+    /**
+     * Simulates a batch withdraw without sending, returning `{ ok, error }`. Used by the funding
+     * worker to quarantine individual requests that would revert (bad/insufficient signatures,
+     * already scheduled, …) before committing the real batch — the program reverts the whole
+     * transaction without naming the offending request, so callers simulate one request at a time.
+     */
+    simulate_withdraw_batch(chain_id, token_address, recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token_pubkey = new web3_js_1.PublicKey(token_address);
+            if (recipients.some(r => { var _a; return (_a = r.signatures) === null || _a === void 0 ? void 0 : _a.length; })) {
+                try {
+                    yield this.ensure_lookup_table([token_address]);
+                }
+                catch (_a) {
+                    this.lookupTableAddress = undefined;
+                    this.lookupTableCache = undefined;
+                }
+            }
+            const ixs = token_pubkey.equals(web3_js_1.SystemProgram.programId)
+                ? yield this.build_batch_withdraw_sol_ixs(chain_id, recipients)
+                : yield this.build_batch_withdraw_spl_ixs(chain_id, token_pubkey, recipients);
+            return this.simulateInstructions(ixs);
         });
     }
     withdraw_sol(amount_in_decimals, receiver_pubkey, signer) {
@@ -582,29 +1038,59 @@ class EscrowAdminUtility {
     sendTransaction(ixs, signer) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const tx = new web3_js_1.Transaction();
-                for (let ix of ixs) {
-                    tx.add(ix);
-                }
-                tx.feePayer = this.provider.wallet.publicKey;
-                tx.recentBlockhash = (yield this.provider.connection.getLatestBlockhash()).blockhash;
-                let signature = "";
-                if (signer) {
-                    tx.sign(signer);
-                    signature = yield this.provider.connection.sendRawTransaction(tx.serialize());
-                    yield (0, TransactionsService_1.waitForTransactionConfirmation)(this.provider, signature, "confirmed");
-                }
-                else {
-                    signature = yield this.provider.sendAndConfirm(tx);
-                    yield (0, TransactionsService_1.waitForTransactionConfirmation)(this.provider, signature, "confirmed");
+                // Prefer a v0 transaction when a lookup table is configured — it is the only way a
+                // batch carrying more than two treasury signatures fits in 1232 bytes.
+                const lookupTables = yield this.resolveLookupTables();
+                if (lookupTables.length) {
+                    return yield this.sendVersionedTransaction(ixs, lookupTables, signer);
                 }
-                return signature;
+                return yield this.sendLegacyTransaction(ixs, signer);
             }
             catch (error) {
                 throw Errors_1.default.decode(error);
             }
         });
     }
+    sendVersionedTransaction(ixs, lookupTables, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = new web3_js_1.TransactionMessage({
+                payerKey: this.provider.wallet.publicKey,
+                recentBlockhash: (yield this.provider.connection.getLatestBlockhash()).blockhash,
+                instructions: ixs,
+            }).compileToV0Message(lookupTables);
+            const tx = new web3_js_1.VersionedTransaction(message);
+            if (signer) {
+                tx.sign([signer]);
+            }
+            else {
+                yield this.provider.wallet.signTransaction(tx);
+            }
+            const signature = yield this.provider.connection.sendRawTransaction(tx.serialize());
+            yield (0, TransactionsService_1.waitForTransactionConfirmation)(this.provider, signature, "confirmed");
+            return signature;
+        });
+    }
+    sendLegacyTransaction(ixs, signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new web3_js_1.Transaction();
+            for (let ix of ixs) {
+                tx.add(ix);
+            }
+            tx.feePayer = this.provider.wallet.publicKey;
+            tx.recentBlockhash = (yield this.provider.connection.getLatestBlockhash()).blockhash;
+            let signature = "";
+            if (signer) {
+                tx.sign(signer);
+                signature = yield this.provider.connection.sendRawTransaction(tx.serialize());
+                yield (0, TransactionsService_1.waitForTransactionConfirmation)(this.provider, signature, "confirmed");
+            }
+            else {
+                signature = yield this.provider.sendAndConfirm(tx);
+                yield (0, TransactionsService_1.waitForTransactionConfirmation)(this.provider, signature, "confirmed");
+            }
+            return signature;
+        });
+    }
     confirmTransaction(signature_1) {
         return __awaiter(this, arguments, void 0, function* (signature, commitment = "finalized") {
             yield this.provider.connection.confirmTransaction(signature, commitment);
@@ -657,12 +1143,14 @@ class EscrowAdminUtility {
      * @param idl IDL file - Escrow program idl
      * @returns
      */
-    static createWithCustomProgramId(provider, programId, idl) {
+    static createWithCustomProgramId(provider, programId, idl, lookupTableAddress) {
         // Override the program ID in the IDL
         const modifiedIdl = Object.assign(Object.assign({}, idl), { address: programId.toBase58() });
         const program = new anchor_1.Program(modifiedIdl, provider);
-        return new EscrowAdminUtility(program, provider);
+        return new EscrowAdminUtility(program, provider, lookupTableAddress);
     }
 }
 exports.EscrowAdminUtility = EscrowAdminUtility;
+/** Matches the program's IDS_PER_PAGE — the replay-bitmap page a request id maps to. */
+EscrowAdminUtility.IDS_PER_PAGE = BigInt(8192);
 exports.default = EscrowAdminUtility;