@pooflabs/web 0.0.81 → 0.0.82

package/dist/{index-B2WGCssJ.js → index-BicMkamC.js}

@@ -9273,15 +9273,15 @@ function requireBuffer$1 () {
 
 var bufferExports$1 = requireBuffer$1();
 
-var safeBuffer = {exports: {}};
+var safeBuffer$1 = {exports: {}};
 
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
-var hasRequiredSafeBuffer;
+var hasRequiredSafeBuffer$1;
 
-function requireSafeBuffer () {
-	if (hasRequiredSafeBuffer) return safeBuffer.exports;
-	hasRequiredSafeBuffer = 1;
+function requireSafeBuffer$1 () {
+	if (hasRequiredSafeBuffer$1) return safeBuffer$1.exports;
+	hasRequiredSafeBuffer$1 = 1;
 	(function (module, exports$1) {
 		/* eslint-disable node/no-deprecated-api */
 		var buffer = requireBuffer$1();
@@ -9347,23 +9347,23 @@ function requireSafeBuffer () {
 		  }
 		  return buffer.SlowBuffer(size)
 		}; 
-	} (safeBuffer, safeBuffer.exports));
-	return safeBuffer.exports;
+	} (safeBuffer$1, safeBuffer$1.exports));
+	return safeBuffer$1.exports;
 }
 
-var src;
-var hasRequiredSrc;
+var src$1;
+var hasRequiredSrc$1;
 
