@pooflabs/web 0.0.60 → 0.0.62

package/dist/{index-DzGrm7WK.js → index-C2cjjAWD.js}

@@ -2,7 +2,7 @@
 
 var React = require('react');
 var globalAxios = require('axios');
-var index = require('./index-D15hrtDJ.js');
+var index = require('./index-BCpgjKea.js');
 var web3_js = require('@solana/web3.js');
 var jsxRuntime = require('react/jsx-runtime');
 require('@coral-xyz/anchor');
@@ -3167,7 +3167,7 @@ function stringToBase64url(str) {
 /**
  *  The current version of Ethers.
  */
-const version = "6.15.0";
+const version = "6.16.0";
 
 /**
  *  Property helper functions.
@@ -3374,7 +3374,8 @@ function _getBytes(value, name, copy) {
         }
         return value;
     }
-    if (typeof (value) === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
+    if (typeof (value) === "string" && (value.length % 2) === 0 &&
+        value.match(/^0x[0-9a-f]*$/i)) {
         const result = new Uint8Array((value.length - 2) / 2);
         let offset = 2;
         for (let i = 0; i < result.length; i++) {
@@ -3571,6 +3572,10 @@ function toBeHex(_value, _width) {
     let result = value.toString(16);
     {
         const width = getNumber(_width, "width");
+        // Special case when both value and width are 0 (see: #5025)
+        if (width === 0 && value === BN_0$3) {
+            return "0x";
+        }
         assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
             operation: "toBeHex",
             fault: "overflow",
@@ -3586,10 +3591,11 @@ function toBeHex(_value, _width) {
 /**
  *  Converts %%value%% to a Big Endian Uint8Array.
  */
-function toBeArray(_value) {
+function toBeArray(_value, _width) {
     const value = getUint(_value, "value");
     if (value === BN_0$3) {
-        return new Uint8Array([]);
+        const width = 0;
+        return new Uint8Array(width);
     }
     let hex = value.toString(16);
     if (hex.length % 2) {
@@ -6485,6 +6491,9 @@ const BN_2$1 = BigInt(2);
 const BN_27$1 = BigInt(27);
 const BN_28$1 = BigInt(28);
 const BN_35$1 = BigInt(35);
+const BN_N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
+const BN_N_2 = BN_N / BN_2$1; // Must be integer (floor) division; do NOT shifts
+const inspect$1 = Symbol.for("nodejs.util.inspect.custom");
 const _guard = {};
 function toUint256(value) {
     return zeroPadValue(toBeArray(value), 32);
@@ -6535,7 +6544,8 @@ class Signature {
      *  Returns true if the Signature is valid for [[link-eip-2]] signatures.
      */
     isValid() {
-        return (parseInt(this.#s.substring(0, 3)) < 8);
+        const s = BigInt(this.#s);
+        return (s <= BN_N_2);
     }
     /**
      *  The ``v`` value for a signature.
@@ -6611,8 +6621,26 @@ class Signature {
         this.#v = v;
         this.#networkV = null;
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return `Signature { r: "${this.r}", s: "${this._s}"${this.isValid() ? "" : ', valid: "false"'}, yParity: ${this.yParity}, networkV: ${this.networkV} }`;
+    /**
+     *  Returns the canonical signature.
+     *
+     *  This is only necessary when dealing with legacy transaction which
+     *  did not enforce canonical S values (i.e. [[link-eip-2]]. Most
+     *  developers should never require this.
+     */
+    getCanonical() {
+        if (this.isValid()) {
+            return this;
+        }
+        // Compute the canonical signature; s' = N - s, v = !v
+        const s = BN_N - BigInt(this._s);
+        const v = (55 - this.v);
+        const result = new Signature(_guard, this.r, toUint256(s), v);
+        // Populate the networkV if necessary
+        if (this.networkV) {
+            result.#networkV = this.networkV;
+        }
+        return result;
     }
     /**
      *  Returns a new identical [[Signature]].
@@ -6635,6 +6663,15 @@ class Signature {
             r: this.r, s: this._s, v: this.v,
         };
     }
+    [inspect$1]() {
+        return this.toString();
+    }
+    toString() {
+        if (this.isValid()) {
+            return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v} }`;
+        }
+        return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v}, valid: false }`;
+    }
     /**
      *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
      *
@@ -7152,7 +7189,9 @@ const BN_27 = BigInt(27);
 const BN_28 = BigInt(28);
 const BN_35 = BigInt(35);
 const BN_MAX_UINT = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+const inspect = Symbol.for("nodejs.util.inspect.custom");
 const BLOB_SIZE = 4096 * 32;
+const CELL_COUNT = 128;
 function getKzgLibrary(kzg) {
     const blobToKzgCommitment = (blob) => {
         if ("computeBlobProof" in kzg) {
@@ -7276,7 +7315,7 @@ function formatAuthorizationList(value) {
             formatNumber(a.nonce, "nonce"),
             formatNumber(a.signature.yParity, "yParity"),
             toBeArray(a.signature.r),
-            toBeArray(a.signature.s)
+            toBeArray(a.signature._s)
         ];
     });
 }
@@ -7377,7 +7416,7 @@ function _serializeLegacy(tx, sig) {
     // Add the signature
     fields.push(toBeArray(v));
     fields.push(toBeArray(sig.r));
-    fields.push(toBeArray(sig.s));
+    fields.push(toBeArray(sig._s));
     return encodeRlp(fields);
 }
 function _parseEipSignature(tx, fields) {
@@ -7482,9 +7521,11 @@ function _serializeEip2930(tx, sig) {
 function _parseEip4844(data) {
     let fields = decodeRlp(getBytes(data).slice(1));
     let typeName = "3";
+    let blobWrapperVersion = null;
     let blobs = null;
     // Parse the network format
     if (fields.length === 4 && Array.isArray(fields[0])) {
+        // EIP-4844 format with sidecar
         typeName = "3 (network format)";
         const fBlobs = fields[1], fCommits = fields[2], fProofs = fields[3];
         assertArgument(Array.isArray(fBlobs), "invalid network format: blobs not an array", "fields[1]", fBlobs);
@@ -7502,6 +7543,31 @@ function _parseEip4844(data) {
         }
         fields = fields[0];
     }
+    else if (fields.length === 5 && Array.isArray(fields[0])) {
+        // EIP-7594 format with sidecar
+        typeName = "3 (EIP-7594 network format)";
+        blobWrapperVersion = getNumber(fields[1]);
+        const fBlobs = fields[2], fCommits = fields[3], fProofs = fields[4];
+        assertArgument(blobWrapperVersion === 1, `unsupported EIP-7594 network format version: ${blobWrapperVersion}`, "fields[1]", blobWrapperVersion);
+        assertArgument(Array.isArray(fBlobs), "invalid EIP-7594 network format: blobs not an array", "fields[2]", fBlobs);
+        assertArgument(Array.isArray(fCommits), "invalid EIP-7594 network format: commitments not an array", "fields[3]", fCommits);
+        assertArgument(Array.isArray(fProofs), "invalid EIP-7594 network format: proofs not an array", "fields[4]", fProofs);
+        assertArgument(fBlobs.length === fCommits.length, "invalid network format: blobs/commitments length mismatch", "fields", fields);
+        assertArgument(fBlobs.length * CELL_COUNT === fProofs.length, "invalid network format: blobs/proofs length mismatch", "fields", fields);
+        blobs = [];
+        for (let i = 0; i < fBlobs.length; i++) {
+            const proof = [];
+            for (let j = 0; j < CELL_COUNT; j++) {
+                proof.push(fProofs[(i * CELL_COUNT) + j]);
+            }
+            blobs.push({
+                data: fBlobs[i],
+                commitment: fCommits[i],
+                proof: concat(proof)
+            });
+        }
+        fields = fields[0];
+    }
     assertArgument(Array.isArray(fields) && (fields.length === 11 || fields.length === 14), `invalid field count for transaction type: ${typeName}`, "data", hexlify(data));
     const tx = {
         type: 3,
@@ -7516,7 +7582,8 @@ function _parseEip4844(data) {
         data: hexlify(fields[7]),
         accessList: handleAccessList(fields[8], "accessList"),
         maxFeePerBlobGas: handleUint(fields[9], "maxFeePerBlobGas"),
-        blobVersionedHashes: fields[10]
+        blobVersionedHashes: fields[10],
+        blobWrapperVersion
     };
     if (blobs) {
         tx.blobs = blobs;
@@ -7556,6 +7623,29 @@ function _serializeEip4844(tx, sig, blobs) {
         fields.push(toBeArray(sig.s));
         // We have blobs; return the network wrapped format
         if (blobs) {
+            // Use EIP-7594
+            if (tx.blobWrapperVersion != null) {
+                const wrapperVersion = toBeArray(tx.blobWrapperVersion);
+                const cellProofs = [];
+                for (const { proof } of blobs) {
+                    const p = getBytes(proof);
+                    const cellSize = p.length / CELL_COUNT;
+                    for (let i = 0; i < p.length; i += cellSize) {
+                        cellProofs.push(p.subarray(i, i + cellSize));
+                    }
+                }
+                return concat([
+                    "0x03",
+                    encodeRlp([
+                        fields,
+                        wrapperVersion,
+                        blobs.map((b) => b.data),
+                        blobs.map((b) => b.commitment),
+                        cellProofs
+                    ])
+                ]);
+            }
+            // Fall back onto classic EIP-4844 behavior
             return concat([
                 "0x03",
                 encodeRlp([
@@ -7644,6 +7734,7 @@ class Transaction {
     #kzg;
     #blobs;
     #auths;
+    #blobWrapperVersion;
     /**
      *  The transaction type.
      *
@@ -7796,6 +7887,21 @@ class Transaction {
     set signature(value) {
         this.#sig = (value == null) ? null : Signature.from(value);
     }
+    isValid() {
+        const sig = this.signature;
+        if (sig && !sig.isValid()) {
+            return false;
+        }
+        const auths = this.authorizationList;
+        if (auths) {
+            for (const auth of auths) {
+                if (!auth.signature.isValid()) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     /**
      *  The access list.
      *
@@ -7931,13 +8037,11 @@ class Transaction {
                 versionedHashes.push(getVersionedHash(1, commit));
             }
             else {
-                const commit = hexlify(blob.commitment);
-                blobs.push({
-                    data: hexlify(blob.data),
-                    commitment: commit,
-                    proof: hexlify(blob.proof)
-                });
-                versionedHashes.push(getVersionedHash(1, commit));
+                const data = hexlify(blob.data);
+                const commitment = hexlify(blob.commitment);
+                const proof = hexlify(blob.proof);
+                blobs.push({ data, commitment, proof });
+                versionedHashes.push(getVersionedHash(1, commitment));
             }
         }
         this.#blobs = blobs;
@@ -7952,6 +8056,12 @@ class Transaction {
             this.#kzg = getKzgLibrary(kzg);
         }
     }
+    get blobWrapperVersion() {
+        return this.#blobWrapperVersion;
+    }
+    set blobWrapperVersion(value) {
+        this.#blobWrapperVersion = value;
+    }
     /**
      *  Creates a new Transaction with default values.
      */
@@ -7973,6 +8083,7 @@ class Transaction {
         this.#kzg = null;
         this.#blobs = null;
         this.#auths = null;
+        this.#blobWrapperVersion = null;
     }
     /**
      *  The transaction hash, if signed. Otherwise, ``null``.
@@ -7999,7 +8110,7 @@ class Transaction {
         if (this.signature == null) {
             return null;
         }
-        return recoverAddress(this.unsignedHash, this.signature);
+        return recoverAddress(this.unsignedHash, this.signature.getCanonical());
     }
     /**
      *  The public key of the sender, if signed. Otherwise, ``null``.
@@ -8008,7 +8119,7 @@ class Transaction {
         if (this.signature == null) {
             return null;
         }
-        return SigningKey.recoverPublicKey(this.unsignedHash, this.signature);
+        return SigningKey.recoverPublicKey(this.unsignedHash, this.signature.getCanonical());
     }
     /**
      *  Returns true if signed.
@@ -8195,6 +8306,56 @@ class Transaction {
             accessList: this.accessList
         };
     }
+    [inspect]() {
+        return this.toString();
+    }
+    toString() {
+        const output = [];
+        const add = (key) => {
+            let value = this[key];
+            if (typeof (value) === "string") {
+                value = JSON.stringify(value);
+            }
+            output.push(`${key}: ${value}`);
+        };
+        if (this.type) {
+            add("type");
+        }
+        add("to");
+        add("data");
+        add("nonce");
+        add("gasLimit");
+        add("value");
+        if (this.chainId != null) {
+            add("chainId");
+        }
+        if (this.signature) {
+            add("from");
+            output.push(`signature: ${this.signature.toString()}`);
+        }
+        // @TODO: accessList
+        // @TODO: blobs (might make output huge; maybe just include a flag?)
+        const auths = this.authorizationList;
+        if (auths) {
+            const outputAuths = [];
+            for (const auth of auths) {
+                const o = [];
+                o.push(`address: ${JSON.stringify(auth.address)}`);
+                if (auth.nonce != null) {
+                    o.push(`nonce: ${auth.nonce}`);
+                }
+                if (auth.chainId != null) {
+                    o.push(`chainId: ${auth.chainId}`);
+                }
+                if (auth.signature) {
+                    o.push(`signature: ${auth.signature.toString()}`);
+                }
+                outputAuths.push(`Authorization { ${o.join(", ")} }`);
+            }
+            output.push(`authorizations: [ ${outputAuths.join(", ")} ]`);
+        }
+        return `Transaction { ${output.join(", ")} }`;
+    }
     /**
      *  Create a **Transaction** from a serialized transaction or a
      *  Transaction-like object.
@@ -8268,6 +8429,9 @@ class Transaction {
         if (tx.kzg != null) {
             result.kzg = tx.kzg;
         }
+        if (tx.blobWrapperVersion != null) {
+            result.blobWrapperVersion = tx.blobWrapperVersion;
+        }
         if (tx.blobs != null) {
             result.blobs = tx.blobs;
         }
@@ -15410,4 +15574,4 @@ exports.useModal = useModal;
 exports.usePhantom = usePhantom;
 exports.useSolana = useSolana;
 exports.useTheme = useTheme;
-//# sourceMappingURL=index-DzGrm7WK.js.map
+//# sourceMappingURL=index-C2cjjAWD.js.map