@ercworldio/blockchain-shared 1.0.5-dev.8-PLAT300.7 → 1.0.6

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

@@ -117,10 +117,14 @@ class EscrowAdminUtility {
             // 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) {
+            // reporting success and overflowing later. Poll rather than single-read: on a pooled RPC
+            // the read right after a write can still land on a backend that hasn't caught up.
+            try {
+                yield this.pollLookupTable(table, t => this.missingAddresses(t.state.addresses, required).length === 0, "final completeness");
+            }
+            catch (_a) {
+                const settled = yield this.fetchLookupTable(table);
+                const stillMissing = settled ? this.missingAddresses(settled.state.addresses, required) : required;
                 throw new Error(`Lookup table ${table.toBase58()} is incomplete: ${stillMissing.length}/${required.length} addresses missing`);
             }
             this.lookupTableAddress = table;
@@ -190,6 +194,10 @@ class EscrowAdminUtility {
                 authority, payer: authority, recentSlot: slot,
             });
             yield this.sendLegacyTransaction([createIx], signer);
+            // Wait until the new account is readable as a LUT before extending it: on a pooled RPC
+            // a lagging backend would otherwise simulate the extend against a still-System-owned
+            // account and fail with InvalidAccountOwner.
+            yield this.pollLookupTable(table, () => true, "post-create visibility");
             yield this.extendLookupTable(table, addresses, signer);
             return table;
         });
@@ -199,17 +207,50 @@ class EscrowAdminUtility {
             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) {
+                const chunk = addresses.slice(i, i + 20);
                 yield this.sendLegacyTransaction([
                     web3_js_1.AddressLookupTableProgram.extendLookupTable({
-                        payer: authority, authority, lookupTable: table, addresses: addresses.slice(i, i + 20),
+                        payer: authority, authority, lookupTable: table, addresses: chunk,
                     }),
                 ], signer);
+                // Confirm this chunk landed and propagated before moving on, so a later read
+                // (this loop's next chunk, or the caller's completeness check) never sees a
+                // stale pre-extend view of the table.
+                const want = chunk.map(a => a.toBase58());
+                yield this.pollLookupTable(table, t => {
+                    const have = new Set(t.state.addresses.map(a => a.toBase58()));
+                    return want.every(a => have.has(a));
+                }, `extend chunk @${i}`);
             }
             // 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);
         });
     }
+    /**
+     * Polls the lookup table until `predicate` holds, or throws after `timeoutMs`. Pooled RPC
+     * endpoints route consecutive requests to backends at slightly different slots, so a write
+     * that just confirmed on one node is not yet visible when the next request reads or
+     * simulates against it. Every "write the table, then immediately read/extend it" step has
+     * to tolerate that lag rather than trusting a single read.
+     */
+    pollLookupTable(table_1, predicate_1, label_1) {
+        return __awaiter(this, arguments, void 0, function* (table, predicate, label, timeoutMs = 45000, intervalMs = 1500) {
+            const deadline = Date.now() + timeoutMs;
+            let last = null;
+            while (Date.now() < deadline) {
+                const { value } = yield this.provider.connection.getAddressLookupTable(table, { commitment: "confirmed" });
+                if (value) {
+                    last = value;
+                    if (predicate(value))
+                        return value;
+                }
+                yield new Promise(r => setTimeout(r, intervalMs));
+            }
+            throw new Error(`Lookup table ${table.toBase58()} did not converge (${label}): ` +
+                (last ? `${last.state.addresses.length} addresses on chain` : "table not visible after write"));
+        });
+    }
     waitForLookupTableActivation(table_1) {
         return __awaiter(this, arguments, void 0, function* (table, timeoutMs = 30000) {
             const startSlot = yield this.provider.connection.getSlot("confirmed");