-function requireSrc () {
-	if (hasRequiredSrc) return src;
-	hasRequiredSrc = 1;
+function requireSrc$1 () {
+	if (hasRequiredSrc$1) return src$1;
+	hasRequiredSrc$1 = 1;
 	// base-x encoding / decoding
 	// Copyright (c) 2018 base-x contributors
 	// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
 	// Distributed under the MIT software license, see the accompanying
 	// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 	// @ts-ignore
-	var _Buffer = requireSafeBuffer().Buffer;
+	var _Buffer = requireSafeBuffer$1().Buffer;
 	function base (ALPHABET) {
 	  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
 	  var BASE_MAP = new Uint8Array(256);
@@ -9478,21 +9478,21 @@ function requireSrc () {
 	    decode: decode
 	  }
 	}
-	src = base;
-	return src;
+	src$1 = base;
+	return src$1;
 }
 
-var bs58$1;
+var bs58$1$1;
 var hasRequiredBs58$1;
 
 function requireBs58$1 () {
-	if (hasRequiredBs58$1) return bs58$1;
+	if (hasRequiredBs58$1) return bs58$1$1;
 	hasRequiredBs58$1 = 1;
-	var basex = requireSrc();
+	var basex = requireSrc$1();
 	var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-	bs58$1 = basex(ALPHABET);
-	return bs58$1;
+	bs58$1$1 = basex(ALPHABET);
+	return bs58$1$1;
 }
 
 var bs58Exports$1 = requireBs58$1();
@@ -9575,6 +9575,12 @@ async function genSolanaMessage(address, nonce) {
 // Serialization Helpers
 // ─────────────────────────────────────────────────────────────
 function isHexString(value) {
+    // Only strings can be hex-encoded. Numbers, BNs, and other shapes coming back
+    // from the API for u64Val/i64Val should fall through to `new BN(value)` which
+    // accepts those shapes natively. Without this guard, calling .startsWith on a
+    // non-string blows up with TypeError.
+    if (typeof value !== "string")
+        return false;
     // Matches strings containing only 0-9, a-f, or A-F (optionally prefixed with 0x)
     let testValue = value;
     // Handle negative values
@@ -9670,8 +9676,11 @@ async function buildSetDocumentsTransaction(connection, idl, anchorProvider, pay
     }
     else if (idl.address === "poof4b5pk1L9tmThvBmaABjcyjfhFGbMbQP5BXk2QZp") {
         const program = new anchor.Program(idl, anchorProvider);
+        // Targets `set_documents_v2` (Vec<u8> ra_indices). The on-chain program
+        // also exposes the legacy `set_documents` (Vec<u64>) so SDKs already on npm
+        // continue to work — but new releases of this SDK speak v2 only.
         tx = await program.methods
-            .setDocuments(args.app_id, prepareAnchorArgs(args.documents), args.delete_paths, args.txData, simulate)
+            .setDocumentsV2(args.app_id, prepareAnchorArgs(args.documents), args.delete_paths, args.txData, simulate)
             .preInstructions(instructions)
             .accounts({
             payer: payerPublicKey
@@ -10026,11 +10035,17 @@ async function makeApiRequest(method, urlPath, data, _overrides) {
         if (_overrides === null || _overrides === void 0 ? void 0 : _overrides.headers) {
             Object.assign(headers, _overrides.headers);
         }
+        // Writes (PUT/POST/DELETE) can take significantly longer than reads —
+        // server-side they may trigger ad-hoc LUT creation (create + extend +
+        // wait-for-finalization, ~15-30s on mainnet). Use a larger default for
+        // non-GET so the SDK doesn't time out before client-api responds.
+        const isRead = method.toUpperCase() === "GET";
+        const defaultTimeout = isRead ? 30000 : 90000;
         const requestConfig = {
             method,
             url: `${config.apiUrl}${urlPath.startsWith("/") ? urlPath : `/${urlPath}`}`,
             headers,
-            timeout: (_a = _overrides === null || _overrides === void 0 ? void 0 : _overrides.timeout) !== null && _a !== void 0 ? _a : 30000,
+            timeout: (_a = _overrides === null || _overrides === void 0 ? void 0 : _overrides.timeout) !== null && _a !== void 0 ? _a : defaultTimeout,
         };
         if (method !== "GET" && method !== "get") {
             requestConfig.data = data ? JSON.stringify(data) : {};
@@ -10675,21 +10690,38 @@ async function setMany(many, options) {
             setDocumentData: tx.transactionArgs.setDocumentData,
             deletePaths: tx.transactionArgs.deletePaths,
             idl: tx.idl,
-            txData: (_b = (_a = tx.txData) === null || _a === void 0 ? void 0 : _a.map((txData) => {
-                var _a;
-                return ({
-                    pluginFunctionKey: txData.pluginFunctionKey,
-                    txData: bufferExports$1.Buffer.from(txData.txData),
-                    raIndices: (_a = txData.raIndices) === null || _a === void 0 ? void 0 : _a.map((raIndex) => {
-                        if (isHexString(raIndex)) {
-                            return new BN(raIndex, "hex");
+            txData: (_b = (_a = tx.txData) === null || _a === void 0 ? void 0 : _a.map((txData) => ({
+                pluginFunctionKey: txData.pluginFunctionKey,
+                txData: bufferExports$1.Buffer.from(txData.txData),
+                // raIndices is Vec<u8> on-chain (serialized as Buffer/bytes). The server may send
+                // it as a Buffer, a number[], a Uint8Array, or — over JSON — as Node's serialized
+                // Buffer shape {type: "Buffer", data: number[]} (the default `JSON.stringify(buf)`
+                // output). Normalise all of those to Buffer here. Each value must fit in u8 (matches
+                // Solana's instruction-level account indexing); throw clearly if anything is out of range.
+                raIndices: (() => {
+                    const raw = txData.raIndices;
+                    if (raw == null)
+                        return bufferExports$1.Buffer.alloc(0);
+                    if (bufferExports$1.Buffer.isBuffer(raw))
+                        return raw;
+                    if (raw instanceof Uint8Array)
+                        return bufferExports$1.Buffer.from(raw);
+                    // Node's JSON-serialised Buffer: {type: "Buffer", data: number[]}
+                    const arrayLike = Array.isArray(raw)
+                        ? raw
+                        : (raw && typeof raw === 'object' && Array.isArray(raw.data))
+                            ? raw.data
+                            : (() => { throw new Error(`raIndices has unexpected shape: ${typeof raw}`); })();
+                    const bytes = arrayLike.map((raIndex) => {
+                        const n = isHexString(raIndex) ? parseInt(raIndex, 16) : Number(raIndex);
+                        if (!Number.isInteger(n) || n < 0 || n > 255) {
+                            throw new Error(`raIndex ${raIndex} is not a valid u8 (must be integer in 0..255)`);
                         }
-                        else {
-                            return new BN(raIndex);
-                        }
-                    }),
-                });
-            })) !== null && _b !== void 0 ? _b : [],
+                        return n;
+                    });
+                    return bufferExports$1.Buffer.from(bytes);
+                })(),
+            }))) !== null && _b !== void 0 ? _b : [],
         };
         const config = await getConfig();
         const solTransaction = {
@@ -15669,7 +15701,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            Promise.resolve().then(function () { return require('./index-DXPkkq81.js'); })
+            Promise.resolve().then(function () { return require('./index-Ci3m3diI.js'); })
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -20087,62 +20119,135 @@ function createSolanaRpcSubscriptionsFromTransport(transport) {
   });
 }
 
-var cjs = {};
+var safeBuffer = {exports: {}};
 
-var hasRequiredCjs;
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
-function requireCjs () {
-	if (hasRequiredCjs) return cjs;
-	hasRequiredCjs = 1;
+var hasRequiredSafeBuffer;
+
+function requireSafeBuffer () {
+	if (hasRequiredSafeBuffer) return safeBuffer.exports;
+	hasRequiredSafeBuffer = 1;
+	(function (module, exports$1) {
+		/* eslint-disable node/no-deprecated-api */
+		var buffer = requireBuffer();
+		var Buffer = buffer.Buffer;
+
+		// alternative to using Object.keys for old browsers
+		function copyProps (src, dst) {
+		  for (var key in src) {
+		    dst[key] = src[key];
+		  }
+		}
+		if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+		  module.exports = buffer;
+		} else {
+		  // Copy properties from require('buffer')
+		  copyProps(buffer, exports$1);
+		  exports$1.Buffer = SafeBuffer;
+		}
+
+		function SafeBuffer (arg, encodingOrOffset, length) {
+		  return Buffer(arg, encodingOrOffset, length)
+		}
+
+		SafeBuffer.prototype = Object.create(Buffer.prototype);
+
+		// Copy static methods from Buffer
+		copyProps(Buffer, SafeBuffer);
+
+		SafeBuffer.from = function (arg, encodingOrOffset, length) {
+		  if (typeof arg === 'number') {
+		    throw new TypeError('Argument must not be a number')
+		  }
+		  return Buffer(arg, encodingOrOffset, length)
+		};
+
+		SafeBuffer.alloc = function (size, fill, encoding) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  var buf = Buffer(size);
+		  if (fill !== undefined) {
+		    if (typeof encoding === 'string') {
+		      buf.fill(fill, encoding);
+		    } else {
+		      buf.fill(fill);
+		    }
+		  } else {
+		    buf.fill(0);
+		  }
+		  return buf
+		};
+
+		SafeBuffer.allocUnsafe = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return Buffer(size)
+		};
+
+		SafeBuffer.allocUnsafeSlow = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return buffer.SlowBuffer(size)
+		}; 
+	} (safeBuffer, safeBuffer.exports));
+	return safeBuffer.exports;
+}
+
+var src;
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
 	// base-x encoding / decoding
 	// Copyright (c) 2018 base-x contributors
 	// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
 	// Distributed under the MIT software license, see the accompanying
 	// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-	Object.defineProperty(cjs, '__esModule', { value: true });
+	// @ts-ignore
+	var _Buffer = requireSafeBuffer().Buffer;
 	function base (ALPHABET) {
 	  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-	  const BASE_MAP = new Uint8Array(256);
-	  for (let j = 0; j < BASE_MAP.length; j++) {
+	  var BASE_MAP = new Uint8Array(256);
+	  for (var j = 0; j < BASE_MAP.length; j++) {
 	    BASE_MAP[j] = 255;
 	  }
-	  for (let i = 0; i < ALPHABET.length; i++) {
-	    const x = ALPHABET.charAt(i);
-	    const xc = x.charCodeAt(0);
+	  for (var i = 0; i < ALPHABET.length; i++) {
+	    var x = ALPHABET.charAt(i);
+	    var xc = x.charCodeAt(0);
 	    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
 	    BASE_MAP[xc] = i;
 	  }
-	  const BASE = ALPHABET.length;
-	  const LEADER = ALPHABET.charAt(0);
-	  const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-	  const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+	  var BASE = ALPHABET.length;
+	  var LEADER = ALPHABET.charAt(0);
+	  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+	  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
 	  function encode (source) {
-	    // eslint-disable-next-line no-empty
-	    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
-	      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-	    } else if (Array.isArray(source)) {
-	      source = Uint8Array.from(source);
-	    }
-	    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+	    if (Array.isArray(source) || source instanceof Uint8Array) { source = _Buffer.from(source); }
+	    if (!_Buffer.isBuffer(source)) { throw new TypeError('Expected Buffer') }
 	    if (source.length === 0) { return '' }
-	    // Skip & count leading zeroes.
-	    let zeroes = 0;
-	    let length = 0;
-	    let pbegin = 0;
-	    const pend = source.length;
+	        // Skip & count leading zeroes.
+	    var zeroes = 0;
+	    var length = 0;
+	    var pbegin = 0;
+	    var pend = source.length;
 	    while (pbegin !== pend && source[pbegin] === 0) {
 	      pbegin++;
 	      zeroes++;
 	    }
-	    // Allocate enough space in big-endian base58 representation.
-	    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-	    const b58 = new Uint8Array(size);
-	    // Process the bytes.
+	        // Allocate enough space in big-endian base58 representation.
+	    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+	    var b58 = new Uint8Array(size);
+	        // Process the bytes.
 	    while (pbegin !== pend) {
-	      let carry = source[pbegin];
-	      // Apply "b58 = b58 * 256 + ch".
-	      let i = 0;
-	      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+	      var carry = source[pbegin];
+	            // Apply "b58 = b58 * 256 + ch".
+	      var i = 0;
+	      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
 	        carry += (256 * b58[it1]) >>> 0;
 	        b58[it1] = (carry % BASE) >>> 0;
 	        carry = (carry / BASE) >>> 0;
@@ -20151,42 +20256,42 @@ function requireCjs () {
 	      length = i;
 	      pbegin++;
 	    }
-	    // Skip leading zeroes in base58 result.
-	    let it2 = size - length;
+	        // Skip leading zeroes in base58 result.
+	    var it2 = size - length;
 	    while (it2 !== size && b58[it2] === 0) {
 	      it2++;
 	    }
-	    // Translate the result into a string.
-	    let str = LEADER.repeat(zeroes);
+	        // Translate the result into a string.
+	    var str = LEADER.repeat(zeroes);
 	    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
 	    return str
 	  }
 	  function decodeUnsafe (source) {
 	    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-	    if (source.length === 0) { return new Uint8Array() }
-	    let psz = 0;
-	    // Skip and count leading '1's.
-	    let zeroes = 0;
-	    let length = 0;
+	    if (source.length === 0) { return _Buffer.alloc(0) }
+	    var psz = 0;
+	        // Skip and count leading '1's.
+	    var zeroes = 0;
+	    var length = 0;
 	    while (source[psz] === LEADER) {
 	      zeroes++;
 	      psz++;
 	    }
-	    // Allocate enough space in big-endian base256 representation.
-	    const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-	    const b256 = new Uint8Array(size);
-	    // Process the characters.
+	        // Allocate enough space in big-endian base256 representation.
+	    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+	    var b256 = new Uint8Array(size);
+	        // Process the characters.
 	    while (psz < source.length) {
-	      // Find code of next character
-	      const charCode = source.charCodeAt(psz);
-	      // Base map can not be indexed using char code
+	            // Find code of next character
+	      var charCode = source.charCodeAt(psz);
+	            // Base map can not be indexed using char code
 	      if (charCode > 255) { return }
-	      // Decode character
-	      let carry = BASE_MAP[charCode];
-	      // Invalid character
+	            // Decode character
+	      var carry = BASE_MAP[charCode];
+	            // Invalid character
 	      if (carry === 255) { return }
-	      let i = 0;
-	      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+	      var i = 0;
+	      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
 	        carry += (BASE * b256[it3]) >>> 0;
 	        b256[it3] = (carry % 256) >>> 0;
 	        carry = (carry / 256) >>> 0;
@@ -20195,52 +20300,53 @@ function requireCjs () {
 	      length = i;
 	      psz++;
 	    }
-	    // Skip leading zeroes in b256.
-	    let it4 = size - length;
+	        // Skip leading zeroes in b256.
+	    var it4 = size - length;
 	    while (it4 !== size && b256[it4] === 0) {
 	      it4++;
 	    }
-	    const vch = new Uint8Array(zeroes + (size - it4));
-	    let j = zeroes;
+	    var vch = _Buffer.allocUnsafe(zeroes + (size - it4));
+	    vch.fill(0x00, 0, zeroes);
+	    var j = zeroes;
 	    while (it4 !== size) {
 	      vch[j++] = b256[it4++];
 	    }
 	    return vch
 	  }
 	  function decode (string) {
-	    const buffer = decodeUnsafe(string);
+	    var buffer = decodeUnsafe(string);
 	    if (buffer) { return buffer }
 	    throw new Error('Non-base' + BASE + ' character')
 	  }
 	  return {
-	    encode,
-	    decodeUnsafe,
-	    decode
+	    encode: encode,
+	    decodeUnsafe: decodeUnsafe,
+	    decode: decode
 	  }
 	}
-	cjs.default = base;
-	return cjs;
+	src = base;
+	return src;
 }
 
-var bs58;
+var bs58$1;
 var hasRequiredBs58;
 
 function requireBs58 () {
-	if (hasRequiredBs58) return bs58;
+	if (hasRequiredBs58) return bs58$1;
 	hasRequiredBs58 = 1;
-	var basex = requireCjs();
+	var basex = requireSrc();
 	var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-	bs58 = basex(ALPHABET);
-	return bs58;
+	bs58$1 = basex(ALPHABET);
+	return bs58$1;
 }
 
 var bs58Exports = requireBs58();
-var base58 = /*@__PURE__*/getDefaultExportFromCjs$1(bs58Exports);
+var bs58 = /*@__PURE__*/getDefaultExportFromCjs$1(bs58Exports);
 
 var index = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
-	default: base58
+	default: bs58
 }, [bs58Exports]);
 
 const SURFNET_RPC_URL$1 = "https://surfpool.fly.dev";
@@ -20975,7 +21081,7 @@ class PrivyWalletProvider {
             // Handle case where signature might be bytes instead of string
             const rawSig = result.signature;
             if (rawSig instanceof Uint8Array || Array.isArray(rawSig)) {
-                signature = base58.encode(rawSig instanceof Uint8Array ? rawSig : new Uint8Array(rawSig));
+                signature = bs58.encode(rawSig instanceof Uint8Array ? rawSig : new Uint8Array(rawSig));
             }
             else {
                 signature = rawSig;
@@ -21155,7 +21261,7 @@ async function loadMwaProtocol() {
         return mwaProtocolLoadPromise;
     mwaProtocolLoadPromise = (async () => {
         try {
-            mwaProtocolModule = await Promise.resolve().then(function () { return require('./index.browser-d0PlOXpF.js'); });
+            mwaProtocolModule = await Promise.resolve().then(function () { return require('./index.browser-Df7yN8D5.js'); });
         }
         catch (e) {
             console.warn('[SolanaMobileWallet] @solana-mobile/mobile-wallet-adapter-protocol-web3js not installed. Install it to enable Seeker wallet support.');
@@ -21177,7 +21283,7 @@ async function registerMobileWalletAdapter(config) {
     if (typeof window === 'undefined')
         return;
     try {
-        const walletStandardMobile = await Promise.resolve().then(function () { return require('./index.browser-CT6PUv9G.js'); });
+        const walletStandardMobile = await Promise.resolve().then(function () { return require('./index.browser-BkMiHSON.js'); });
         const registerMwa = walletStandardMobile.registerMwa || ((_a = walletStandardMobile.default) === null || _a === void 0 ? void 0 : _a.registerMwa);
         if (!registerMwa) {
             console.warn('[SolanaMobileWallet] registerMwa not found in @solana-mobile/wallet-standard-mobile');
@@ -21930,7 +22036,7 @@ class PrivyExpoProvider {
         const wallet = await this.getWalletOrThrow();
         const messageBytes = getPlatform().textEncode(message);
         const result = await wallet.signMessage(messageBytes);
-        return base58.encode(result.signature);
+        return bs58.encode(result.signature);
     }
     async signTransaction(transaction) {
         await this.ensureReady();
@@ -22097,7 +22203,6 @@ exports.ServerSessionManager = ServerSessionManager;
 exports.SolanaMobileWalletProvider = SolanaMobileWalletProvider;
 exports.WebSessionManager = WebSessionManager;
 exports.aggregate = aggregate;
-exports.base58 = base58;
 exports.bufferExports = bufferExports;
 exports.buildSetDocumentsTransaction = buildSetDocumentsTransaction;
 exports.clearCache = clearCache;
@@ -22145,4 +22250,4 @@ exports.signSessionCreateMessage = signSessionCreateMessage;
 exports.signTransaction = signTransaction;
 exports.subscribe = subscribe;
 exports.useAuth = useAuth;
-//# sourceMappingURL=index-B2WGCssJ.js.map
+//# sourceMappingURL=index-BicMkamC.js.map