@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/publickey-DsLd2AKA.js

@@ -0,0 +1,2940 @@
+import { e as ed25519 } from './ed25519-BcS7UiUJ.js';
+import { s as secp256k1 } from './secp256k1-FNoOZ2h8.js';
+import { f as fromBig, b as add3H, r as rotr32L, c as rotr32H, d as add, e as rotrSL, g as rotrSH, h as rotrBL, i as rotrBH, j as add3L, s as sha256 } from './sha2-OXpLEvj4.js';
+import { j as createHasher, g as abytes, s as u32, t as swap8IfBE, f as clean, e as anumber$1, i as aexists, v as swap32IfBE, o as aoutput, m as bytesToHex, h as hexToBytes } from './utils-BDj4oeIm.js';
+import { p as p256 } from './nist-Cie-30E0.js';
+
+//#region src/uleb.ts
+function ulebEncode(num) {
+	let bigNum = BigInt(num);
+	const arr = [];
+	let len = 0;
+	if (bigNum === 0n) return [0];
+	while (bigNum > 0) {
+		arr[len] = Number(bigNum & 127n);
+		bigNum >>= 7n;
+		if (bigNum > 0n) arr[len] |= 128;
+		len += 1;
+	}
+	return arr;
+}
+function ulebDecode(arr) {
+	let total = 0n;
+	let shift = 0n;
+	let len = 0;
+	while (true) {
+		if (len >= arr.length) throw new Error("ULEB decode error: buffer overflow");
+		const byte = arr[len];
+		len += 1;
+		total += BigInt(byte & 127) << shift;
+		if ((byte & 128) === 0) break;
+		shift += 7n;
+	}
+	if (total > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
+	return {
+		value: Number(total),
+		length: len
+	};
+}
+
+//#region src/reader.ts
+/**
+* Class used for reading BCS data chunk by chunk. Meant to be used
+* by some wrapper, which will make sure that data is valid and is
+* matching the desired format.
+*
+* @example
+* // data for this example is:
+* // { a: u8, b: u32, c: bool, d: u64 }
+*
+* let reader = new BcsReader("647f1a060001ffffe7890423c78a050102030405");
+* let field1 = reader.read8();
+* let field2 = reader.read32();
+* let field3 = reader.read8() === '1'; // bool
+* let field4 = reader.read64();
+* // ....
+*
+* Reading vectors is another deal in bcs. To read a vector, you first need to read
+* its length using {@link readULEB}. Here's an example:
+* @example
+* // data encoded: { field: [1, 2, 3, 4, 5] }
+* let reader = new BcsReader("050102030405");
+* let vec_length = reader.readULEB();
+* let elements = [];
+* for (let i = 0; i < vec_length; i++) {
+*   elements.push(reader.read8());
+* }
+* console.log(elements); // [1,2,3,4,5]
+*
+* @param {String} data HEX-encoded data (serialized BCS)
+*/
+var BcsReader = class {
+	/**
+	* @param {Uint8Array} data Data to use as a buffer.
+	*/
+	constructor(data) {
+		this.bytePosition = 0;
+		this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	}
+	/**
+	* Shift current cursor position by `bytes`.
+	*
+	* @param {Number} bytes Number of bytes to
+	* @returns {this} Self for possible chaining.
+	*/
+	shift(bytes) {
+		this.bytePosition += bytes;
+		return this;
+	}
+	/**
+	* Read U8 value from the buffer and shift cursor by 1.
+	* @returns
+	*/
+	read8() {
+		const value = this.dataView.getUint8(this.bytePosition);
+		this.shift(1);
+		return value;
+	}
+	/**
+	* Read U16 value from the buffer and shift cursor by 2.
+	* @returns
+	*/
+	read16() {
+		const value = this.dataView.getUint16(this.bytePosition, true);
+		this.shift(2);
+		return value;
+	}
+	/**
+	* Read U32 value from the buffer and shift cursor by 4.
+	* @returns
+	*/
+	read32() {
+		const value = this.dataView.getUint32(this.bytePosition, true);
+		this.shift(4);
+		return value;
+	}
+	/**
+	* Read U64 value from the buffer and shift cursor by 8.
+	* @returns
+	*/
+	read64() {
+		const value1 = this.read32();
+		const result = this.read32().toString(16) + value1.toString(16).padStart(8, "0");
+		return BigInt("0x" + result).toString(10);
+	}
+	/**
+	* Read U128 value from the buffer and shift cursor by 16.
+	*/
+	read128() {
+		const value1 = BigInt(this.read64());
+		const result = BigInt(this.read64()).toString(16) + value1.toString(16).padStart(16, "0");
+		return BigInt("0x" + result).toString(10);
+	}
+	/**
+	* Read U128 value from the buffer and shift cursor by 32.
+	* @returns
+	*/
+	read256() {
+		const value1 = BigInt(this.read128());
+		const result = BigInt(this.read128()).toString(16) + value1.toString(16).padStart(32, "0");
+		return BigInt("0x" + result).toString(10);
+	}
+	/**
+	* Read `num` number of bytes from the buffer and shift cursor by `num`.
+	* @param num Number of bytes to read.
+	*/
+	readBytes(num) {
+		const start = this.bytePosition + this.dataView.byteOffset;
+		const value = new Uint8Array(this.dataView.buffer, start, num);
+		this.shift(num);
+		return value;
+	}
+	/**
+	* Read ULEB value - an integer of varying size. Used for enum indexes and
+	* vector lengths.
+	* @returns {Number} The ULEB value.
+	*/
+	readULEB() {
+		const start = this.bytePosition + this.dataView.byteOffset;
+		const { value, length } = ulebDecode(new Uint8Array(this.dataView.buffer, start));
+		this.shift(length);
+		return value;
+	}
+	/**
+	* Read a BCS vector: read a length and then apply function `cb` X times
+	* where X is the length of the vector, defined as ULEB in BCS bytes.
+	* @param cb Callback to process elements of vector.
+	* @returns {Array<Any>} Array of the resulting values, returned by callback.
+	*/
+	readVec(cb) {
+		const length = this.readULEB();
+		const result = [];
+		for (let i = 0; i < length; i++) result.push(cb(this, i, length));
+		return result;
+	}
+};
+
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+function isArrayOf(isString, arr) {
+    if (!Array.isArray(arr))
+        return false;
+    if (arr.length === 0)
+        return true;
+    if (isString) {
+        return arr.every((item) => typeof item === 'string');
+    }
+    else {
+        return arr.every((item) => Number.isSafeInteger(item));
+    }
+}
+function afn(input) {
+    if (typeof input !== 'function')
+        throw new Error('function expected');
+    return true;
+}
+function astr(label, input) {
+    if (typeof input !== 'string')
+        throw new Error(`${label}: string expected`);
+    return true;
+}
+function anumber(n) {
+    if (!Number.isSafeInteger(n))
+        throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+    if (!Array.isArray(input))
+        throw new Error('array expected');
+}
+function astrArr(label, input) {
+    if (!isArrayOf(true, input))
+        throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+    if (!isArrayOf(false, input))
+        throw new Error(`${label}: array of numbers expected`);
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function chain(...args) {
+    const id = (a) => a;
+    // Wrap call in closure so JIT can inline calls
+    const wrap = (a, b) => (c) => a(b(c));
+    // Construct chain of args[-1].encode(args[-2].encode([...]))
+    const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+    // Construct chain of args[0].decode(args[1].decode(...))
+    const decode = args.map((x) => x.decode).reduce(wrap, id);
+    return { encode, decode };
+}
+/**
+ * Encodes integer radix representation to array of strings using alphabet and back.
+ * Could also be array of strings.
+ * @__NO_SIDE_EFFECTS__
+ */
+function alphabet(letters) {
+    // mapping 1 to "b"
+    const lettersA = typeof letters === 'string' ? letters.split('') : letters;
+    const len = lettersA.length;
+    astrArr('alphabet', lettersA);
+    // mapping "b" to 1
+    const indexes = new Map(lettersA.map((l, i) => [l, i]));
+    return {
+        encode: (digits) => {
+            aArr(digits);
+            return digits.map((i) => {
+                if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+                    throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+                return lettersA[i];
+            });
+        },
+        decode: (input) => {
+            aArr(input);
+            return input.map((letter) => {
+                astr('alphabet.decode', letter);
+                const i = indexes.get(letter);
+                if (i === undefined)
+                    throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+                return i;
+            });
+        },
+    };
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function join(separator = '') {
+    astr('join', separator);
+    return {
+        encode: (from) => {
+            astrArr('join.decode', from);
+            return from.join(separator);
+        },
+        decode: (to) => {
+            astr('join.decode', to);
+            return to.split(separator);
+        },
+    };
+}
+/**
+ * Slow: O(n^2) time complexity
+ */
+function convertRadix(data, from, to) {
+    // base 1 is impossible
+    if (from < 2)
+        throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+    if (to < 2)
+        throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+    aArr(data);
+    if (!data.length)
+        return [];
+    let pos = 0;
+    const res = [];
+    const digits = Array.from(data, (d) => {
+        anumber(d);
+        if (d < 0 || d >= from)
+            throw new Error(`invalid integer: ${d}`);
+        return d;
+    });
+    const dlen = digits.length;
+    while (true) {
+        let carry = 0;
+        let done = true;
+        for (let i = pos; i < dlen; i++) {
+            const digit = digits[i];
+            const fromCarry = from * carry;
+            const digitBase = fromCarry + digit;
+            if (!Number.isSafeInteger(digitBase) ||
+                fromCarry / from !== carry ||
+                digitBase - digit !== fromCarry) {
+                throw new Error('convertRadix: carry overflow');
+            }
+            const div = digitBase / to;
+            carry = digitBase % to;
+            const rounded = Math.floor(div);
+            digits[i] = rounded;
+            if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+                throw new Error('convertRadix: carry overflow');
+            if (!done)
+                continue;
+            else if (!rounded)
+                pos = i;
+            else
+                done = false;
+        }
+        res.push(carry);
+        if (done)
+            break;
+    }
+    for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+        res.push(0);
+    return res.reverse();
+}
+const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
+const radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+const powers = /* @__PURE__ */ (() => {
+    let res = [];
+    for (let i = 0; i < 40; i++)
+        res.push(2 ** i);
+    return res;
+})();
+/**
+ * Implemented with numbers, because BigInt is 5x slower
+ */
+function convertRadix2(data, from, to, padding) {
+    aArr(data);
+    if (from <= 0 || from > 32)
+        throw new Error(`convertRadix2: wrong from=${from}`);
+    if (to <= 0 || to > 32)
+        throw new Error(`convertRadix2: wrong to=${to}`);
+    if (radix2carry(from, to) > 32) {
+        throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+    }
+    let carry = 0;
+    let pos = 0; // bitwise position in current element
+    const max = powers[from];
+    const mask = powers[to] - 1;
+    const res = [];
+    for (const n of data) {
+        anumber(n);
+        if (n >= max)
+            throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+        carry = (carry << from) | n;
+        if (pos + from > 32)
+            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+        pos += from;
+        for (; pos >= to; pos -= to)
+            res.push(((carry >> (pos - to)) & mask) >>> 0);
+        const pow = powers[pos];
+        if (pow === undefined)
+            throw new Error('invalid carry');
+        carry &= pow - 1; // clean carry, otherwise it will cause overflow
+    }
+    carry = (carry << (to - pos)) & mask;
+    if (!padding && pos >= from)
+        throw new Error('Excess padding');
+    if (!padding && carry > 0)
+        throw new Error(`Non-zero padding: ${carry}`);
+    if (padding && pos > 0)
+        res.push(carry >>> 0);
+    return res;
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function radix(num) {
+    anumber(num);
+    const _256 = 2 ** 8;
+    return {
+        encode: (bytes) => {
+            if (!isBytes(bytes))
+                throw new Error('radix.encode input should be Uint8Array');
+            return convertRadix(Array.from(bytes), _256, num);
+        },
+        decode: (digits) => {
+            anumArr('radix.decode', digits);
+            return Uint8Array.from(convertRadix(digits, num, _256));
+        },
+    };
+}
+/**
+ * If both bases are power of same number (like `2**8 <-> 2**64`),
+ * there is a linear algorithm. For now we have implementation for power-of-two bases only.
+ * @__NO_SIDE_EFFECTS__
+ */
+function radix2(bits, revPadding = false) {
+    anumber(bits);
+    if (bits <= 0 || bits > 32)
+        throw new Error('radix2: bits should be in (0..32]');
+    if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+        throw new Error('radix2: carry overflow');
+    return {
+        encode: (bytes) => {
+            if (!isBytes(bytes))
+                throw new Error('radix2.encode input should be Uint8Array');
+            return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+        },
+        decode: (digits) => {
+            anumArr('radix2.decode', digits);
+            return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+        },
+    };
+}
+function unsafeWrapper(fn) {
+    afn(fn);
+    return function (...args) {
+        try {
+            return fn.apply(null, args);
+        }
+        catch (e) { }
+    };
+}
+function checksum(len, fn) {
+    anumber(len);
+    afn(fn);
+    return {
+        encode(data) {
+            if (!isBytes(data))
+                throw new Error('checksum.encode: input should be Uint8Array');
+            const sum = fn(data).slice(0, len);
+            const res = new Uint8Array(data.length + len);
+            res.set(data);
+            res.set(sum, data.length);
+            return res;
+        },
+        decode(data) {
+            if (!isBytes(data))
+                throw new Error('checksum.decode: input should be Uint8Array');
+            const payload = data.slice(0, -len);
+            const oldChecksum = data.slice(-len);
+            const newChecksum = fn(payload).slice(0, len);
+            for (let i = 0; i < len; i++)
+                if (newChecksum[i] !== oldChecksum[i])
+                    throw new Error('Invalid checksum');
+            return payload;
+        },
+    };
+}
+// base58 code
+// -----------
+const genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(''));
+/**
+ * base58: base64 without ambigous characters +, /, 0, O, I, l.
+ * Quadratic (O(n^2)) - so, can't be used on large inputs.
+ * @example
+ * ```js
+ * base58.decode('01abcdef');
+ * // => '3UhJW'
+ * ```
+ */
+const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+/**
+ * Method, which creates base58check encoder.
+ * Requires function, calculating sha256.
+ */
+const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);
+const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));
+const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+function bech32Polymod(pre) {
+    const b = pre >> 25;
+    let chk = (pre & 0x1ffffff) << 5;
+    for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+        if (((b >> i) & 1) === 1)
+            chk ^= POLYMOD_GENERATORS[i];
+    }
+    return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+    const len = prefix.length;
+    let chk = 1;
+    for (let i = 0; i < len; i++) {
+        const c = prefix.charCodeAt(i);
+        if (c < 33 || c > 126)
+            throw new Error(`Invalid prefix (${prefix})`);
+        chk = bech32Polymod(chk) ^ (c >> 5);
+    }
+    chk = bech32Polymod(chk);
+    for (let i = 0; i < len; i++)
+        chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);
+    for (let v of words)
+        chk = bech32Polymod(chk) ^ v;
+    for (let i = 0; i < 6; i++)
+        chk = bech32Polymod(chk);
+    chk ^= encodingConst;
+    return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function genBech32(encoding) {
+    const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;
+    const _words = radix2(5);
+    const fromWords = _words.decode;
+    const toWords = _words.encode;
+    const fromWordsUnsafe = unsafeWrapper(fromWords);
+    function encode(prefix, words, limit = 90) {
+        astr('bech32.encode prefix', prefix);
+        if (isBytes(words))
+            words = Array.from(words);
+        anumArr('bech32.encode', words);
+        const plen = prefix.length;
+        if (plen === 0)
+            throw new TypeError(`Invalid prefix length ${plen}`);
+        const actualLength = plen + 7 + words.length;
+        if (limit !== false && actualLength > limit)
+            throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+        const lowered = prefix.toLowerCase();
+        const sum = bechChecksum(lowered, words, ENCODING_CONST);
+        return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+    }
+    function decode(str, limit = 90) {
+        astr('bech32.decode input', str);
+        const slen = str.length;
+        if (slen < 8 || (limit !== false && slen > limit))
+            throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+        // don't allow mixed case
+        const lowered = str.toLowerCase();
+        if (str !== lowered && str !== str.toUpperCase())
+            throw new Error(`String must be lowercase or uppercase`);
+        const sepIndex = lowered.lastIndexOf('1');
+        if (sepIndex === 0 || sepIndex === -1)
+            throw new Error(`Letter "1" must be present between prefix and data only`);
+        const prefix = lowered.slice(0, sepIndex);
+        const data = lowered.slice(sepIndex + 1);
+        if (data.length < 6)
+            throw new Error('Data must be at least 6 characters long');
+        const words = BECH_ALPHABET.decode(data).slice(0, -6);
+        const sum = bechChecksum(prefix, words, ENCODING_CONST);
+        if (!data.endsWith(sum))
+            throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+        return { prefix, words };
+    }
+    const decodeUnsafe = unsafeWrapper(decode);
+    function decodeToBytes(str) {
+        const { prefix, words } = decode(str, false);
+        return { prefix, words, bytes: fromWords(words) };
+    }
+    function encodeFromBytes(prefix, bytes) {
+        return encode(prefix, toWords(bytes));
+    }
+    return {
+        encode,
+        decode,
+        encodeFromBytes,
+        decodeToBytes,
+        decodeUnsafe,
+        fromWords,
+        fromWordsUnsafe,
+        toWords,
+    };
+}
+/**
+ * bech32 from BIP 173. Operates on words.
+ * For high-level, check out scure-btc-signer:
+ * https://github.com/paulmillr/scure-btc-signer.
+ */
+const bech32 = genBech32('bech32');
+
+//#region src/b58.ts
+const toBase58 = (buffer) => base58.encode(buffer);
+const fromBase58 = (str) => base58.decode(str);
+
+//#region src/b64.ts
+function fromBase64(base64String) {
+	return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+}
+const CHUNK_SIZE = 8192;
+function toBase64(bytes) {
+	if (bytes.length < CHUNK_SIZE) return btoa(String.fromCharCode(...bytes));
+	let output = "";
+	for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+		const chunk = bytes.slice(i, i + CHUNK_SIZE);
+		output += String.fromCharCode(...chunk);
+	}
+	return btoa(output);
+}
+
+//#region src/hex.ts
+function fromHex(hexStr) {
+	const normalized = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+	const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
+	const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+	if (intArr.length !== padded.length / 2) throw new Error(`Invalid hex string ${hexStr}`);
+	return Uint8Array.from(intArr);
+}
+function toHex(bytes) {
+	return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+
+//#region src/utils.ts
+/**
+* Encode data with either `hex` or `base64`.
+*
+* @param {Uint8Array} data Data to encode.
+* @param {String} encoding Encoding to use: base64 or hex
+* @returns {String} Encoded value.
+*/
+function encodeStr(data, encoding) {
+	switch (encoding) {
+		case "base58": return toBase58(data);
+		case "base64": return toBase64(data);
+		case "hex": return toHex(data);
+		default: throw new Error("Unsupported encoding, supported values are: base64, hex");
+	}
+}
+function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
+	const [left, right] = genericSeparators;
+	const tok = [];
+	let word = "";
+	let nestedAngleBrackets = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str[i];
+		if (char === left) nestedAngleBrackets++;
+		if (char === right) nestedAngleBrackets--;
+		if (nestedAngleBrackets === 0 && char === ",") {
+			tok.push(word.trim());
+			word = "";
+			continue;
+		}
+		word += char;
+	}
+	tok.push(word.trim());
+	return tok;
+}
+
+//#region src/writer.ts
+/**
+* Class used to write BCS data into a buffer. Initializer requires
+* some size of a buffer to init; default value for this buffer is 1KB.
+*
+* Most methods are chainable, so it is possible to write them in one go.
+*
+* @example
+* let serialized = new BcsWriter()
+*   .write8(10)
+*   .write32(1000000)
+*   .write64(10000001000000)
+*   .hex();
+*/
+/**
+* Set of methods that allows data encoding/decoding as standalone
+* BCS value or a part of a composed structure/vector.
+*/
+var BcsWriter = class {
+	constructor({ initialSize = 1024, maxSize = Infinity, allocateSize = 1024 } = {}) {
+		this.bytePosition = 0;
+		this.size = initialSize;
+		this.maxSize = maxSize;
+		this.allocateSize = allocateSize;
+		this.dataView = new DataView(new ArrayBuffer(initialSize));
+	}
+	ensureSizeOrGrow(bytes) {
+		const requiredSize = this.bytePosition + bytes;
+		if (requiredSize > this.size) {
+			const nextSize = Math.min(this.maxSize, Math.max(this.size + requiredSize, this.size + this.allocateSize));
+			if (requiredSize > nextSize) throw new Error(`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`);
+			this.size = nextSize;
+			const nextBuffer = new ArrayBuffer(this.size);
+			new Uint8Array(nextBuffer).set(new Uint8Array(this.dataView.buffer));
+			this.dataView = new DataView(nextBuffer);
+		}
+	}
+	/**
+	* Shift current cursor position by `bytes`.
+	*
+	* @param {Number} bytes Number of bytes to
+	* @returns {this} Self for possible chaining.
+	*/
+	shift(bytes) {
+		this.bytePosition += bytes;
+		return this;
+	}
+	/**
+	* Write a U8 value into a buffer and shift cursor position by 1.
+	* @param {Number} value Value to write.
+	* @returns {this}
+	*/
+	write8(value) {
+		this.ensureSizeOrGrow(1);
+		this.dataView.setUint8(this.bytePosition, Number(value));
+		return this.shift(1);
+	}
+	/**
+	* Write a U8 value into a buffer and shift cursor position by 1.
+	* @param {Number} value Value to write.
+	* @returns {this}
+	*/
+	writeBytes(bytes) {
+		this.ensureSizeOrGrow(bytes.length);
+		for (let i = 0; i < bytes.length; i++) this.dataView.setUint8(this.bytePosition + i, bytes[i]);
+		return this.shift(bytes.length);
+	}
+	/**
+	* Write a U16 value into a buffer and shift cursor position by 2.
+	* @param {Number} value Value to write.
+	* @returns {this}
+	*/
+	write16(value) {
+		this.ensureSizeOrGrow(2);
+		this.dataView.setUint16(this.bytePosition, Number(value), true);
+		return this.shift(2);
+	}
+	/**
+	* Write a U32 value into a buffer and shift cursor position by 4.
+	* @param {Number} value Value to write.
+	* @returns {this}
+	*/
+	write32(value) {
+		this.ensureSizeOrGrow(4);
+		this.dataView.setUint32(this.bytePosition, Number(value), true);
+		return this.shift(4);
+	}
+	/**
+	* Write a U64 value into a buffer and shift cursor position by 8.
+	* @param {bigint} value Value to write.
+	* @returns {this}
+	*/
+	write64(value) {
+		toLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));
+		return this;
+	}
+	/**
+	* Write a U128 value into a buffer and shift cursor position by 16.
+	*
+	* @param {bigint} value Value to write.
+	* @returns {this}
+	*/
+	write128(value) {
+		toLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));
+		return this;
+	}
+	/**
+	* Write a U256 value into a buffer and shift cursor position by 16.
+	*
+	* @param {bigint} value Value to write.
+	* @returns {this}
+	*/
+	write256(value) {
+		toLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));
+		return this;
+	}
+	/**
+	* Write a ULEB value into a buffer and shift cursor position by number of bytes
+	* written.
+	* @param {Number} value Value to write.
+	* @returns {this}
+	*/
+	writeULEB(value) {
+		ulebEncode(value).forEach((el) => this.write8(el));
+		return this;
+	}
+	/**
+	* Write a vector into a buffer by first writing the vector length and then calling
+	* a callback on each passed value.
+	*
+	* @param {Array<Any>} vector Array of elements to write.
+	* @param {WriteVecCb} cb Callback to call on each element of the vector.
+	* @returns {this}
+	*/
+	writeVec(vector, cb) {
+		this.writeULEB(vector.length);
+		Array.from(vector).forEach((el, i) => cb(this, el, i, vector.length));
+		return this;
+	}
+	/**
+	* Adds support for iterations over the object.
+	* @returns {Uint8Array}
+	*/
+	*[Symbol.iterator]() {
+		for (let i = 0; i < this.bytePosition; i++) yield this.dataView.getUint8(i);
+		return this.toBytes();
+	}
+	/**
+	* Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+	* @returns {Uint8Array} Resulting bcs.
+	*/
+	toBytes() {
+		return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+	}
+	/**
+	* Represent data as 'hex' or 'base64'
+	* @param encoding Encoding to use: 'base64' or 'hex'
+	*/
+	toString(encoding) {
+		return encodeStr(this.toBytes(), encoding);
+	}
+};
+function toLittleEndian(bigint, size) {
+	const result = new Uint8Array(size);
+	let i = 0;
+	while (bigint > 0) {
+		result[i] = Number(bigint % BigInt(256));
+		bigint = bigint / BigInt(256);
+		i += 1;
+	}
+	return result;
+}
+
+//#region src/bcs-type.ts
+var BcsType = class BcsType {
+	#write;
+	#serialize;
+	constructor(options) {
+		this.name = options.name;
+		this.read = options.read;
+		this.serializedSize = options.serializedSize ?? (() => null);
+		this.#write = options.write;
+		this.#serialize = options.serialize ?? ((value, options$1) => {
+			const writer = new BcsWriter({
+				initialSize: this.serializedSize(value) ?? void 0,
+				...options$1
+			});
+			this.#write(value, writer);
+			return writer.toBytes();
+		});
+		this.validate = options.validate ?? (() => {});
+	}
+	write(value, writer) {
+		this.validate(value);
+		this.#write(value, writer);
+	}
+	serialize(value, options) {
+		this.validate(value);
+		return new SerializedBcs(this, this.#serialize(value, options));
+	}
+	parse(bytes) {
+		const reader = new BcsReader(bytes);
+		return this.read(reader);
+	}
+	fromHex(hex) {
+		return this.parse(fromHex(hex));
+	}
+	fromBase58(b64) {
+		return this.parse(fromBase58(b64));
+	}
+	fromBase64(b64) {
+		return this.parse(fromBase64(b64));
+	}
+	transform({ name, input, output, validate }) {
+		return new BcsType({
+			name: name ?? this.name,
+			read: (reader) => output ? output(this.read(reader)) : this.read(reader),
+			write: (value, writer) => this.#write(input ? input(value) : value, writer),
+			serializedSize: (value) => this.serializedSize(input ? input(value) : value),
+			serialize: (value, options) => this.#serialize(input ? input(value) : value, options),
+			validate: (value) => {
+				validate?.(value);
+				this.validate(input ? input(value) : value);
+			}
+		});
+	}
+};
+const SERIALIZED_BCS_BRAND = Symbol.for("@mysten/serialized-bcs");
+var SerializedBcs = class {
+	#schema;
+	#bytes;
+	get [SERIALIZED_BCS_BRAND]() {
+		return true;
+	}
+	constructor(schema, bytes) {
+		this.#schema = schema;
+		this.#bytes = bytes;
+	}
+	toBytes() {
+		return this.#bytes;
+	}
+	toHex() {
+		return toHex(this.#bytes);
+	}
+	toBase64() {
+		return toBase64(this.#bytes);
+	}
+	toBase58() {
+		return toBase58(this.#bytes);
+	}
+	parse() {
+		return this.#schema.parse(this.#bytes);
+	}
+};
+function fixedSizeBcsType({ size, ...options }) {
+	return new BcsType({
+		...options,
+		serializedSize: () => size
+	});
+}
+function uIntBcsType({ readMethod, writeMethod, ...options }) {
+	return fixedSizeBcsType({
+		...options,
+		read: (reader) => reader[readMethod](),
+		write: (value, writer) => writer[writeMethod](value),
+		validate: (value) => {
+			if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+			options.validate?.(value);
+		}
+	});
+}
+function bigUIntBcsType({ readMethod, writeMethod, ...options }) {
+	return fixedSizeBcsType({
+		...options,
+		read: (reader) => reader[readMethod](),
+		write: (value, writer) => writer[writeMethod](BigInt(value)),
+		validate: (val) => {
+			const value = BigInt(val);
+			if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+			options.validate?.(value);
+		}
+	});
+}
+function dynamicSizeBcsType({ serialize, ...options }) {
+	const type = new BcsType({
+		...options,
+		serialize,
+		write: (value, writer) => {
+			for (const byte of type.serialize(value).toBytes()) writer.write8(byte);
+		}
+	});
+	return type;
+}
+function stringLikeBcsType({ toBytes, fromBytes, ...options }) {
+	return new BcsType({
+		...options,
+		read: (reader) => {
+			const length = reader.readULEB();
+			return fromBytes(reader.readBytes(length));
+		},
+		write: (hex, writer) => {
+			const bytes = toBytes(hex);
+			writer.writeULEB(bytes.length);
+			for (let i = 0; i < bytes.length; i++) writer.write8(bytes[i]);
+		},
+		serialize: (value) => {
+			const bytes = toBytes(value);
+			const size = ulebEncode(bytes.length);
+			const result = new Uint8Array(size.length + bytes.length);
+			result.set(size, 0);
+			result.set(bytes, size.length);
+			return result;
+		},
+		validate: (value) => {
+			if (typeof value !== "string") throw new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);
+			options.validate?.(value);
+		}
+	});
+}
+function lazyBcsType(cb) {
+	let lazyType = null;
+	function getType() {
+		if (!lazyType) lazyType = cb();
+		return lazyType;
+	}
+	return new BcsType({
+		name: "lazy",
+		read: (data) => getType().read(data),
+		serializedSize: (value) => getType().serializedSize(value),
+		write: (value, writer) => getType().write(value, writer),
+		serialize: (value, options) => getType().serialize(value, options).toBytes()
+	});
+}
+var BcsStruct = class extends BcsType {
+	constructor({ name, fields, ...options }) {
+		const canonicalOrder = Object.entries(fields);
+		super({
+			name,
+			serializedSize: (values) => {
+				let total = 0;
+				for (const [field, type] of canonicalOrder) {
+					const size = type.serializedSize(values[field]);
+					if (size == null) return null;
+					total += size;
+				}
+				return total;
+			},
+			read: (reader) => {
+				const result = {};
+				for (const [field, type] of canonicalOrder) result[field] = type.read(reader);
+				return result;
+			},
+			write: (value, writer) => {
+				for (const [field, type] of canonicalOrder) type.write(value[field], writer);
+			},
+			...options,
+			validate: (value) => {
+				options?.validate?.(value);
+				if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+			}
+		});
+	}
+};
+var BcsEnum = class extends BcsType {
+	constructor({ fields, ...options }) {
+		const canonicalOrder = Object.entries(fields);
+		super({
+			read: (reader) => {
+				const index = reader.readULEB();
+				const enumEntry = canonicalOrder[index];
+				if (!enumEntry) throw new TypeError(`Unknown value ${index} for enum ${options.name}`);
+				const [kind, type] = enumEntry;
+				return {
+					[kind]: type?.read(reader) ?? true,
+					$kind: kind
+				};
+			},
+			write: (value, writer) => {
+				const [name, val] = Object.entries(value).filter(([name$1]) => Object.hasOwn(fields, name$1))[0];
+				for (let i = 0; i < canonicalOrder.length; i++) {
+					const [optionName, optionType] = canonicalOrder[i];
+					if (optionName === name) {
+						writer.writeULEB(i);
+						optionType?.write(val, writer);
+						return;
+					}
+				}
+			},
+			...options,
+			validate: (value) => {
+				options?.validate?.(value);
+				if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+				const keys = Object.keys(value).filter((k) => value[k] !== void 0 && Object.hasOwn(fields, k));
+				if (keys.length !== 1) throw new TypeError(`Expected object with one key, but found ${keys.length} for type ${options.name}}`);
+				const [variant] = keys;
+				if (!Object.hasOwn(fields, variant)) throw new TypeError(`Invalid enum variant ${variant}`);
+			}
+		});
+	}
+};
+var BcsTuple = class extends BcsType {
+	constructor({ fields, name, ...options }) {
+		super({
+			name: name ?? `(${fields.map((t) => t.name).join(", ")})`,
+			serializedSize: (values) => {
+				let total = 0;
+				for (let i = 0; i < fields.length; i++) {
+					const size = fields[i].serializedSize(values[i]);
+					if (size == null) return null;
+					total += size;
+				}
+				return total;
+			},
+			read: (reader) => {
+				const result = [];
+				for (const field of fields) result.push(field.read(reader));
+				return result;
+			},
+			write: (value, writer) => {
+				for (let i = 0; i < fields.length; i++) fields[i].write(value[i], writer);
+			},
+			...options,
+			validate: (value) => {
+				options?.validate?.(value);
+				if (!Array.isArray(value)) throw new TypeError(`Expected array, found ${typeof value}`);
+				if (value.length !== fields.length) throw new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);
+			}
+		});
+	}
+};
+
+//#region src/bcs.ts
+function fixedArray(size, type, options) {
+	return new BcsType({
+		read: (reader) => {
+			const result = new Array(size);
+			for (let i = 0; i < size; i++) result[i] = type.read(reader);
+			return result;
+		},
+		write: (value, writer) => {
+			for (const item of value) type.write(item, writer);
+		},
+		...options,
+		name: options?.name ?? `${type.name}[${size}]`,
+		validate: (value) => {
+			options?.validate?.(value);
+			if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+			if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+		}
+	});
+}
+function option(type) {
+	return bcs.enum(`Option<${type.name}>`, {
+		None: null,
+		Some: type
+	}).transform({
+		input: (value) => {
+			if (value == null) return { None: true };
+			return { Some: value };
+		},
+		output: (value) => {
+			if (value.$kind === "Some") return value.Some;
+			return null;
+		}
+	});
+}
+function vector(type, options) {
+	return new BcsType({
+		read: (reader) => {
+			const length = reader.readULEB();
+			const result = new Array(length);
+			for (let i = 0; i < length; i++) result[i] = type.read(reader);
+			return result;
+		},
+		write: (value, writer) => {
+			writer.writeULEB(value.length);
+			for (const item of value) type.write(item, writer);
+		},
+		...options,
+		name: options?.name ?? `vector<${type.name}>`,
+		validate: (value) => {
+			options?.validate?.(value);
+			if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+		}
+	});
+}
+/**
+* Compares two byte arrays using lexicographic ordering.
+* This matches Rust's Ord implementation for Vec<u8>/[u8] which is used for BTreeMap key ordering.
+* Comparison is done byte-by-byte first, then by length if all compared bytes are equal.
+*/
+function compareBcsBytes(a, b) {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function map(keyType, valueType) {
+	return new BcsType({
+		name: `Map<${keyType.name}, ${valueType.name}>`,
+		read: (reader) => {
+			const length = reader.readULEB();
+			const result = /* @__PURE__ */ new Map();
+			for (let i = 0; i < length; i++) result.set(keyType.read(reader), valueType.read(reader));
+			return result;
+		},
+		write: (value, writer) => {
+			const entries = [...value.entries()].map(([key, val]) => [keyType.serialize(key).toBytes(), val]);
+			entries.sort(([a], [b]) => compareBcsBytes(a, b));
+			writer.writeULEB(entries.length);
+			for (const [keyBytes, val] of entries) {
+				writer.writeBytes(keyBytes);
+				valueType.write(val, writer);
+			}
+		}
+	});
+}
+const bcs = {
+	u8(options) {
+		return uIntBcsType({
+			readMethod: "read8",
+			writeMethod: "write8",
+			size: 1,
+			maxValue: 2 ** 8 - 1,
+			...options,
+			name: options?.name ?? "u8"
+		});
+	},
+	u16(options) {
+		return uIntBcsType({
+			readMethod: "read16",
+			writeMethod: "write16",
+			size: 2,
+			maxValue: 2 ** 16 - 1,
+			...options,
+			name: options?.name ?? "u16"
+		});
+	},
+	u32(options) {
+		return uIntBcsType({
+			readMethod: "read32",
+			writeMethod: "write32",
+			size: 4,
+			maxValue: 2 ** 32 - 1,
+			...options,
+			name: options?.name ?? "u32"
+		});
+	},
+	u64(options) {
+		return bigUIntBcsType({
+			readMethod: "read64",
+			writeMethod: "write64",
+			size: 8,
+			maxValue: 2n ** 64n - 1n,
+			...options,
+			name: options?.name ?? "u64"
+		});
+	},
+	u128(options) {
+		return bigUIntBcsType({
+			readMethod: "read128",
+			writeMethod: "write128",
+			size: 16,
+			maxValue: 2n ** 128n - 1n,
+			...options,
+			name: options?.name ?? "u128"
+		});
+	},
+	u256(options) {
+		return bigUIntBcsType({
+			readMethod: "read256",
+			writeMethod: "write256",
+			size: 32,
+			maxValue: 2n ** 256n - 1n,
+			...options,
+			name: options?.name ?? "u256"
+		});
+	},
+	bool(options) {
+		return fixedSizeBcsType({
+			size: 1,
+			read: (reader) => reader.read8() === 1,
+			write: (value, writer) => writer.write8(value ? 1 : 0),
+			...options,
+			name: options?.name ?? "bool",
+			validate: (value) => {
+				options?.validate?.(value);
+				if (typeof value !== "boolean") throw new TypeError(`Expected boolean, found ${typeof value}`);
+			}
+		});
+	},
+	uleb128(options) {
+		return dynamicSizeBcsType({
+			read: (reader) => reader.readULEB(),
+			serialize: (value) => {
+				return Uint8Array.from(ulebEncode(value));
+			},
+			...options,
+			name: options?.name ?? "uleb128"
+		});
+	},
+	bytes(size, options) {
+		return fixedSizeBcsType({
+			size,
+			read: (reader) => reader.readBytes(size),
+			write: (value, writer) => {
+				writer.writeBytes(new Uint8Array(value));
+			},
+			...options,
+			name: options?.name ?? `bytes[${size}]`,
+			validate: (value) => {
+				options?.validate?.(value);
+				if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+				if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+			}
+		});
+	},
+	byteVector(options) {
+		return new BcsType({
+			read: (reader) => {
+				const length = reader.readULEB();
+				return reader.readBytes(length);
+			},
+			write: (value, writer) => {
+				const array = new Uint8Array(value);
+				writer.writeULEB(array.length);
+				writer.writeBytes(array);
+			},
+			...options,
+			name: options?.name ?? "vector<u8>",
+			serializedSize: (value) => {
+				const length = "length" in value ? value.length : null;
+				return length == null ? null : ulebEncode(length).length + length;
+			},
+			validate: (value) => {
+				options?.validate?.(value);
+				if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+			}
+		});
+	},
+	string(options) {
+		return stringLikeBcsType({
+			toBytes: (value) => new TextEncoder().encode(value),
+			fromBytes: (bytes) => new TextDecoder().decode(bytes),
+			...options,
+			name: options?.name ?? "string"
+		});
+	},
+	fixedArray,
+	option,
+	vector,
+	tuple(fields, options) {
+		return new BcsTuple({
+			fields,
+			...options
+		});
+	},
+	struct(name, fields, options) {
+		return new BcsStruct({
+			name,
+			fields,
+			...options
+		});
+	},
+	enum(name, fields, options) {
+		return new BcsEnum({
+			name,
+			fields,
+			...options
+		});
+	},
+	map,
+	lazy(cb) {
+		return lazyBcsType(cb);
+	}
+};
+
+const SUI_ADDRESS_LENGTH = 32;
+function isValidSuiAddress(value) {
+	return isHex(value) && getHexByteLength(value) === SUI_ADDRESS_LENGTH;
+}
+/**
+* Perform the following operations:
+* 1. Make the address lower case
+* 2. Prepend `0x` if the string does not start with `0x`.
+* 3. Add more zeros if the length of the address(excluding `0x`) is less than `SUI_ADDRESS_LENGTH`
+*
+* WARNING: if the address value itself starts with `0x`, e.g., `0x0x`, the default behavior
+* is to treat the first `0x` not as part of the address. The default behavior can be overridden by
+* setting `forceAdd0x` to true
+*
+*/
+function normalizeSuiAddress(value, forceAdd0x = false) {
+	let address = value.toLowerCase();
+	if (!forceAdd0x && address.startsWith("0x")) address = address.slice(2);
+	return `0x${address.padStart(SUI_ADDRESS_LENGTH * 2, "0")}`;
+}
+function isHex(value) {
+	return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;
+}
+function getHexByteLength(value) {
+	return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;
+}
+
+//#region src/bcs/type-tag-serializer.ts
+const VECTOR_REGEX = /^vector<(.+)>$/;
+const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+var TypeTagSerializer = class TypeTagSerializer {
+	static parseFromStr(str, normalizeAddress = false) {
+		if (str === "address") return { address: null };
+		else if (str === "bool") return { bool: null };
+		else if (str === "u8") return { u8: null };
+		else if (str === "u16") return { u16: null };
+		else if (str === "u32") return { u32: null };
+		else if (str === "u64") return { u64: null };
+		else if (str === "u128") return { u128: null };
+		else if (str === "u256") return { u256: null };
+		else if (str === "signer") return { signer: null };
+		const vectorMatch = str.match(VECTOR_REGEX);
+		if (vectorMatch) return { vector: TypeTagSerializer.parseFromStr(vectorMatch[1], normalizeAddress) };
+		const structMatch = str.match(STRUCT_REGEX);
+		if (structMatch) return { struct: {
+			address: normalizeAddress ? normalizeSuiAddress(structMatch[1]) : structMatch[1],
+			module: structMatch[2],
+			name: structMatch[3],
+			typeParams: structMatch[5] === void 0 ? [] : TypeTagSerializer.parseStructTypeArgs(structMatch[5], normalizeAddress)
+		} };
+		throw new Error(`Encountered unexpected token when parsing type args for ${str}`);
+	}
+	static parseStructTypeArgs(str, normalizeAddress = false) {
+		return splitGenericParameters(str).map((tok) => TypeTagSerializer.parseFromStr(tok, normalizeAddress));
+	}
+	static tagToString(tag) {
+		if ("bool" in tag) return "bool";
+		if ("u8" in tag) return "u8";
+		if ("u16" in tag) return "u16";
+		if ("u32" in tag) return "u32";
+		if ("u64" in tag) return "u64";
+		if ("u128" in tag) return "u128";
+		if ("u256" in tag) return "u256";
+		if ("address" in tag) return "address";
+		if ("signer" in tag) return "signer";
+		if ("vector" in tag) return `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;
+		if ("struct" in tag) {
+			const struct = tag.struct;
+			const typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(", ");
+			return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ""}`;
+		}
+		throw new Error("Invalid TypeTag");
+	}
+};
+
+//#region src/bcs/bcs.ts
+function unsafe_u64(options) {
+	return bcs.u64({
+		name: "unsafe_u64",
+		...options
+	}).transform({
+		input: (val) => val,
+		output: (val) => Number(val)
+	});
+}
+function optionEnum(type) {
+	return bcs.enum("Option", {
+		None: null,
+		Some: type
+	});
+}
+const Address = bcs.bytes(SUI_ADDRESS_LENGTH).transform({
+	validate: (val) => {
+		const address = typeof val === "string" ? val : toHex(val);
+		if (!address || !isValidSuiAddress(normalizeSuiAddress(address))) throw new Error(`Invalid Sui address ${address}`);
+	},
+	input: (val) => typeof val === "string" ? fromHex(normalizeSuiAddress(val)) : val,
+	output: (val) => normalizeSuiAddress(toHex(val))
+});
+const ObjectDigest = bcs.byteVector().transform({
+	name: "ObjectDigest",
+	input: (value) => fromBase58(value),
+	output: (value) => toBase58(new Uint8Array(value)),
+	validate: (value) => {
+		if (fromBase58(value).length !== 32) throw new Error("ObjectDigest must be 32 bytes");
+	}
+});
+const SuiObjectRef = bcs.struct("SuiObjectRef", {
+	objectId: Address,
+	version: bcs.u64(),
+	digest: ObjectDigest
+});
+const SharedObjectRef = bcs.struct("SharedObjectRef", {
+	objectId: Address,
+	initialSharedVersion: bcs.u64(),
+	mutable: bcs.bool()
+});
+const ObjectArg = bcs.enum("ObjectArg", {
+	ImmOrOwnedObject: SuiObjectRef,
+	SharedObject: SharedObjectRef,
+	Receiving: SuiObjectRef
+});
+const Owner = bcs.enum("Owner", {
+	AddressOwner: Address,
+	ObjectOwner: Address,
+	Shared: bcs.struct("Shared", { initialSharedVersion: bcs.u64() }),
+	Immutable: null,
+	ConsensusAddressOwner: bcs.struct("ConsensusAddressOwner", {
+		startVersion: bcs.u64(),
+		owner: Address
+	})
+});
+const Reservation = bcs.enum("Reservation", { MaxAmountU64: bcs.u64() });
+const WithdrawalType = bcs.enum("WithdrawalType", { Balance: bcs.lazy(() => TypeTag) });
+const WithdrawFrom = bcs.enum("WithdrawFrom", {
+	Sender: null,
+	Sponsor: null
+});
+const FundsWithdrawal = bcs.struct("FundsWithdrawal", {
+	reservation: Reservation,
+	typeArg: WithdrawalType,
+	withdrawFrom: WithdrawFrom
+});
+const CallArg = bcs.enum("CallArg", {
+	Pure: bcs.struct("Pure", { bytes: bcs.byteVector().transform({
+		input: (val) => typeof val === "string" ? fromBase64(val) : val,
+		output: (val) => toBase64(new Uint8Array(val))
+	}) }),
+	Object: ObjectArg,
+	FundsWithdrawal
+});
+const InnerTypeTag = bcs.enum("TypeTag", {
+	bool: null,
+	u8: null,
+	u64: null,
+	u128: null,
+	address: null,
+	signer: null,
+	vector: bcs.lazy(() => InnerTypeTag),
+	struct: bcs.lazy(() => StructTag),
+	u16: null,
+	u32: null,
+	u256: null
+});
+const TypeTag = InnerTypeTag.transform({
+	input: (typeTag) => typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
+	output: (typeTag) => TypeTagSerializer.tagToString(typeTag)
+});
+const Argument = bcs.enum("Argument", {
+	GasCoin: null,
+	Input: bcs.u16(),
+	Result: bcs.u16(),
+	NestedResult: bcs.tuple([bcs.u16(), bcs.u16()])
+});
+const ProgrammableMoveCall = bcs.struct("ProgrammableMoveCall", {
+	package: Address,
+	module: bcs.string(),
+	function: bcs.string(),
+	typeArguments: bcs.vector(TypeTag),
+	arguments: bcs.vector(Argument)
+});
+const Command = bcs.enum("Command", {
+	MoveCall: ProgrammableMoveCall,
+	TransferObjects: bcs.struct("TransferObjects", {
+		objects: bcs.vector(Argument),
+		address: Argument
+	}),
+	SplitCoins: bcs.struct("SplitCoins", {
+		coin: Argument,
+		amounts: bcs.vector(Argument)
+	}),
+	MergeCoins: bcs.struct("MergeCoins", {
+		destination: Argument,
+		sources: bcs.vector(Argument)
+	}),
+	Publish: bcs.struct("Publish", {
+		modules: bcs.vector(bcs.byteVector().transform({
+			input: (val) => typeof val === "string" ? fromBase64(val) : val,
+			output: (val) => toBase64(new Uint8Array(val))
+		})),
+		dependencies: bcs.vector(Address)
+	}),
+	MakeMoveVec: bcs.struct("MakeMoveVec", {
+		type: optionEnum(TypeTag).transform({
+			input: (val) => val === null ? { None: true } : { Some: val },
+			output: (val) => val.Some ?? null
+		}),
+		elements: bcs.vector(Argument)
+	}),
+	Upgrade: bcs.struct("Upgrade", {
+		modules: bcs.vector(bcs.byteVector().transform({
+			input: (val) => typeof val === "string" ? fromBase64(val) : val,
+			output: (val) => toBase64(new Uint8Array(val))
+		})),
+		dependencies: bcs.vector(Address),
+		package: Address,
+		ticket: Argument
+	})
+});
+const ProgrammableTransaction = bcs.struct("ProgrammableTransaction", {
+	inputs: bcs.vector(CallArg),
+	commands: bcs.vector(Command)
+});
+const TransactionKind = bcs.enum("TransactionKind", {
+	ProgrammableTransaction,
+	ChangeEpoch: null,
+	Genesis: null,
+	ConsensusCommitPrologue: null
+});
+const ValidDuring = bcs.struct("ValidDuring", {
+	minEpoch: bcs.option(bcs.u64()),
+	maxEpoch: bcs.option(bcs.u64()),
+	minTimestamp: bcs.option(bcs.u64()),
+	maxTimestamp: bcs.option(bcs.u64()),
+	chain: ObjectDigest,
+	nonce: bcs.u32()
+});
+const TransactionExpiration = bcs.enum("TransactionExpiration", {
+	None: null,
+	Epoch: unsafe_u64(),
+	ValidDuring
+});
+const StructTag = bcs.struct("StructTag", {
+	address: Address,
+	module: bcs.string(),
+	name: bcs.string(),
+	typeParams: bcs.vector(InnerTypeTag)
+});
+const GasData = bcs.struct("GasData", {
+	payment: bcs.vector(SuiObjectRef),
+	owner: Address,
+	price: bcs.u64(),
+	budget: bcs.u64()
+});
+const TransactionDataV1 = bcs.struct("TransactionDataV1", {
+	kind: TransactionKind,
+	sender: Address,
+	gasData: GasData,
+	expiration: TransactionExpiration
+});
+const TransactionData = bcs.enum("TransactionData", { V1: TransactionDataV1 });
+const IntentScope = bcs.enum("IntentScope", {
+	TransactionData: null,
+	TransactionEffects: null,
+	CheckpointSummary: null,
+	PersonalMessage: null
+});
+const IntentVersion = bcs.enum("IntentVersion", { V0: null });
+const AppId = bcs.enum("AppId", { Sui: null });
+const Intent = bcs.struct("Intent", {
+	scope: IntentScope,
+	version: IntentVersion,
+	appId: AppId
+});
+function IntentMessage(T) {
+	return bcs.struct(`IntentMessage<${T.name}>`, {
+		intent: Intent,
+		value: T
+	});
+}
+const CompressedSignature = bcs.enum("CompressedSignature", {
+	ED25519: bcs.bytes(64),
+	Secp256k1: bcs.bytes(64),
+	Secp256r1: bcs.bytes(64),
+	ZkLogin: bcs.byteVector(),
+	Passkey: bcs.byteVector()
+});
+const PublicKey$1 = bcs.enum("PublicKey", {
+	ED25519: bcs.bytes(32),
+	Secp256k1: bcs.bytes(33),
+	Secp256r1: bcs.bytes(33),
+	ZkLogin: bcs.byteVector(),
+	Passkey: bcs.bytes(33)
+});
+const MultiSigPkMap = bcs.struct("MultiSigPkMap", {
+	pubKey: PublicKey$1,
+	weight: bcs.u8()
+});
+const MultiSigPublicKey = bcs.struct("MultiSigPublicKey", {
+	pk_map: bcs.vector(MultiSigPkMap),
+	threshold: bcs.u16()
+});
+const MultiSig = bcs.struct("MultiSig", {
+	sigs: bcs.vector(CompressedSignature),
+	bitmap: bcs.u16(),
+	multisig_pk: MultiSigPublicKey
+});
+const base64String = bcs.byteVector().transform({
+	input: (val) => typeof val === "string" ? fromBase64(val) : val,
+	output: (val) => toBase64(new Uint8Array(val))
+});
+const SenderSignedTransaction = bcs.struct("SenderSignedTransaction", {
+	intentMessage: IntentMessage(TransactionData),
+	txSignatures: bcs.vector(base64String)
+});
+const SenderSignedData = bcs.vector(SenderSignedTransaction, { name: "SenderSignedData" });
+const PasskeyAuthenticator = bcs.struct("PasskeyAuthenticator", {
+	authenticatorData: bcs.byteVector(),
+	clientDataJson: bcs.string(),
+	userSignature: bcs.byteVector()
+});
+const MoveObjectType = bcs.enum("MoveObjectType", {
+	Other: StructTag,
+	GasCoin: null,
+	StakedSui: null,
+	Coin: TypeTag,
+	AccumulatorBalanceWrapper: null
+});
+const TypeOrigin = bcs.struct("TypeOrigin", {
+	moduleName: bcs.string(),
+	datatypeName: bcs.string(),
+	package: Address
+});
+const UpgradeInfo = bcs.struct("UpgradeInfo", {
+	upgradedId: Address,
+	upgradedVersion: bcs.u64()
+});
+const MovePackage = bcs.struct("MovePackage", {
+	id: Address,
+	version: bcs.u64(),
+	moduleMap: bcs.map(bcs.string(), bcs.byteVector()),
+	typeOriginTable: bcs.vector(TypeOrigin),
+	linkageTable: bcs.map(Address, UpgradeInfo)
+});
+const MoveObject = bcs.struct("MoveObject", {
+	type: MoveObjectType,
+	hasPublicTransfer: bcs.bool(),
+	version: bcs.u64(),
+	contents: bcs.byteVector()
+});
+const Data = bcs.enum("Data", {
+	Move: MoveObject,
+	Package: MovePackage
+});
+const ObjectInner = bcs.struct("ObjectInner", {
+	data: Data,
+	owner: Owner,
+	previousTransaction: ObjectDigest,
+	storageRebate: bcs.u64()
+});
+
+//#region src/bcs/effects.ts
+const PackageUpgradeError = bcs.enum("PackageUpgradeError", {
+	UnableToFetchPackage: bcs.struct("UnableToFetchPackage", { packageId: Address }),
+	NotAPackage: bcs.struct("NotAPackage", { objectId: Address }),
+	IncompatibleUpgrade: null,
+	DigestDoesNotMatch: bcs.struct("DigestDoesNotMatch", { digest: bcs.byteVector() }),
+	UnknownUpgradePolicy: bcs.struct("UnknownUpgradePolicy", { policy: bcs.u8() }),
+	PackageIDDoesNotMatch: bcs.struct("PackageIDDoesNotMatch", {
+		packageId: Address,
+		ticketId: Address
+	})
+});
+const ModuleId = bcs.struct("ModuleId", {
+	address: Address,
+	name: bcs.string()
+});
+const MoveLocation = bcs.struct("MoveLocation", {
+	module: ModuleId,
+	function: bcs.u16(),
+	instruction: bcs.u16(),
+	functionName: bcs.option(bcs.string())
+});
+const CommandArgumentError = bcs.enum("CommandArgumentError", {
+	TypeMismatch: null,
+	InvalidBCSBytes: null,
+	InvalidUsageOfPureArg: null,
+	InvalidArgumentToPrivateEntryFunction: null,
+	IndexOutOfBounds: bcs.struct("IndexOutOfBounds", { idx: bcs.u16() }),
+	SecondaryIndexOutOfBounds: bcs.struct("SecondaryIndexOutOfBounds", {
+		resultIdx: bcs.u16(),
+		secondaryIdx: bcs.u16()
+	}),
+	InvalidResultArity: bcs.struct("InvalidResultArity", { resultIdx: bcs.u16() }),
+	InvalidGasCoinUsage: null,
+	InvalidValueUsage: null,
+	InvalidObjectByValue: null,
+	InvalidObjectByMutRef: null,
+	SharedObjectOperationNotAllowed: null,
+	InvalidArgumentArity: null,
+	InvalidTransferObject: null,
+	InvalidMakeMoveVecNonObjectArgument: null,
+	ArgumentWithoutValue: null,
+	CannotMoveBorrowedValue: null,
+	CannotWriteToExtendedReference: null,
+	InvalidReferenceArgument: null
+});
+const TypeArgumentError = bcs.enum("TypeArgumentError", {
+	TypeNotFound: null,
+	ConstraintNotSatisfied: null
+});
+const ExecutionFailureStatus = bcs.enum("ExecutionFailureStatus", {
+	InsufficientGas: null,
+	InvalidGasObject: null,
+	InvariantViolation: null,
+	FeatureNotYetSupported: null,
+	MoveObjectTooBig: bcs.struct("MoveObjectTooBig", {
+		objectSize: bcs.u64(),
+		maxObjectSize: bcs.u64()
+	}),
+	MovePackageTooBig: bcs.struct("MovePackageTooBig", {
+		objectSize: bcs.u64(),
+		maxObjectSize: bcs.u64()
+	}),
+	CircularObjectOwnership: bcs.struct("CircularObjectOwnership", { object: Address }),
+	InsufficientCoinBalance: null,
+	CoinBalanceOverflow: null,
+	PublishErrorNonZeroAddress: null,
+	SuiMoveVerificationError: null,
+	MovePrimitiveRuntimeError: bcs.option(MoveLocation),
+	MoveAbort: bcs.tuple([MoveLocation, bcs.u64()]),
+	VMVerificationOrDeserializationError: null,
+	VMInvariantViolation: null,
+	FunctionNotFound: null,
+	ArityMismatch: null,
+	TypeArityMismatch: null,
+	NonEntryFunctionInvoked: null,
+	CommandArgumentError: bcs.struct("CommandArgumentError", {
+		argIdx: bcs.u16(),
+		kind: CommandArgumentError
+	}),
+	TypeArgumentError: bcs.struct("TypeArgumentError", {
+		argumentIdx: bcs.u16(),
+		kind: TypeArgumentError
+	}),
+	UnusedValueWithoutDrop: bcs.struct("UnusedValueWithoutDrop", {
+		resultIdx: bcs.u16(),
+		secondaryIdx: bcs.u16()
+	}),
+	InvalidPublicFunctionReturnType: bcs.struct("InvalidPublicFunctionReturnType", { idx: bcs.u16() }),
+	InvalidTransferObject: null,
+	EffectsTooLarge: bcs.struct("EffectsTooLarge", {
+		currentSize: bcs.u64(),
+		maxSize: bcs.u64()
+	}),
+	PublishUpgradeMissingDependency: null,
+	PublishUpgradeDependencyDowngrade: null,
+	PackageUpgradeError: bcs.struct("PackageUpgradeError", { upgradeError: PackageUpgradeError }),
+	WrittenObjectsTooLarge: bcs.struct("WrittenObjectsTooLarge", {
+		currentSize: bcs.u64(),
+		maxSize: bcs.u64()
+	}),
+	CertificateDenied: null,
+	SuiMoveVerificationTimedout: null,
+	SharedObjectOperationNotAllowed: null,
+	InputObjectDeleted: null,
+	ExecutionCancelledDueToSharedObjectCongestion: bcs.struct("ExecutionCancelledDueToSharedObjectCongestion", { congested_objects: bcs.vector(Address) }),
+	AddressDeniedForCoin: bcs.struct("AddressDeniedForCoin", {
+		address: Address,
+		coinType: bcs.string()
+	}),
+	CoinTypeGlobalPause: bcs.struct("CoinTypeGlobalPause", { coinType: bcs.string() }),
+	ExecutionCancelledDueToRandomnessUnavailable: null,
+	MoveVectorElemTooBig: bcs.struct("MoveVectorElemTooBig", {
+		valueSize: bcs.u64(),
+		maxScaledSize: bcs.u64()
+	}),
+	MoveRawValueTooBig: bcs.struct("MoveRawValueTooBig", {
+		valueSize: bcs.u64(),
+		maxScaledSize: bcs.u64()
+	}),
+	InvalidLinkage: null,
+	InsufficientBalanceForWithdraw: null,
+	NonExclusiveWriteInputObjectModified: bcs.struct("NonExclusiveWriteInputObjectModified", { id: Address })
+});
+const ExecutionStatus = bcs.enum("ExecutionStatus", {
+	Success: null,
+	Failure: bcs.struct("Failure", {
+		error: ExecutionFailureStatus,
+		command: bcs.option(bcs.u64())
+	})
+});
+const GasCostSummary = bcs.struct("GasCostSummary", {
+	computationCost: bcs.u64(),
+	storageCost: bcs.u64(),
+	storageRebate: bcs.u64(),
+	nonRefundableStorageFee: bcs.u64()
+});
+const TransactionEffectsV1 = bcs.struct("TransactionEffectsV1", {
+	status: ExecutionStatus,
+	executedEpoch: bcs.u64(),
+	gasUsed: GasCostSummary,
+	modifiedAtVersions: bcs.vector(bcs.tuple([Address, bcs.u64()])),
+	sharedObjects: bcs.vector(SuiObjectRef),
+	transactionDigest: ObjectDigest,
+	created: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+	mutated: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+	unwrapped: bcs.vector(bcs.tuple([SuiObjectRef, Owner])),
+	deleted: bcs.vector(SuiObjectRef),
+	unwrappedThenDeleted: bcs.vector(SuiObjectRef),
+	wrapped: bcs.vector(SuiObjectRef),
+	gasObject: bcs.tuple([SuiObjectRef, Owner]),
+	eventsDigest: bcs.option(ObjectDigest),
+	dependencies: bcs.vector(ObjectDigest)
+});
+const VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
+const ObjectIn = bcs.enum("ObjectIn", {
+	NotExist: null,
+	Exist: bcs.tuple([VersionDigest, Owner])
+});
+const AccumulatorAddress = bcs.struct("AccumulatorAddress", {
+	address: Address,
+	ty: TypeTag
+});
+const AccumulatorOperation = bcs.enum("AccumulatorOperation", {
+	Merge: null,
+	Split: null
+});
+const AccumulatorValue = bcs.enum("AccumulatorValue", {
+	Integer: bcs.u64(),
+	IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
+	EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest]))
+});
+const AccumulatorWriteV1 = bcs.struct("AccumulatorWriteV1", {
+	address: AccumulatorAddress,
+	operation: AccumulatorOperation,
+	value: AccumulatorValue
+});
+const ObjectOut = bcs.enum("ObjectOut", {
+	NotExist: null,
+	ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
+	PackageWrite: VersionDigest,
+	AccumulatorWriteV1
+});
+const IDOperation = bcs.enum("IDOperation", {
+	None: null,
+	Created: null,
+	Deleted: null
+});
+const EffectsObjectChange = bcs.struct("EffectsObjectChange", {
+	inputState: ObjectIn,
+	outputState: ObjectOut,
+	idOperation: IDOperation
+});
+const UnchangedConsensusKind = bcs.enum("UnchangedConsensusKind", {
+	ReadOnlyRoot: VersionDigest,
+	MutateConsensusStreamEnded: bcs.u64(),
+	ReadConsensusStreamEnded: bcs.u64(),
+	Cancelled: bcs.u64(),
+	PerEpochConfig: null
+});
+const TransactionEffectsV2 = bcs.struct("TransactionEffectsV2", {
+	status: ExecutionStatus,
+	executedEpoch: bcs.u64(),
+	gasUsed: GasCostSummary,
+	transactionDigest: ObjectDigest,
+	gasObjectIndex: bcs.option(bcs.u32()),
+	eventsDigest: bcs.option(ObjectDigest),
+	dependencies: bcs.vector(ObjectDigest),
+	lamportVersion: bcs.u64(),
+	changedObjects: bcs.vector(bcs.tuple([Address, EffectsObjectChange])),
+	unchangedConsensusObjects: bcs.vector(bcs.tuple([Address, UnchangedConsensusKind])),
+	auxDataDigest: bcs.option(ObjectDigest)
+});
+const TransactionEffects = bcs.enum("TransactionEffects", {
+	V1: TransactionEffectsV1,
+	V2: TransactionEffectsV2
+});
+
+//#region src/bcs/index.ts
+const suiBcs = {
+	...bcs,
+	U8: bcs.u8(),
+	U16: bcs.u16(),
+	U32: bcs.u32(),
+	U64: bcs.u64(),
+	U128: bcs.u128(),
+	U256: bcs.u256(),
+	ULEB128: bcs.uleb128(),
+	Bool: bcs.bool(),
+	String: bcs.string(),
+	Address,
+	AppId,
+	Argument,
+	CallArg,
+	Command,
+	CompressedSignature,
+	Data,
+	GasData,
+	Intent,
+	IntentMessage,
+	IntentScope,
+	IntentVersion,
+	MoveObject,
+	MoveObjectType,
+	MovePackage,
+	MultiSig,
+	MultiSigPkMap,
+	MultiSigPublicKey,
+	Object: ObjectInner,
+	ObjectArg,
+	ObjectDigest,
+	Owner,
+	PasskeyAuthenticator,
+	ProgrammableMoveCall,
+	ProgrammableTransaction,
+	PublicKey: PublicKey$1,
+	SenderSignedData,
+	SenderSignedTransaction,
+	SharedObjectRef,
+	StructTag,
+	SuiObjectRef,
+	TransactionData,
+	TransactionDataV1,
+	TransactionEffects,
+	TransactionExpiration,
+	TransactionKind,
+	TypeOrigin,
+	TypeTag,
+	UpgradeInfo
+};
+
+/**
+ * Internal helpers for blake hash.
+ * @module
+ */
+/**
+ * Internal blake variable.
+ * For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+ */
+// prettier-ignore
+const BSIGMA = /* @__PURE__ */ Uint8Array.from([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    // Blake1, unused in others
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+]);
+
+/**
+ * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+ * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+ * @module
+ */
+// Same as SHA512_IV, but swapped endianness: LE instead of BE. iv[1] is iv[0], etc.
+const B2B_IV = /* @__PURE__ */ Uint32Array.from([
+    0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+    0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
+]);
+// Temporary buffer
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+// Mixing function G splitted in two halfs
+function G1b(a, b, c, d, msg, x) {
+    // NOTE: V is LE here
+    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = add3L(Al, Bl, Xl);
+    Ah = add3H(ll, Ah, Bh, Xh);
+    Al = ll | 0;
+    // v[d] = rotr(v[d] ^ v[a], 32)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 24)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+function G2b(a, b, c, d, msg, x) {
+    // NOTE: V is LE here
+    const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
+    let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
+    let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
+    let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
+    let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
+    // v[a] = (v[a] + v[b] + x) | 0;
+    let ll = add3L(Al, Bl, Xl);
+    Ah = add3H(ll, Ah, Bh, Xh);
+    Al = ll | 0;
+    // v[d] = rotr(v[d] ^ v[a], 16)
+    ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+    ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+    // v[c] = (v[c] + v[d]) | 0;
+    ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+    // v[b] = rotr(v[b] ^ v[c], 63)
+    ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+    ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+    ((BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah));
+    ((BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh));
+    ((BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch));
+    ((BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh));
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+    anumber$1(keyLen);
+    if (outputLen < 0 || outputLen > keyLen)
+        throw new Error('outputLen bigger than keyLen');
+    const { key, salt, personalization } = opts;
+    if (key !== undefined && (key.length < 1 || key.length > keyLen))
+        throw new Error('"key" expected to be undefined or of length=1..' + keyLen);
+    if (salt !== undefined)
+        abytes(salt, saltLen, 'salt');
+    if (personalization !== undefined)
+        abytes(personalization, persLen, 'personalization');
+}
+/** Internal base class for BLAKE2. */
+class _BLAKE2 {
+    buffer;
+    buffer32;
+    finished = false;
+    destroyed = false;
+    length = 0;
+    pos = 0;
+    blockLen;
+    outputLen;
+    constructor(blockLen, outputLen) {
+        anumber$1(blockLen);
+        anumber$1(outputLen);
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.buffer = new Uint8Array(blockLen);
+        this.buffer32 = u32(this.buffer);
+    }
+    update(data) {
+        aexists(this);
+        abytes(data);
+        // Main difference with other hashes: there is flag for last block,
+        // so we cannot process current block before we know that there
+        // is the next one. This significantly complicates logic and reduces ability
+        // to do zero-copy processing
+        const { blockLen, buffer, buffer32 } = this;
+        const len = data.length;
+        const offset = data.byteOffset;
+        const buf = data.buffer;
+        for (let pos = 0; pos < len;) {
+            // If buffer is full and we still have input (don't process last block, same as blake2s)
+            if (this.pos === blockLen) {
+                swap32IfBE(buffer32);
+                this.compress(buffer32, 0, false);
+                swap32IfBE(buffer32);
+                this.pos = 0;
+            }
+            const take = Math.min(blockLen - this.pos, len - pos);
+            const dataOffset = offset + pos;
+            // full block && aligned to 4 bytes && not last in input
+            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                swap32IfBE(data32);
+                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                    this.length += blockLen;
+                    this.compress(data32, pos32, false);
+                }
+                swap32IfBE(data32);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            this.length += take;
+            pos += take;
+        }
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        const { pos, buffer32 } = this;
+        this.finished = true;
+        // Padding
+        clean(this.buffer.subarray(pos));
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, true);
+        swap32IfBE(buffer32);
+        const out32 = u32(out);
+        this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        const { buffer, length, finished, destroyed, outputLen, pos } = this;
+        to ||= new this.constructor({ dkLen: outputLen });
+        to.set(...this.get());
+        to.buffer.set(buffer);
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        // @ts-ignore
+        to.outputLen = outputLen;
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/** Internal blake2b hash class. */
+class _BLAKE2b extends _BLAKE2 {
+    // Same as SHA-512, but LE
+    v0l = B2B_IV[0] | 0;
+    v0h = B2B_IV[1] | 0;
+    v1l = B2B_IV[2] | 0;
+    v1h = B2B_IV[3] | 0;
+    v2l = B2B_IV[4] | 0;
+    v2h = B2B_IV[5] | 0;
+    v3l = B2B_IV[6] | 0;
+    v3h = B2B_IV[7] | 0;
+    v4l = B2B_IV[8] | 0;
+    v4h = B2B_IV[9] | 0;
+    v5l = B2B_IV[10] | 0;
+    v5h = B2B_IV[11] | 0;
+    v6l = B2B_IV[12] | 0;
+    v6h = B2B_IV[13] | 0;
+    v7l = B2B_IV[14] | 0;
+    v7h = B2B_IV[15] | 0;
+    constructor(opts = {}) {
+        const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+        super(128, olen);
+        checkBlake2Opts(olen, opts, 64, 16, 16);
+        let { key, personalization, salt } = opts;
+        let keyLength = 0;
+        if (key !== undefined) {
+            abytes(key, undefined, 'key');
+            keyLength = key.length;
+        }
+        this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+        if (salt !== undefined) {
+            abytes(salt, undefined, 'salt');
+            const slt = u32(salt);
+            this.v4l ^= swap8IfBE(slt[0]);
+            this.v4h ^= swap8IfBE(slt[1]);
+            this.v5l ^= swap8IfBE(slt[2]);
+            this.v5h ^= swap8IfBE(slt[3]);
+        }
+        if (personalization !== undefined) {
+            abytes(personalization, undefined, 'personalization');
+            const pers = u32(personalization);
+            this.v6l ^= swap8IfBE(pers[0]);
+            this.v6h ^= swap8IfBE(pers[1]);
+            this.v7l ^= swap8IfBE(pers[2]);
+            this.v7h ^= swap8IfBE(pers[3]);
+        }
+        if (key !== undefined) {
+            // Pad to blockLen and update
+            const tmp = new Uint8Array(this.blockLen);
+            tmp.set(key);
+            this.update(tmp);
+        }
+    }
+    // prettier-ignore
+    get() {
+        let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+        return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+    }
+    // prettier-ignore
+    set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+        this.v0l = v0l | 0;
+        this.v0h = v0h | 0;
+        this.v1l = v1l | 0;
+        this.v1h = v1h | 0;
+        this.v2l = v2l | 0;
+        this.v2h = v2h | 0;
+        this.v3l = v3l | 0;
+        this.v3h = v3h | 0;
+        this.v4l = v4l | 0;
+        this.v4h = v4h | 0;
+        this.v5l = v5l | 0;
+        this.v5h = v5h | 0;
+        this.v6l = v6l | 0;
+        this.v6h = v6h | 0;
+        this.v7l = v7l | 0;
+        this.v7h = v7h | 0;
+    }
+    compress(msg, offset, isLast) {
+        this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
+        BBUF.set(B2B_IV, 16); // Second half from IV.
+        let { h, l } = fromBig(BigInt(this.length));
+        BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.
+        BBUF[25] = B2B_IV[9] ^ h; // High word.
+        // Invert all bits for last block
+        if (isLast) {
+            BBUF[28] = ~BBUF[28];
+            BBUF[29] = ~BBUF[29];
+        }
+        let j = 0;
+        const s = BSIGMA;
+        for (let i = 0; i < 12; i++) {
+            G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+            G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+            G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+            G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+            G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+            G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+            G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+            G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+            G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+            G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+            G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+            G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+            G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+            G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+            G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+            G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+        }
+        this.v0l ^= BBUF[0] ^ BBUF[16];
+        this.v0h ^= BBUF[1] ^ BBUF[17];
+        this.v1l ^= BBUF[2] ^ BBUF[18];
+        this.v1h ^= BBUF[3] ^ BBUF[19];
+        this.v2l ^= BBUF[4] ^ BBUF[20];
+        this.v2h ^= BBUF[5] ^ BBUF[21];
+        this.v3l ^= BBUF[6] ^ BBUF[22];
+        this.v3h ^= BBUF[7] ^ BBUF[23];
+        this.v4l ^= BBUF[8] ^ BBUF[24];
+        this.v4h ^= BBUF[9] ^ BBUF[25];
+        this.v5l ^= BBUF[10] ^ BBUF[26];
+        this.v5h ^= BBUF[11] ^ BBUF[27];
+        this.v6l ^= BBUF[12] ^ BBUF[28];
+        this.v6h ^= BBUF[13] ^ BBUF[29];
+        this.v7l ^= BBUF[14] ^ BBUF[30];
+        this.v7h ^= BBUF[15] ^ BBUF[31];
+        clean(BBUF);
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.buffer32);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+/**
+ * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+const blake2b = /* @__PURE__ */ createHasher((opts) => new _BLAKE2b(opts));
+
+//#region src/cryptography/signature-scheme.ts
+const SIGNATURE_SCHEME_TO_FLAG = {
+	ED25519: 0,
+	Secp256k1: 1,
+	Secp256r1: 2,
+	MultiSig: 3,
+	ZkLogin: 5,
+	Passkey: 6
+};
+const SIGNATURE_SCHEME_TO_SIZE = {
+	ED25519: 32,
+	Secp256k1: 33,
+	Secp256r1: 33,
+	Passkey: 33
+};
+const SIGNATURE_FLAG_TO_SCHEME = {
+	0: "ED25519",
+	1: "Secp256k1",
+	2: "Secp256r1",
+	3: "MultiSig",
+	5: "ZkLogin",
+	6: "Passkey"
+};
+
+//#region src/cryptography/intent.ts
+/**
+* Inserts a domain separator for a message that is being signed
+*/
+function messageWithIntent(scope, message) {
+	return suiBcs.IntentMessage(suiBcs.bytes(message.length)).serialize({
+		intent: {
+			scope: { [scope]: true },
+			version: { V0: true },
+			appId: { Sui: true }
+		},
+		value: message
+	}).toBytes();
+}
+
+//#region src/cryptography/publickey.ts
+function bytesEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* A public key
+*/
+var PublicKey = class {
+	/**
+	* Checks if two public keys are equal
+	*/
+	equals(publicKey) {
+		return bytesEqual(this.toRawBytes(), publicKey.toRawBytes());
+	}
+	/**
+	* Return the base-64 representation of the public key
+	*/
+	toBase64() {
+		return toBase64(this.toRawBytes());
+	}
+	toString() {
+		throw new Error("`toString` is not implemented on public keys. Use `toBase64()` or `toRawBytes()` instead.");
+	}
+	/**
+	* Return the Sui representation of the public key encoded in
+	* base-64. A Sui public key is formed by the concatenation
+	* of the scheme flag with the raw bytes of the public key
+	*/
+	toSuiPublicKey() {
+		return toBase64(this.toSuiBytes());
+	}
+	verifyWithIntent(bytes, signature, intent) {
+		const digest = blake2b(messageWithIntent(intent, bytes), { dkLen: 32 });
+		return this.verify(digest, signature);
+	}
+	/**
+	* Verifies that the signature is valid for for the provided PersonalMessage
+	*/
+	verifyPersonalMessage(message, signature) {
+		return this.verifyWithIntent(suiBcs.byteVector().serialize(message).toBytes(), signature, "PersonalMessage");
+	}
+	/**
+	* Verifies that the signature is valid for for the provided Transaction
+	*/
+	verifyTransaction(transaction, signature) {
+		return this.verifyWithIntent(transaction, signature, "TransactionData");
+	}
+	/**
+	* Verifies that the public key is associated with the provided address
+	*/
+	verifyAddress(address) {
+		return this.toSuiAddress() === address;
+	}
+	/**
+	* Returns the bytes representation of the public key
+	* prefixed with the signature scheme flag
+	*/
+	toSuiBytes() {
+		const rawBytes = this.toRawBytes();
+		const suiBytes = new Uint8Array(rawBytes.length + 1);
+		suiBytes.set([this.flag()]);
+		suiBytes.set(rawBytes, 1);
+		return suiBytes;
+	}
+	/**
+	* Return the Sui address associated with this Ed25519 public key
+	*/
+	toSuiAddress() {
+		return normalizeSuiAddress(bytesToHex(blake2b(this.toSuiBytes(), { dkLen: 32 })).slice(0, SUI_ADDRESS_LENGTH * 2));
+	}
+};
+function parseSerializedKeypairSignature(serializedSignature) {
+	const bytes = fromBase64(serializedSignature);
+	const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+	switch (signatureScheme) {
+		case "ED25519":
+		case "Secp256k1":
+		case "Secp256r1":
+			const size = SIGNATURE_SCHEME_TO_SIZE[signatureScheme];
+			const signature = bytes.slice(1, bytes.length - size);
+			return {
+				serializedSignature,
+				signatureScheme,
+				signature,
+				publicKey: bytes.slice(1 + signature.length),
+				bytes
+			};
+		default: throw new Error("Unsupported signature scheme");
+	}
+}
+
+//#region src/keypairs/ed25519/publickey.ts
+const PUBLIC_KEY_SIZE = 32;
+/**
+* An Ed25519 public key
+*/
+var Ed25519PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new Ed25519PublicKey object
+	* @param value ed25519 public key as buffer or base-64 encoded string
+	*/
+	constructor(value) {
+		super();
+		if (typeof value === "string") this.data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.data = value;
+		else this.data = Uint8Array.from(value);
+		if (this.data.length !== PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two Ed25519 public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Ed25519 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Sui address associated with this Ed25519 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["ED25519"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedKeypairSignature(signature);
+			if (parsed.signatureScheme !== "ED25519") throw new Error("Invalid signature scheme");
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) throw new Error("Signature does not match public key");
+			bytes = parsed.signature;
+		} else bytes = signature;
+		return ed25519.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+//#region src/keypairs/passkey/publickey.ts
+const PASSKEY_PUBLIC_KEY_SIZE = 33;
+const PASSKEY_SIGNATURE_SIZE = 64;
+/**
+* A passkey public key
+*/
+(class extends PublicKey {
+	static {
+		this.SIZE = PASSKEY_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new PasskeyPublicKey object
+	* @param value passkey public key as buffer or base-64 encoded string
+	*/
+	constructor(value) {
+		super();
+		if (typeof value === "string") this.data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.data = value;
+		else this.data = Uint8Array.from(value);
+		if (this.data.length !== PASSKEY_PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${PASSKEY_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two passkey public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Secp256r1 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Sui address associated with this Secp256r1 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["Passkey"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		const parsed = parseSerializedPasskeySignature(signature);
+		const clientDataJSON = JSON.parse(parsed.clientDataJson);
+		if (clientDataJSON.type !== "webauthn.get") return false;
+		if (!bytesEqual(message, fromBase64(clientDataJSON.challenge.replace(/-/g, "+").replace(/_/g, "/")))) return false;
+		const pk = parsed.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE);
+		if (!bytesEqual(this.toRawBytes(), pk)) return false;
+		const payload = new Uint8Array([...parsed.authenticatorData, ...sha256(new TextEncoder().encode(parsed.clientDataJson))]);
+		const sig = parsed.userSignature.slice(1, PASSKEY_SIGNATURE_SIZE + 1);
+		return p256.verify(sig, payload, pk);
+	}
+});
+/**
+* Parse signature from bytes or base64 string into the following fields.
+*/
+function parseSerializedPasskeySignature(signature) {
+	const bytes = typeof signature === "string" ? fromBase64(signature) : signature;
+	if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.Passkey) throw new Error("Invalid signature scheme");
+	const dec = PasskeyAuthenticator.parse(bytes.slice(1));
+	return {
+		signatureScheme: "Passkey",
+		serializedSignature: toBase64(bytes),
+		signature: bytes,
+		authenticatorData: dec.authenticatorData,
+		clientDataJson: dec.clientDataJson,
+		userSignature: new Uint8Array(dec.userSignature),
+		publicKey: new Uint8Array(dec.userSignature.slice(1 + PASSKEY_SIGNATURE_SIZE))
+	};
+}
+
+function findFirstNonZeroIndex(bytes) {
+	for (let i = 0; i < bytes.length; i++) if (bytes[i] !== 0) return i;
+	return -1;
+}
+function toPaddedBigEndianBytes(num, width) {
+	return hexToBytes(num.toString(16).padStart(width * 2, "0").slice(-width * 2));
+}
+function toBigEndianBytes(num, width) {
+	const bytes = toPaddedBigEndianBytes(num, width);
+	const firstNonZeroIndex = findFirstNonZeroIndex(bytes);
+	if (firstNonZeroIndex === -1) return new Uint8Array([0]);
+	return bytes.slice(firstNonZeroIndex);
+}
+function normalizeZkLoginIssuer(iss) {
+	if (iss === "accounts.google.com") return "https://accounts.google.com";
+	return iss;
+}
+
+//#region src/zklogin/jwt-utils.ts
+function base64UrlCharTo6Bits(base64UrlChar) {
+	if (base64UrlChar.length !== 1) throw new Error("Invalid base64Url character: " + base64UrlChar);
+	const index = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".indexOf(base64UrlChar);
+	if (index === -1) throw new Error("Invalid base64Url character: " + base64UrlChar);
+	const binaryString = index.toString(2).padStart(6, "0");
+	return Array.from(binaryString).map(Number);
+}
+function base64UrlStringToBitVector(base64UrlString) {
+	let bitVector = [];
+	for (let i = 0; i < base64UrlString.length; i++) {
+		const bits = base64UrlCharTo6Bits(base64UrlString.charAt(i));
+		bitVector = bitVector.concat(bits);
+	}
+	return bitVector;
+}
+function decodeBase64URL(s, i) {
+	if (s.length < 2) throw new Error(`Input (s = ${s}) is not tightly packed because s.length < 2`);
+	let bits = base64UrlStringToBitVector(s);
+	const firstCharOffset = i % 4;
+	if (firstCharOffset === 0) ; else if (firstCharOffset === 1) bits = bits.slice(2);
+	else if (firstCharOffset === 2) bits = bits.slice(4);
+	else throw new Error(`Input (s = ${s}) is not tightly packed because i%4 = 3 (i = ${i}))`);
+	const lastCharOffset = (i + s.length - 1) % 4;
+	if (lastCharOffset === 3) ; else if (lastCharOffset === 2) bits = bits.slice(0, bits.length - 2);
+	else if (lastCharOffset === 1) bits = bits.slice(0, bits.length - 4);
+	else throw new Error(`Input (s = ${s}) is not tightly packed because (i + s.length - 1)%4 = 0 (i = ${i}))`);
+	if (bits.length % 8 !== 0) throw new Error(`We should never reach here...`);
+	const bytes = new Uint8Array(Math.floor(bits.length / 8));
+	let currentByteIndex = 0;
+	for (let i$1 = 0; i$1 < bits.length; i$1 += 8) {
+		const bitChunk = bits.slice(i$1, i$1 + 8);
+		const byte = parseInt(bitChunk.join(""), 2);
+		bytes[currentByteIndex++] = byte;
+	}
+	return new TextDecoder().decode(bytes);
+}
+function verifyExtendedClaim(claim) {
+	if (!(claim.slice(-1) === "}" || claim.slice(-1) === ",")) throw new Error("Invalid claim");
+	const json = JSON.parse("{" + claim.slice(0, -1) + "}");
+	if (Object.keys(json).length !== 1) throw new Error("Invalid claim");
+	const key = Object.keys(json)[0];
+	return [key, json[key]];
+}
+function extractClaimValue(claim, claimName) {
+	const [name, value] = verifyExtendedClaim(decodeBase64URL(claim.value, claim.indexMod4));
+	if (name !== claimName) throw new Error(`Invalid field name: found ${name} expected ${claimName}`);
+	return value;
+}
+
+//#region src/zklogin/bcs.ts
+const zkLoginSignature = bcs.struct("ZkLoginSignature", {
+	inputs: bcs.struct("ZkLoginSignatureInputs", {
+		proofPoints: bcs.struct("ZkLoginSignatureInputsProofPoints", {
+			a: bcs.vector(bcs.string()),
+			b: bcs.vector(bcs.vector(bcs.string())),
+			c: bcs.vector(bcs.string())
+		}),
+		issBase64Details: bcs.struct("ZkLoginSignatureInputsClaim", {
+			value: bcs.string(),
+			indexMod4: bcs.u8()
+		}),
+		headerBase64: bcs.string(),
+		addressSeed: bcs.string()
+	}),
+	maxEpoch: bcs.u64(),
+	userSignature: bcs.byteVector()
+});
+
+function parseZkLoginSignature(signature) {
+	return zkLoginSignature.parse(typeof signature === "string" ? fromBase64(signature) : signature);
+}
+
+//#region src/zklogin/publickey.ts
+/**
+* A zkLogin public identifier
+*/
+var ZkLoginPublicIdentifier = class ZkLoginPublicIdentifier extends PublicKey {
+	#data;
+	#client;
+	#legacyAddress;
+	/**
+	* Create a new ZkLoginPublicIdentifier object
+	* @param value zkLogin public identifier as buffer or base-64 encoded string
+	*/
+	constructor(value, { client } = {}) {
+		super();
+		this.#client = client;
+		if (typeof value === "string") this.#data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.#data = value;
+		else this.#data = Uint8Array.from(value);
+		this.#legacyAddress = this.#data.length !== this.#data[0] + 1 + 32;
+		if (this.#legacyAddress) this.#data = normalizeZkLoginPublicKeyBytes(this.#data, false);
+	}
+	static fromBytes(bytes, { client, address, legacyAddress } = {}) {
+		let publicKey;
+		if (legacyAddress === true) publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), { client });
+		else if (legacyAddress === false) publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), { client });
+		else if (address) {
+			publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, false), { client });
+			if (publicKey.toSuiAddress() !== address) publicKey = new ZkLoginPublicIdentifier(normalizeZkLoginPublicKeyBytes(bytes, true), { client });
+		} else publicKey = new ZkLoginPublicIdentifier(bytes, { client });
+		if (address && publicKey.toSuiAddress() !== address) throw new Error("Public key bytes do not match the provided address");
+		return publicKey;
+	}
+	static fromProof(address, proof) {
+		const { issBase64Details, addressSeed } = proof;
+		const iss = extractClaimValue(issBase64Details, "iss");
+		const legacyPublicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, { legacyAddress: true });
+		if (legacyPublicKey.toSuiAddress() === address) return legacyPublicKey;
+		const publicKey = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, { legacyAddress: false });
+		if (publicKey.toSuiAddress() !== address) throw new Error("Proof does not match address");
+		return publicKey;
+	}
+	/**
+	* Checks if two zkLogin public identifiers are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	toSuiAddress() {
+		if (this.#legacyAddress) return this.#toLegacyAddress();
+		return super.toSuiAddress();
+	}
+	#toLegacyAddress() {
+		const legacyBytes = normalizeZkLoginPublicKeyBytes(this.#data, true);
+		const addressBytes = new Uint8Array(legacyBytes.length + 1);
+		addressBytes[0] = this.flag();
+		addressBytes.set(legacyBytes, 1);
+		return normalizeSuiAddress(bytesToHex(blake2b(addressBytes, { dkLen: 32 })).slice(0, SUI_ADDRESS_LENGTH * 2));
+	}
+	/**
+	* Return the byte array representation of the zkLogin public identifier
+	*/
+	toRawBytes() {
+		return this.#data;
+	}
+	/**
+	* Return the Sui address associated with this ZkLogin public identifier
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["ZkLogin"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(_message, _signature) {
+		throw Error("does not support");
+	}
+	/**
+	* Verifies that the signature is valid for for the provided PersonalMessage
+	*/
+	verifyPersonalMessage(message, signature) {
+		const parsedSignature = parseSerializedZkLoginSignature(signature);
+		return graphqlVerifyZkLoginSignature({
+			address: new ZkLoginPublicIdentifier(parsedSignature.publicKey).toSuiAddress(),
+			bytes: toBase64(message),
+			signature: parsedSignature.serializedSignature,
+			intentScope: "PersonalMessage",
+			client: this.#client
+		});
+	}
+	/**
+	* Verifies that the signature is valid for for the provided Transaction
+	*/
+	verifyTransaction(transaction, signature) {
+		const parsedSignature = parseSerializedZkLoginSignature(signature);
+		return graphqlVerifyZkLoginSignature({
+			address: new ZkLoginPublicIdentifier(parsedSignature.publicKey).toSuiAddress(),
+			bytes: toBase64(transaction),
+			signature: parsedSignature.serializedSignature,
+			intentScope: "TransactionData",
+			client: this.#client
+		});
+	}
+	/**
+	* Verifies that the public key is associated with the provided address
+	*/
+	verifyAddress(address) {
+		return address === super.toSuiAddress() || address === this.#toLegacyAddress();
+	}
+};
+function toZkLoginPublicIdentifier(addressSeed, iss, options) {
+	if (options.legacyAddress === void 0) throw new Error("legacyAddress parameter must be specified");
+	const addressSeedBytesBigEndian = options.legacyAddress ? toBigEndianBytes(addressSeed, 32) : toPaddedBigEndianBytes(addressSeed, 32);
+	const issBytes = new TextEncoder().encode(normalizeZkLoginIssuer(iss));
+	const tmp = new Uint8Array(1 + issBytes.length + addressSeedBytesBigEndian.length);
+	tmp.set([issBytes.length], 0);
+	tmp.set(issBytes, 1);
+	tmp.set(addressSeedBytesBigEndian, 1 + issBytes.length);
+	return new ZkLoginPublicIdentifier(tmp, options);
+}
+function normalizeZkLoginPublicKeyBytes(bytes, legacyAddress) {
+	const issByteLength = bytes[0] + 1;
+	const addressSeed = BigInt(`0x${toHex(bytes.slice(issByteLength))}`);
+	const seedBytes = legacyAddress ? toBigEndianBytes(addressSeed, 32) : toPaddedBigEndianBytes(addressSeed, 32);
+	const data = new Uint8Array(issByteLength + seedBytes.length);
+	data.set(bytes.slice(0, issByteLength), 0);
+	data.set(seedBytes, issByteLength);
+	return data;
+}
+async function graphqlVerifyZkLoginSignature({ address, bytes, signature, intentScope, client }) {
+	if (!client) throw new Error("A Sui Client (GRPC, GraphQL, or JSON RPC) is required to verify zkLogin signatures");
+	const resp = await client.core.verifyZkLoginSignature({
+		bytes,
+		signature,
+		intentScope,
+		address
+	});
+	return resp.success === true && resp.errors.length === 0;
+}
+function parseSerializedZkLoginSignature(signature) {
+	const bytes = typeof signature === "string" ? fromBase64(signature) : signature;
+	if (bytes[0] !== SIGNATURE_SCHEME_TO_FLAG.ZkLogin) throw new Error("Invalid signature scheme");
+	const { inputs, maxEpoch, userSignature } = parseZkLoginSignature(bytes.slice(1));
+	const { issBase64Details, addressSeed } = inputs;
+	const iss = extractClaimValue(issBase64Details, "iss");
+	const publicIdentifier = toZkLoginPublicIdentifier(BigInt(addressSeed), iss, { legacyAddress: false });
+	return {
+		serializedSignature: toBase64(bytes),
+		signatureScheme: "ZkLogin",
+		zkLogin: {
+			inputs,
+			maxEpoch,
+			userSignature,
+			iss,
+			addressSeed: BigInt(addressSeed)
+		},
+		signature: bytes,
+		publicKey: publicIdentifier.toRawBytes()
+	};
+}
+
+//#region src/cryptography/signature.ts
+/**
+* Takes in a signature, its associated signing scheme and a public key, then serializes this data
+*/
+function toSerializedSignature({ signature, signatureScheme, publicKey }) {
+	if (!publicKey) throw new Error("`publicKey` is required");
+	const pubKeyBytes = publicKey.toRawBytes();
+	const serializedSignature = new Uint8Array(1 + signature.length + pubKeyBytes.length);
+	serializedSignature.set([SIGNATURE_SCHEME_TO_FLAG[signatureScheme]]);
+	serializedSignature.set(signature, 1);
+	serializedSignature.set(pubKeyBytes, 1 + signature.length);
+	return toBase64(serializedSignature);
+}
+/**
+* Decodes a serialized signature into its constituent components: the signature scheme, the actual signature, and the public key
+*/
+function parseSerializedSignature(serializedSignature) {
+	const bytes = fromBase64(serializedSignature);
+	const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+	switch (signatureScheme) {
+		case "Passkey": return parseSerializedPasskeySignature(serializedSignature);
+		case "MultiSig": return {
+			serializedSignature,
+			signatureScheme,
+			multisig: suiBcs.MultiSig.parse(bytes.slice(1)),
+			bytes,
+			signature: void 0
+		};
+		case "ZkLogin": return parseSerializedZkLoginSignature(serializedSignature);
+		case "ED25519":
+		case "Secp256k1":
+		case "Secp256r1": return parseSerializedKeypairSignature(serializedSignature);
+		default: throw new Error("Unsupported signature scheme");
+	}
+}
+
+//#region src/keypairs/secp256k1/publickey.ts
+const SECP256K1_PUBLIC_KEY_SIZE = 33;
+/**
+* A Secp256k1 public key
+*/
+var Secp256k1PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = SECP256K1_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new Secp256k1PublicKey object
+	* @param value secp256k1 public key as buffer or base-64 encoded string
+	*/
+	constructor(value) {
+		super();
+		if (typeof value === "string") this.data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.data = value;
+		else this.data = Uint8Array.from(value);
+		if (this.data.length !== SECP256K1_PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${SECP256K1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two Secp256k1 public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Secp256k1 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Sui address associated with this Secp256k1 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["Secp256k1"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedKeypairSignature(signature);
+			if (parsed.signatureScheme !== "Secp256k1") throw new Error("Invalid signature scheme");
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) throw new Error("Signature does not match public key");
+			bytes = parsed.signature;
+		} else bytes = signature;
+		return secp256k1.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+//#region src/keypairs/secp256r1/publickey.ts
+const SECP256R1_PUBLIC_KEY_SIZE = 33;
+/**
+* A Secp256r1 public key
+*/
+var Secp256r1PublicKey = class extends PublicKey {
+	static {
+		this.SIZE = SECP256R1_PUBLIC_KEY_SIZE;
+	}
+	/**
+	* Create a new Secp256r1PublicKey object
+	* @param value secp256r1 public key as buffer or base-64 encoded string
+	*/
+	constructor(value) {
+		super();
+		if (typeof value === "string") this.data = fromBase64(value);
+		else if (value instanceof Uint8Array) this.data = value;
+		else this.data = Uint8Array.from(value);
+		if (this.data.length !== SECP256R1_PUBLIC_KEY_SIZE) throw new Error(`Invalid public key input. Expected ${SECP256R1_PUBLIC_KEY_SIZE} bytes, got ${this.data.length}`);
+	}
+	/**
+	* Checks if two Secp256r1 public keys are equal
+	*/
+	equals(publicKey) {
+		return super.equals(publicKey);
+	}
+	/**
+	* Return the byte array representation of the Secp256r1 public key
+	*/
+	toRawBytes() {
+		return this.data;
+	}
+	/**
+	* Return the Sui address associated with this Secp256r1 public key
+	*/
+	flag() {
+		return SIGNATURE_SCHEME_TO_FLAG["Secp256r1"];
+	}
+	/**
+	* Verifies that the signature is valid for for the provided message
+	*/
+	async verify(message, signature) {
+		let bytes;
+		if (typeof signature === "string") {
+			const parsed = parseSerializedSignature(signature);
+			if (parsed.signatureScheme !== "Secp256r1") throw new Error("Invalid signature scheme");
+			if (!bytesEqual(this.toRawBytes(), parsed.publicKey)) throw new Error("Signature does not match public key");
+			bytes = parsed.signature;
+		} else bytes = signature;
+		return p256.verify(bytes, message, this.toRawBytes());
+	}
+};
+
+export { Ed25519PublicKey as E, SIGNATURE_FLAG_TO_SCHEME as S, SIGNATURE_SCHEME_TO_FLAG as a, bech32 as b, blake2b as c, toBase64 as d, toSerializedSignature as e, bcs as f, fromHex as g, createBase58check as h, Secp256k1PublicKey as i, Secp256r1PublicKey as j, fromBase64 as k, messageWithIntent as m, toHex as t };