FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@solana/codecs-numbers/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Solana Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@solana/codecs-numbers/README.md

@@ -0,0 +1,130 @@
+[![npm][npm-image]][npm-url]
+[![npm-downloads][npm-downloads-image]][npm-url]
+<br />
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/codecs-numbers?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/codecs-numbers?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/codecs-numbers
+
+# @solana/codecs-numbers
+
+This package contains codecs for numbers of different sizes and endianness. It can be used standalone, but it is also exported as part of Kit [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+
+This package is also part of the [`@solana/codecs` package](https://github.com/anza-xyz/kit/tree/main/packages/codecs) which acts as an entry point for all codec packages as well as for their documentation.
+
+## Integer codecs
+
+This package provides ten codecs of five different byte sizes for integers. Five of them store unsigned integers and the other five store signed integers.
+
+```ts
+// Unsigned integers.
+getU8Codec().encode(42); // 0x2a
+getU16Codec().encode(42); // 0x2a00
+getU32Codec().encode(42); // 0x2a000000
+getU64Codec().encode(42); // 0x2a00000000000000
+getU128Codec().encode(42); // 0x2a000000000000000000000000000000
+
+// Signed integers.
+getI8Codec().encode(-42); // 0xd6
+getI16Codec().encode(-42); // 0xd6ff
+getI32Codec().encode(-42); // 0xd6ffffff
+getI64Codec().encode(-42); // 0xd6ffffffffffffff
+getI128Codec().encode(-42); // 0xd6ffffffffffffffffffffffffffffff
+```
+
+By default, integers are stored using little endianness but you may change this behaviour via the `endian` option. This option is available for every codec that uses more than a single byte.
+
+```ts
+// Big-endian unsigned integers.
+getU16Codec({ endian: Endian.Big }).encode(42); // 0x002a
+getU32Codec({ endian: Endian.Big }).encode(42); // 0x0000002a
+getU64Codec({ endian: Endian.Big }).encode(42); // 0x000000000000002a
+getU128Codec({ endian: Endian.Big }).encode(42); // 0x0000000000000000000000000000002a
+
+// Big-endian signed integers.
+getI16Codec({ endian: Endian.Big }).encode(-42); // 0xffd6
+getI32Codec({ endian: Endian.Big }).encode(-42); // 0xffffffd6
+getI64Codec({ endian: Endian.Big }).encode(-42); // 0xffffffffffffffd6
+getI128Codec({ endian: Endian.Big }).encode(-42); // 0xffffffffffffffffffffffffffffffd6
+```
+
+All integer codecs are of type `Codec<number>` except for the `u64`, `u128`, `i64` and `i128` codecs which are of type `Codec<number | bigint, bigint>`. This means we can provide either a `number` of a `bigint` value to encode but the decoded value will always be a `bigint`. This is because JavaScript's native `number` type does not support numbers larger than `2^53 - 1` and these large integer codecs have the potential to go over that value.
+
+```ts
+const bytesFromNumber = getU64Codec().encode(42);
+getU64Codec().decode(bytesFromNumber); // BigInt(42)
+
+// OR
+const bytesFromBigInt = getU64Codec().encode(BigInt(42));
+getU64Codec().decode(bytesFromBigInt); // BigInt(42)
+```
+
+Finally, for each of these `get*Codec` functions, separate `get*Encoder` and `get*Decoder` functions exist to focus on only one side of the serialization and tree-shake the rest of the functions away.
+
+```ts
+const bytes = getU8Encoder().encode(42);
+const value = getU8Decoder().decode(bytes);
+```
+
+## Decimal number codecs
+
+This package also provides two codecs for floating numbers. One using 32 bits and one using 64 bits.
+
+```ts
+getF32Codec().encode(-1.5); // 0x0000c0bf
+getF64Codec().encode(-1.5); // 0x000000000000f8bf
+```
+
+Similarly to the integer codecs, they are stored in little-endian by default but may be stored in big-endian using the `endian` option.
+
+```ts
+getF32Codec({ endian: Endian.Big }).encode(-1.5); // 0xbfc00000
+getF64Codec({ endian: Endian.Big }).encode(-1.5); // 0xbff8000000000000
+```
+
+Note that based on the selected codec, some of the precision of the number you are encoding may be lost when decoding it. For instance, when storing `3.1415` using a `f32` codec, you will not get the exact same number back.
+
+```ts
+const bytes = getF32Codec().encode(3.1415); // 0x560e4940
+const value = getF32Codec().decode(bytes); // 3.1414999961853027 !== 3.1415
+```
+
+As usual, separate encoder and decoder functions are available for these codecs.
+
+```ts
+getF32Encoder().encode(-1.5);
+getF32Decoder().decode(new Uint8Array([...]));
+
+getF64Encoder().encode(-1.5);
+getF64Decoder().decode(new Uint8Array([...]));
+```
+
+## Short u16 codec
+
+This last integer codec is less common `VariableSizeCodec` that stores an unsigned integer using between 1 to 3 bytes depending on the value of that integer.
+
+```ts
+const bytes = getShortU16Codec().encode(42); // 0x2a
+const value = getShortU16Codec().decode(bytes); // 42
+```
+
+If the provided integer is equal to or lower than `0x7f`, it will be stored as-is, using a single byte. However, if the integer is above `0x7f`, then the top bit is set and the remaining value is stored in the next bytes. Each byte follows the same pattern until the third byte. The third byte, if needed, uses all 8 bits to store the last byte of the original value.
+
+In other words, this codec provides an extendable size that adapts based on the integer. In the illustration below, you can see the `0` and `1` byte flags for each scenario as well as the available bits to store the integer marked with `X`.
+
+```
+0XXXXXXX <- From 0 to 127.
+1XXXXXXX 0XXXXXXX <- From 128 to 16,383.
+1XXXXXXX 1XXXXXXX XXXXXXXX <- From 16,384 to 4,194,303.
+```
+
+This codec is mainly used internally when encoding and decoding Solana transactions.
+
+Separate encoder and decoder functions are also available via `getShortU16Encoder` and `getShortU16Decoder` respectively.
+
+---
+
+To read more about the available codecs and how to use them, check out the documentation of the main [`@solana/codecs` package](https://github.com/anza-xyz/kit/tree/main/packages/codecs).

node_modules/@solana/codecs-numbers/dist/index.browser.cjs

@@ -0,0 +1,326 @@
+'use strict';
+
+var errors = require('@solana/errors');
+var codecsCore = require('@solana/codecs-core');
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return codecsCore.createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return codecsCore.createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      codecsCore.assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      codecsCore.assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(codecsCore.toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => codecsCore.combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => codecsCore.combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => codecsCore.combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => codecsCore.combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => codecsCore.combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => codecsCore.combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => codecsCore.combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => codecsCore.createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => codecsCore.createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => codecsCore.combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => codecsCore.combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => codecsCore.combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => codecsCore.combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => codecsCore.combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => codecsCore.combineCodec(getU8Encoder(), getU8Decoder());
+
+exports.Endian = Endian;
+exports.assertNumberIsBetweenForCodec = assertNumberIsBetweenForCodec;
+exports.getF32Codec = getF32Codec;
+exports.getF32Decoder = getF32Decoder;
+exports.getF32Encoder = getF32Encoder;
+exports.getF64Codec = getF64Codec;
+exports.getF64Decoder = getF64Decoder;
+exports.getF64Encoder = getF64Encoder;
+exports.getI128Codec = getI128Codec;
+exports.getI128Decoder = getI128Decoder;
+exports.getI128Encoder = getI128Encoder;
+exports.getI16Codec = getI16Codec;
+exports.getI16Decoder = getI16Decoder;
+exports.getI16Encoder = getI16Encoder;
+exports.getI32Codec = getI32Codec;
+exports.getI32Decoder = getI32Decoder;
+exports.getI32Encoder = getI32Encoder;
+exports.getI64Codec = getI64Codec;
+exports.getI64Decoder = getI64Decoder;
+exports.getI64Encoder = getI64Encoder;
+exports.getI8Codec = getI8Codec;
+exports.getI8Decoder = getI8Decoder;
+exports.getI8Encoder = getI8Encoder;
+exports.getShortU16Codec = getShortU16Codec;
+exports.getShortU16Decoder = getShortU16Decoder;
+exports.getShortU16Encoder = getShortU16Encoder;
+exports.getU128Codec = getU128Codec;
+exports.getU128Decoder = getU128Decoder;
+exports.getU128Encoder = getU128Encoder;
+exports.getU16Codec = getU16Codec;
+exports.getU16Decoder = getU16Decoder;
+exports.getU16Encoder = getU16Encoder;
+exports.getU32Codec = getU32Codec;
+exports.getU32Decoder = getU32Decoder;
+exports.getU32Encoder = getU32Encoder;
+exports.getU64Codec = getU64Codec;
+exports.getU64Decoder = getU64Decoder;
+exports.getU64Encoder = getU64Encoder;
+exports.getU8Codec = getU8Codec;
+exports.getU8Decoder = getU8Decoder;
+exports.getU8Encoder = getU8Encoder;
+//# sourceMappingURL=index.browser.cjs.map
+//# sourceMappingURL=index.browser.cjs.map

node_modules/@solana/codecs-numbers/dist/index.browser.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.browser.mjs.map
+//# sourceMappingURL=index.browser.mjs.map

node_modules/@solana/codecs-numbers/dist/index.native.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.native.mjs.map
+//# sourceMappingURL=index.native.mjs.map

node_modules/@solana/codecs-numbers/dist/index.node.cjs

@@ -0,0 +1,326 @@
+'use strict';
+
+var errors = require('@solana/errors');
+var codecsCore = require('@solana/codecs-core');
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return codecsCore.createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return codecsCore.createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      codecsCore.assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      codecsCore.assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(codecsCore.toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => codecsCore.combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => codecsCore.combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => codecsCore.combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => codecsCore.combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => codecsCore.combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => codecsCore.combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => codecsCore.combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => codecsCore.createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => codecsCore.createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => codecsCore.combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => codecsCore.combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => codecsCore.combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => codecsCore.combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => codecsCore.combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => codecsCore.combineCodec(getU8Encoder(), getU8Decoder());
+
+exports.Endian = Endian;
+exports.assertNumberIsBetweenForCodec = assertNumberIsBetweenForCodec;
+exports.getF32Codec = getF32Codec;
+exports.getF32Decoder = getF32Decoder;
+exports.getF32Encoder = getF32Encoder;
+exports.getF64Codec = getF64Codec;
+exports.getF64Decoder = getF64Decoder;
+exports.getF64Encoder = getF64Encoder;
+exports.getI128Codec = getI128Codec;
+exports.getI128Decoder = getI128Decoder;
+exports.getI128Encoder = getI128Encoder;
+exports.getI16Codec = getI16Codec;
+exports.getI16Decoder = getI16Decoder;
+exports.getI16Encoder = getI16Encoder;
+exports.getI32Codec = getI32Codec;
+exports.getI32Decoder = getI32Decoder;
+exports.getI32Encoder = getI32Encoder;
+exports.getI64Codec = getI64Codec;
+exports.getI64Decoder = getI64Decoder;
+exports.getI64Encoder = getI64Encoder;
+exports.getI8Codec = getI8Codec;
+exports.getI8Decoder = getI8Decoder;
+exports.getI8Encoder = getI8Encoder;
+exports.getShortU16Codec = getShortU16Codec;
+exports.getShortU16Decoder = getShortU16Decoder;
+exports.getShortU16Encoder = getShortU16Encoder;
+exports.getU128Codec = getU128Codec;
+exports.getU128Decoder = getU128Decoder;
+exports.getU128Encoder = getU128Encoder;
+exports.getU16Codec = getU16Codec;
+exports.getU16Decoder = getU16Decoder;
+exports.getU16Encoder = getU16Encoder;
+exports.getU32Codec = getU32Codec;
+exports.getU32Decoder = getU32Decoder;
+exports.getU32Encoder = getU32Encoder;
+exports.getU64Codec = getU64Codec;
+exports.getU64Decoder = getU64Decoder;
+exports.getU64Encoder = getU64Encoder;
+exports.getU8Codec = getU8Codec;
+exports.getU8Decoder = getU8Decoder;
+exports.getU8Encoder = getU8Encoder;
+//# sourceMappingURL=index.node.cjs.map
+//# sourceMappingURL=index.node.cjs.map

node_modules/@solana/codecs-numbers/dist/index.node.mjs

@@ -0,0 +1,284 @@
+import { SolanaError, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE } from '@solana/errors';
+import { combineCodec, createDecoder, createEncoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec, toArrayBuffer } from '@solana/codecs-core';
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+
+// src/common.ts
+var Endian = /* @__PURE__ */ ((Endian2) => {
+  Endian2[Endian2["Little"] = 0] = "Little";
+  Endian2[Endian2["Big"] = 1] = "Big";
+  return Endian2;
+})(Endian || {});
+function isLittleEndian(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+
+// src/f32.ts
+var getF32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f32",
+  set: (view, value, le) => view.setFloat32(0, Number(value), le),
+  size: 4
+});
+var getF32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat32(0, le),
+  name: "f32",
+  size: 4
+});
+var getF32Codec = (config = {}) => combineCodec(getF32Encoder(config), getF32Decoder(config));
+var getF64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "f64",
+  set: (view, value, le) => view.setFloat64(0, Number(value), le),
+  size: 8
+});
+var getF64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getFloat64(0, le),
+  name: "f64",
+  size: 8
+});
+var getF64Codec = (config = {}) => combineCodec(getF64Encoder(config), getF64Decoder(config));
+var getI128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i128",
+  range: [-BigInt("0x7fffffffffffffffffffffffffffffff") - 1n, BigInt("0x7fffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getI128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigInt64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "i128",
+  size: 16
+});
+var getI128Codec = (config = {}) => combineCodec(getI128Encoder(config), getI128Decoder(config));
+var getI16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i16",
+  range: [-Number("0x7fff") - 1, Number("0x7fff")],
+  set: (view, value, le) => view.setInt16(0, Number(value), le),
+  size: 2
+});
+var getI16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt16(0, le),
+  name: "i16",
+  size: 2
+});
+var getI16Codec = (config = {}) => combineCodec(getI16Encoder(config), getI16Decoder(config));
+var getI32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i32",
+  range: [-Number("0x7fffffff") - 1, Number("0x7fffffff")],
+  set: (view, value, le) => view.setInt32(0, Number(value), le),
+  size: 4
+});
+var getI32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getInt32(0, le),
+  name: "i32",
+  size: 4
+});
+var getI32Codec = (config = {}) => combineCodec(getI32Encoder(config), getI32Decoder(config));
+var getI64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "i64",
+  range: [-BigInt("0x7fffffffffffffff") - 1n, BigInt("0x7fffffffffffffff")],
+  set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+  size: 8
+});
+var getI64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigInt64(0, le),
+  name: "i64",
+  size: 8
+});
+var getI64Codec = (config = {}) => combineCodec(getI64Encoder(config), getI64Decoder(config));
+var getI8Encoder = () => numberEncoderFactory({
+  name: "i8",
+  range: [-Number("0x7f") - 1, Number("0x7f")],
+  set: (view, value) => view.setInt8(0, Number(value)),
+  size: 1
+});
+var getI8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getInt8(0),
+  name: "i8",
+  size: 1
+});
+var getI8Codec = () => combineCodec(getI8Encoder(), getI8Decoder());
+var getShortU16Encoder = () => createEncoder({
+  getSizeFromValue: (value) => {
+    if (value <= 127) return 1;
+    if (value <= 16383) return 2;
+    return 3;
+  },
+  maxSize: 3,
+  write: (value, bytes, offset) => {
+    assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+    const shortU16Bytes = [0];
+    for (let ii = 0; ; ii += 1) {
+      const alignedValue = Number(value) >> ii * 7;
+      if (alignedValue === 0) {
+        break;
+      }
+      const nextSevenBits = 127 & alignedValue;
+      shortU16Bytes[ii] = nextSevenBits;
+      if (ii > 0) {
+        shortU16Bytes[ii - 1] |= 128;
+      }
+    }
+    bytes.set(shortU16Bytes, offset);
+    return offset + shortU16Bytes.length;
+  }
+});
+var getShortU16Decoder = () => createDecoder({
+  maxSize: 3,
+  read: (bytes, offset) => {
+    let value = 0;
+    let byteCount = 0;
+    while (++byteCount) {
+      const byteIndex = byteCount - 1;
+      const currentByte = bytes[offset + byteIndex];
+      const nextSevenBits = 127 & currentByte;
+      value |= nextSevenBits << byteIndex * 7;
+      if ((currentByte & 128) === 0) {
+        break;
+      }
+    }
+    return [value, offset + byteCount];
+  }
+});
+var getShortU16Codec = () => combineCodec(getShortU16Encoder(), getShortU16Decoder());
+var getU128Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u128",
+  range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
+  set: (view, value, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const rightMask = 0xffffffffffffffffn;
+    view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+    view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+  },
+  size: 16
+});
+var getU128Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => {
+    const leftOffset = le ? 8 : 0;
+    const rightOffset = le ? 0 : 8;
+    const left = view.getBigUint64(leftOffset, le);
+    const right = view.getBigUint64(rightOffset, le);
+    return (left << 64n) + right;
+  },
+  name: "u128",
+  size: 16
+});
+var getU128Codec = (config = {}) => combineCodec(getU128Encoder(config), getU128Decoder(config));
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u16",
+  range: [0, Number("0xffff")],
+  set: (view, value, le) => view.setUint16(0, Number(value), le),
+  size: 2
+});
+var getU16Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint16(0, le),
+  name: "u16",
+  size: 2
+});
+var getU16Codec = (config = {}) => combineCodec(getU16Encoder(config), getU16Decoder(config));
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec(getU32Encoder(config), getU32Decoder(config));
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+var getU64Codec = (config = {}) => combineCodec(getU64Encoder(config), getU64Decoder(config));
+var getU8Encoder = () => numberEncoderFactory({
+  name: "u8",
+  range: [0, Number("0xff")],
+  set: (view, value) => view.setUint8(0, Number(value)),
+  size: 1
+});
+var getU8Decoder = () => numberDecoderFactory({
+  get: (view) => view.getUint8(0),
+  name: "u8",
+  size: 1
+});
+var getU8Codec = () => combineCodec(getU8Encoder(), getU8Decoder());
+
+export { Endian, assertNumberIsBetweenForCodec, getF32Codec, getF32Decoder, getF32Encoder, getF64Codec, getF64Decoder, getF64Encoder, getI128Codec, getI128Decoder, getI128Encoder, getI16Codec, getI16Decoder, getI16Encoder, getI32Codec, getI32Decoder, getI32Encoder, getI64Codec, getI64Decoder, getI64Encoder, getI8Codec, getI8Decoder, getI8Encoder, getShortU16Codec, getShortU16Decoder, getShortU16Encoder, getU128Codec, getU128Decoder, getU128Encoder, getU16Codec, getU16Decoder, getU16Encoder, getU32Codec, getU32Decoder, getU32Encoder, getU64Codec, getU64Decoder, getU64Encoder, getU8Codec, getU8Decoder, getU8Encoder };
+//# sourceMappingURL=index.node.mjs.map
+//# sourceMappingURL=index.node.mjs.map

node_modules/@solana/codecs-numbers/dist/types/assertions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Ensures that a given number falls within a specified range.
+ *
+ * If the number is outside the allowed range, an error is thrown.
+ * This function is primarily used to validate values before encoding them in a codec.
+ *
+ * @param codecDescription - A string describing the codec that is performing the validation.
+ * @param min - The minimum allowed value (inclusive).
+ * @param max - The maximum allowed value (inclusive).
+ * @param value - The number to validate.
+ *
+ * @throws {@link SolanaError} if the value is out of range.
+ *
+ * @example
+ * Validating a number within range.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 42); // Passes
+ * ```
+ *
+ * @example
+ * Throwing an error for an out-of-range value.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 300); // Throws
+ * ```
+ */
+export declare function assertNumberIsBetweenForCodec(codecDescription: string, min: bigint | number, max: bigint | number, value: bigint | number): void;
+//# sourceMappingURL=assertions.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../src/assertions.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CACzC,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,KAAK,EAAE,MAAM,GAAG,MAAM,QAUzB"}

node_modules/@solana/codecs-numbers/dist/types/common.d.ts

@@ -0,0 +1,84 @@
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Represents an encoder for numbers and bigints.
+ *
+ * This type allows encoding values that are either `number` or `bigint`.
+ * Depending on the specific implementation, the encoded output may have a fixed or variable size.
+ *
+ * @see {@link FixedSizeNumberEncoder}
+ */
+export type NumberEncoder = Encoder<bigint | number>;
+/**
+ * Represents a fixed-size encoder for numbers and bigints.
+ *
+ * This encoder serializes values using an exact number of bytes, defined by `TSize`.
+ *
+ * @typeParam TSize - The number of bytes used for encoding.
+ *
+ * @see {@link NumberEncoder}
+ */
+export type FixedSizeNumberEncoder<TSize extends number = number> = FixedSizeEncoder<bigint | number, TSize>;
+/**
+ * Represents a decoder for numbers and bigints.
+ *
+ * This type supports decoding values as either `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberDecoder}
+ */
+export type NumberDecoder = Decoder<bigint> | Decoder<number>;
+/**
+ * Represents a fixed-size decoder for numbers and bigints.
+ *
+ * This decoder reads a fixed number of bytes (`TSize`) and converts them into a `number` or `bigint`.
+ *
+ * @typeParam TSize - The number of bytes expected for decoding.
+ *
+ * @see {@link NumberDecoder}
+ */
+export type FixedSizeNumberDecoder<TSize extends number = number> = FixedSizeDecoder<bigint, TSize> | FixedSizeDecoder<number, TSize>;
+/**
+ * Represents a codec for encoding and decoding numbers and bigints.
+ *
+ * - The encoded value can be either a `number` or a `bigint`.
+ * - The decoded value will always be either a `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberCodec}
+ */
+export type NumberCodec = Codec<bigint | number, bigint> | Codec<bigint | number, number>;
+/**
+ * Represents a fixed-size codec for encoding and decoding numbers and bigints.
+ *
+ * This codec uses a specific number of bytes (`TSize`) for serialization.
+ * The encoded value can be either a `number` or `bigint`, but the decoded value will always be a `number` or `bigint`,
+ * depending on the implementation.
+ *
+ * @typeParam TSize - The number of bytes used for encoding and decoding.
+ *
+ * @see {@link NumberCodec}
+ */
+export type FixedSizeNumberCodec<TSize extends number = number> = FixedSizeCodec<bigint | number, bigint, TSize> | FixedSizeCodec<bigint | number, number, TSize>;
+/**
+ * Configuration options for number codecs that use more than one byte.
+ *
+ * This configuration applies to all number codecs except `u8` and `i8`,
+ * allowing the user to specify the endianness of serialization.
+ */
+export type NumberCodecConfig = {
+    /**
+     * Specifies whether numbers should be encoded in little-endian or big-endian format.
+     *
+     * @defaultValue `Endian.Little`
+     */
+    endian?: Endian;
+};
+/**
+ * Defines the byte order used for number serialization.
+ *
+ * - `Little`: The least significant byte is stored first.
+ * - `Big`: The most significant byte is stored first.
+ */
+export declare enum Endian {
+    Little = 0,
+    Big = 1
+}
+//# sourceMappingURL=common.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAClH;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAErD;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAAI,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,CAAC;AAE7G;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAC1D,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,GAC/B,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC;AAE1F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IACxD,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,GAC9C,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,oBAAY,MAAM;IACd,MAAM,IAAA;IACN,GAAG,IAAA;CACN"}

node_modules/@solana/codecs-numbers/dist/types/f32.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This encoder serializes `f32` values using 4 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 4>` for encoding `f32` values.
+ *
+ * @example
+ * Encoding an `f32` value.
+ * ```ts
+ * const encoder = getF32Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x0000c0bf
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export declare const getF32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This decoder deserializes `f32` values from 4 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `f32` values.
+ *
+ * @example
+ * Decoding an `f32` value.
+ * ```ts
+ * const decoder = getF32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0xc0, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export declare const getF32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit floating-point numbers (`f32`).
+ *
+ * This codec serializes `f32` values using 4 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 4>` for encoding and decoding `f32` values.
+ *
+ * @example
+ * Encoding and decoding an `f32` value.
+ * ```ts
+ * const codec = getF32Codec();
+ * const bytes = codec.encode(-1.5); // 0x0000c0bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbfc00000
+ * ```
+ *
+ * @remarks
+ * `f32` values follow the IEEE 754 single-precision floating-point standard.
+ * Precision loss may occur for certain values.
+ *
+ * - If you need higher precision, consider using {@link getF64Codec}.
+ * - If you need integer values, consider using {@link getI32Codec} or {@link getU32Codec}.
+ *
+ * Separate {@link getF32Encoder} and {@link getF32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF32Encoder().encode(-1.5);
+ * const value = getF32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF32Encoder}
+ * @see {@link getF32Decoder}
+ */
+export declare const getF32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=f32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/f32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f32.d.ts","sourceRoot":"","sources":["../../src/f32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/f64.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This encoder serializes `f64` values using 8 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 8>` for encoding `f64` values.
+ *
+ * @example
+ * Encoding an `f64` value.
+ * ```ts
+ * const encoder = getF64Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x000000000000f8bf
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export declare const getF64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This decoder deserializes `f64` values from 8 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 8>` for decoding `f64` values.
+ *
+ * @example
+ * Decoding an `f64` value.
+ * ```ts
+ * const decoder = getF64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export declare const getF64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit floating-point numbers (`f64`).
+ *
+ * This codec serializes `f64` values using 8 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 8>` for encoding and decoding `f64` values.
+ *
+ * @example
+ * Encoding and decoding an `f64` value.
+ * ```ts
+ * const codec = getF64Codec();
+ * const bytes = codec.encode(-1.5); // 0x000000000000f8bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbff8000000000000
+ * ```
+ *
+ * @remarks
+ * `f64` values follow the IEEE 754 double-precision floating-point standard.
+ * Precision loss may still occur but is significantly lower than `f32`.
+ *
+ * - If you need smaller floating-point values, consider using {@link getF32Codec}.
+ * - If you need integer values, consider using {@link getI64Codec} or {@link getU64Codec}.
+ *
+ * Separate {@link getF64Encoder} and {@link getF64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF64Encoder().encode(-1.5);
+ * const value = getF64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF64Encoder}
+ * @see {@link getF64Decoder}
+ */
+export declare const getF64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 8>;
+//# sourceMappingURL=f64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/f64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f64.d.ts","sourceRoot":"","sources":["../../src/f64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i128.d.ts

@@ -0,0 +1,91 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 128-bit signed integers (`i128`).
+ *
+ * This encoder serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `i128` values.
+ *
+ * @example
+ * Encoding an `i128` value.
+ * ```ts
+ * const encoder = getI128Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export declare const getI128Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 16>;
+/**
+ * Returns a decoder for 128-bit signed integers (`i128`).
+ *
+ * This decoder deserializes `i128` values from 16 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `i128` values.
+ *
+ * @example
+ * Decoding an `i128` value.
+ * ```ts
+ * const decoder = getI128Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ *   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export declare const getI128Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 16>;
+/**
+ * Returns a codec for encoding and decoding 128-bit signed integers (`i128`).
+ *
+ * This codec serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `i128` values.
+ *
+ * @example
+ * Encoding and decoding an `i128` value.
+ * ```ts
+ * const codec = getI128Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^127` and `2^127 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI64Codec} or {@link getI32Codec}.
+ * - If you need a larger signed integer, consider using a custom codec.
+ * - If you need unsigned integers, consider using {@link getU128Codec}.
+ *
+ * Separate {@link getI128Encoder} and {@link getI128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI128Encoder().encode(-42);
+ * const value = getI128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI128Encoder}
+ * @see {@link getI128Decoder}
+ */
+export declare const getI128Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 16>;
+//# sourceMappingURL=i128.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i128.d.ts","sourceRoot":"","sources":["../../src/i128.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,CAa9F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAYrF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,YAAY,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i16.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 16-bit signed integers (`i16`).
+ *
+ * This encoder serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `i16` values.
+ *
+ * @example
+ * Encoding an `i16` value.
+ * ```ts
+ * const encoder = getI16Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ff
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export declare const getI16Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 2>;
+/**
+ * Returns a decoder for 16-bit signed integers (`i16`).
+ *
+ * This decoder deserializes `i16` values from 2 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `i16` values.
+ *
+ * @example
+ * Decoding an `i16` value.
+ * ```ts
+ * const decoder = getI16Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export declare const getI16Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 2>;
+/**
+ * Returns a codec for encoding and decoding 16-bit signed integers (`i16`).
+ *
+ * This codec serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `i16` values.
+ *
+ * @example
+ * Encoding and decoding an `i16` value.
+ * ```ts
+ * const codec = getI16Codec();
+ * const bytes = codec.encode(-42); // 0xd6ff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^15` (`-32,768`) and `2^15 - 1` (`32,767`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI32Codec}.
+ * - If you need unsigned integers, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getI16Encoder} and {@link getI16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI16Encoder().encode(-42);
+ * const value = getI16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI16Encoder}
+ * @see {@link getI16Decoder}
+ */
+export declare const getI16Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 2>;
+//# sourceMappingURL=i16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i16.d.ts","sourceRoot":"","sources":["../../src/i16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i32.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit signed integers (`i32`).
+ *
+ * This encoder serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 4>` for encoding `i32` values.
+ *
+ * @example
+ * Encoding an `i32` value.
+ * ```ts
+ * const encoder = getI32Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ffffff
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export declare const getI32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit signed integers (`i32`).
+ *
+ * This decoder deserializes `i32` values from 4 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `i32` values.
+ *
+ * @example
+ * Decoding an `i32` value.
+ * ```ts
+ * const decoder = getI32Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff, 0xff, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export declare const getI32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit signed integers (`i32`).
+ *
+ * This codec serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 4>` for encoding and decoding `i32` values.
+ *
+ * @example
+ * Encoding and decoding an `i32` value.
+ * ```ts
+ * const codec = getI32Codec();
+ * const bytes = codec.encode(-42); // 0xd6ffffff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^31` (`-2,147,483,648`) and `2^31 - 1` (`2,147,483,647`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI16Codec} or {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI64Codec}.
+ * - If you need unsigned integers, consider using {@link getU32Codec}.
+ *
+ * Separate {@link getI32Encoder} and {@link getI32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI32Encoder().encode(-42);
+ * const value = getI32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI32Encoder}
+ * @see {@link getI32Decoder}
+ */
+export declare const getI32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=i32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i32.d.ts","sourceRoot":"","sources":["../../src/i32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i64.d.ts

@@ -0,0 +1,90 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit signed integers (`i64`).
+ *
+ * This encoder serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `i64` values.
+ *
+ * @example
+ * Encoding an `i64` value.
+ * ```ts
+ * const encoder = getI64Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffff
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export declare const getI64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit signed integers (`i64`).
+ *
+ * This decoder deserializes `i64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `i64` values.
+ *
+ * @example
+ * Decoding an `i64` value.
+ * ```ts
+ * const decoder = getI64Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export declare const getI64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit signed integers (`i64`).
+ *
+ * This codec serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `i64` values.
+ *
+ * @example
+ * Encoding and decoding an `i64` value.
+ * ```ts
+ * const codec = getI64Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^63` and `2^63 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI32Codec} or {@link getI16Codec}.
+ * - If you need a larger signed integer, consider using {@link getI128Codec}.
+ * - If you need unsigned integers, consider using {@link getU64Codec}.
+ *
+ * Separate {@link getI64Encoder} and {@link getI64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI64Encoder().encode(-42);
+ * const value = getI64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI64Encoder}
+ * @see {@link getI64Decoder}
+ */
+export declare const getI64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 8>;
+//# sourceMappingURL=i64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i64.d.ts","sourceRoot":"","sources":["../../src/i64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/i8.d.ts

@@ -0,0 +1,75 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for 8-bit signed integers (`i8`).
+ *
+ * This encoder serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `i8` values.
+ *
+ * @example
+ * Encoding an `i8` value.
+ * ```ts
+ * const encoder = getI8Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export declare const getI8Encoder: () => FixedSizeEncoder<bigint | number, 1>;
+/**
+ * Returns a decoder for 8-bit signed integers (`i8`).
+ *
+ * This decoder deserializes `i8` values from 1 byte.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `i8` values.
+ *
+ * @example
+ * Decoding an `i8` value.
+ * ```ts
+ * const decoder = getI8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6])); // -42
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export declare const getI8Decoder: () => FixedSizeDecoder<number, 1>;
+/**
+ * Returns a codec for encoding and decoding 8-bit signed integers (`i8`).
+ *
+ * This codec serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `i8` values.
+ *
+ * @example
+ * Encoding and decoding an `i8` value.
+ * ```ts
+ * const codec = getI8Codec();
+ * const bytes = codec.encode(-42); // 0xd6
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^7` (`-128`) and `2^7 - 1` (`127`).
+ *
+ * - If you need a larger signed integer, consider using {@link getI16Codec}.
+ * - If you need an unsigned integer, consider using {@link getU8Codec}.
+ *
+ * Separate {@link getI8Encoder} and {@link getI8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI8Encoder().encode(-42);
+ * const value = getI8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI8Encoder}
+ * @see {@link getI8Decoder}
+ */
+export declare const getI8Codec: () => FixedSizeCodec<bigint | number, number, 1>;
+//# sourceMappingURL=i8.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/i8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i8.d.ts","sourceRoot":"","sources":["../../src/i8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvG;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM7D,CAAC;AAEP;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAKpD,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,UAAU,QAAO,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACvB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This package contains codecs for numbers of different sizes and endianness.
+ * It can be used standalone, but it is also exported as part of Kit
+ * [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * This package is also part of the [`@solana/codecs` package](https://github.com/anza-xyz/kit/tree/main/packages/codecs)
+ * which acts as an entry point for all codec packages as well as for their documentation.
+ *
+ * @packageDocumentation
+ */
+export * from './assertions';
+export * from './common';
+export * from './f32';
+export * from './f64';
+export * from './i128';
+export * from './i16';
+export * from './i32';
+export * from './i64';
+export * from './i8';
+export * from './short-u16';
+export * from './u128';
+export * from './u16';
+export * from './u32';
+export * from './u64';
+export * from './u8';
+//# sourceMappingURL=index.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/short-u16.d.ts

@@ -0,0 +1,96 @@
+import { VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for `shortU16` values.
+ *
+ * This encoder serializes `shortU16` values using **1 to 3 bytes**.
+ * Smaller values use fewer bytes, while larger values take up more space.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeEncoder<number | bigint>` for encoding `shortU16` values.
+ *
+ * @example
+ * Encoding a `shortU16` value.
+ * ```ts
+ * const encoder = getShortU16Encoder();
+ * encoder.encode(42);    // 0x2a
+ * encoder.encode(128);   // 0x8001
+ * encoder.encode(16384); // 0x808001
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export declare const getShortU16Encoder: () => VariableSizeEncoder<bigint | number>;
+/**
+ * Returns a decoder for `shortU16` values.
+ *
+ * This decoder deserializes `shortU16` values from **1 to 3 bytes**.
+ * The number of bytes used depends on the encoded value.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeDecoder<number>` for decoding `shortU16` values.
+ *
+ * @example
+ * Decoding a `shortU16` value.
+ * ```ts
+ * const decoder = getShortU16Decoder();
+ * decoder.decode(new Uint8Array([0x2a]));             // 42
+ * decoder.decode(new Uint8Array([0x80, 0x01]));       // 128
+ * decoder.decode(new Uint8Array([0x80, 0x80, 0x01])); // 16384
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export declare const getShortU16Decoder: () => VariableSizeDecoder<number>;
+/**
+ * Returns a codec for encoding and decoding `shortU16` values.
+ *
+ * It serializes unsigned integers using **1 to 3 bytes** based on the encoded value.
+ * The larger the value, the more bytes it uses.
+ *
+ * - If the value is `<= 0x7f` (127), it is stored in a **single byte**
+ *   and the first bit is set to `0` to indicate the end of the value.
+ * - Otherwise, the first bit is set to `1` to indicate that the value continues in the next byte, which follows the same pattern.
+ * - This process repeats until the value is fully encoded in up to 3 bytes. The third and last byte, if needed, uses all 8 bits to store the remaining value.
+ *
+ * In other words, the encoding scheme follows this structure:
+ *
+ * ```txt
+ * 0XXXXXXX                   <- Values 0 to 127 (1 byte)
+ * 1XXXXXXX 0XXXXXXX          <- Values 128 to 16,383 (2 bytes)
+ * 1XXXXXXX 1XXXXXXX XXXXXXXX <- Values 16,384 to 4,194,303 (3 bytes)
+ * ```
+ *
+ * @returns A `VariableSizeCodec<number | bigint, number>` for encoding and decoding `shortU16` values.
+ *
+ * @example
+ * Encoding and decoding `shortU16` values.
+ * ```ts
+ * const codec = getShortU16Codec();
+ * const bytes1 = codec.encode(42);    // 0x2a
+ * const bytes2 = codec.encode(128);   // 0x8001
+ * const bytes3 = codec.encode(16384); // 0x808001
+ *
+ * codec.decode(bytes1); // 42
+ * codec.decode(bytes2); // 128
+ * codec.decode(bytes3); // 16384
+ * ```
+ *
+ * @remarks
+ * This codec efficiently stores small numbers, making it useful for transactions and compact representations.
+ *
+ * If you need a fixed-size `u16` codec, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getShortU16Encoder} and {@link getShortU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getShortU16Encoder().encode(42);
+ * const value = getShortU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getShortU16Encoder}
+ * @see {@link getShortU16Decoder}
+ */
+export declare const getShortU16Codec: () => VariableSizeCodec<bigint | number, number>;
+//# sourceMappingURL=short-u16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/short-u16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"short-u16.d.ts","sourceRoot":"","sources":["../../src/short-u16.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,QAAO,mBAAmB,CAAC,MAAM,GAAG,MAAM,CA6BnE,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,QAAO,mBAAmB,CAAC,MAAM,CAmB1D,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,gBAAgB,QAAO,iBAAiB,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CACjB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u128.d.ts

@@ -0,0 +1,87 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 128-bit unsigned integers (`u128`).
+ *
+ * This encoder serializes `u128` values using sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `u128` values.
+ *
+ * @example
+ * Encoding a `u128` value.
+ * ```ts
+ * const encoder = getU128Encoder();
+ * const bytes = encoder.encode(42n); // 0x2a000000000000000000000000000000
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export declare const getU128Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 16>;
+/**
+ * Returns a decoder for 128-bit unsigned integers (`u128`).
+ *
+ * This decoder deserializes `u128` values from sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `u128` values.
+ *
+ * @example
+ * Decoding a `u128` value.
+ * ```ts
+ * const decoder = getU128Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export declare const getU128Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 16>;
+/**
+ * Returns a codec for encoding and decoding 128-bit unsigned integers (`u128`).
+ *
+ * This codec serializes `u128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `u128` values.
+ *
+ * @example
+ * Encoding and decoding a `u128` value.
+ * ```ts
+ * const codec = getU128Codec();
+ * const bytes = codec.encode(42); // 0x2a000000000000000000000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000000000000000000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^128 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU64Codec} or {@link getU32Codec}.
+ * - If you need signed integers, consider using {@link getI128Codec}.
+ *
+ * Separate {@link getU128Encoder} and {@link getU128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU128Encoder().encode(42);
+ * const value = getU128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU128Encoder}
+ * @see {@link getU128Decoder}
+ */
+export declare const getU128Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 16>;
+//# sourceMappingURL=u128.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u128.d.ts","sourceRoot":"","sources":["../../src/u128.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,CAa9F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAYrF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,YAAY,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u16.d.ts

@@ -0,0 +1,85 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 16-bit unsigned integers (`u16`).
+ *
+ * This encoder serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `u16` values.
+ *
+ * @example
+ * Encoding a `u16` value.
+ * ```ts
+ * const encoder = getU16Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export declare const getU16Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 2>;
+/**
+ * Returns a decoder for 16-bit unsigned integers (`u16`).
+ *
+ * This decoder deserializes `u16` values from two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `u16` values.
+ *
+ * @example
+ * Decoding a `u16` value.
+ * ```ts
+ * const decoder = getU16Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export declare const getU16Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 2>;
+/**
+ * Returns a codec for encoding and decoding 16-bit unsigned integers (`u16`).
+ *
+ * This codec serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `u16` values.
+ *
+ * @example
+ * Encoding and decoding a `u16` value.
+ * ```ts
+ * const codec = getU16Codec();
+ * const bytes = codec.encode(42); // 0x2a00 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^16 - 1`.
+ * If you need a larger range, consider using {@link getU32Codec} or {@link getU64Codec}.
+ * For signed integers, use {@link getI16Codec}.
+ *
+ * Separate {@link getU16Encoder} and {@link getU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU16Encoder().encode(42);
+ * const value = getU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU16Encoder}
+ * @see {@link getU16Decoder}
+ */
+export declare const getU16Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 2>;
+//# sourceMappingURL=u16.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u16.d.ts","sourceRoot":"","sources":["../../src/u16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u32.d.ts

@@ -0,0 +1,85 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 32-bit unsigned integers (`u32`).
+ *
+ * This encoder serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<bigint | number, 4>` for encoding `u32` values.
+ *
+ * @example
+ * Encoding a `u32` value.
+ * ```ts
+ * const encoder = getU32Encoder();
+ * const bytes = encoder.encode(42); // 0x2a000000
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export declare const getU32Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 4>;
+/**
+ * Returns a decoder for 32-bit unsigned integers (`u32`).
+ *
+ * This decoder deserializes `u32` values from four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `u32` values.
+ *
+ * @example
+ * Decoding a `u32` value.
+ * ```ts
+ * const decoder = getU32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export declare const getU32Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<number, 4>;
+/**
+ * Returns a codec for encoding and decoding 32-bit unsigned integers (`u32`).
+ *
+ * This codec serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<bigint | number, number, 4>` for encoding and decoding `u32` values.
+ *
+ * @example
+ * Encoding and decoding a `u32` value.
+ * ```ts
+ * const codec = getU32Codec();
+ * const bytes = codec.encode(42); // 0x2a000000 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000002a
+ * ```
+ *
+ * @remarks
+ * This codec only supports values between `0` and `2^32 - 1`.
+ * If you need a larger range, consider using {@link getU64Codec} or {@link getU128Codec}.
+ * For signed integers, use {@link getI32Codec}.
+ *
+ * Separate {@link getU32Encoder} and {@link getU32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU32Encoder().encode(42);
+ * const value = getU32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU32Encoder}
+ * @see {@link getU32Decoder}
+ */
+export declare const getU32Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, number, 4>;
+//# sourceMappingURL=u32.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u32.d.ts","sourceRoot":"","sources":["../../src/u32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u64.d.ts

@@ -0,0 +1,88 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+/**
+ * Returns an encoder for 64-bit unsigned integers (`u64`).
+ *
+ * This encoder serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `u64` values.
+ *
+ * @example
+ * Encoding a `u64` value.
+ * ```ts
+ * const encoder = getU64Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00000000000000
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export declare const getU64Encoder: (config?: NumberCodecConfig) => FixedSizeEncoder<bigint | number, 8>;
+/**
+ * Returns a decoder for 64-bit unsigned integers (`u64`).
+ *
+ * This decoder deserializes `u64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `u64` values.
+ *
+ * @example
+ * Decoding a `u64` value.
+ * ```ts
+ * const decoder = getU64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export declare const getU64Decoder: (config?: NumberCodecConfig) => FixedSizeDecoder<bigint, 8>;
+/**
+ * Returns a codec for encoding and decoding 64-bit unsigned integers (`u64`).
+ *
+ * This codec serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `u64` values.
+ *
+ * @example
+ * Encoding and decoding a `u64` value.
+ * ```ts
+ * const codec = getU64Codec();
+ * const bytes = codec.encode(42); // 0x2a00000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^64 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU32Codec} or {@link getU16Codec}.
+ * - If you need a larger unsigned integer, consider using {@link getU128Codec}.
+ * - If you need signed integers, consider using {@link getI64Codec}.
+ *
+ * Separate {@link getU64Encoder} and {@link getU64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU64Encoder().encode(42);
+ * const value = getU64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU64Encoder}
+ * @see {@link getU64Decoder}
+ */
+export declare const getU64Codec: (config?: NumberCodecConfig) => FixedSizeCodec<bigint | number, bigint, 8>;
+//# sourceMappingURL=u64.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u64.d.ts","sourceRoot":"","sources":["../../src/u64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/u8.d.ts

@@ -0,0 +1,71 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Returns an encoder for 8-bit unsigned integers (`u8`).
+ *
+ * This encoder serializes `u8` values using a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `u8` values.
+ *
+ * @example
+ * Encoding a `u8` value.
+ * ```ts
+ * const encoder = getU8Encoder();
+ * const bytes = encoder.encode(42); // 0x2a
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export declare const getU8Encoder: () => FixedSizeEncoder<bigint | number, 1>;
+/**
+ * Returns a decoder for 8-bit unsigned integers (`u8`).
+ *
+ * This decoder deserializes `u8` values from a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `u8` values.
+ *
+ * @example
+ * Decoding a `u8` value.
+ * ```ts
+ * const decoder = getU8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xff])); // 255
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export declare const getU8Decoder: () => FixedSizeDecoder<number, 1>;
+/**
+ * Returns a codec for encoding and decoding 8-bit unsigned integers (`u8`).
+ *
+ * This codec serializes `u8` values using a single byte.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `u8` values.
+ *
+ * @example
+ * Encoding and decoding a `u8` value.
+ * ```ts
+ * const codec = getU8Codec();
+ * const bytes = codec.encode(255); // 0xff
+ * const value = codec.decode(bytes); // 255
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^8 - 1` (0 to 255).
+ * If you need larger integers, consider using {@link getU16Codec}, {@link getU32Codec}, or {@link getU64Codec}.
+ * For signed integers, use {@link getI8Codec}.
+ *
+ * Separate {@link getU8Encoder} and {@link getU8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU8Encoder().encode(42);
+ * const value = getU8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU8Encoder}
+ * @see {@link getU8Decoder}
+ */
+export declare const getU8Codec: () => FixedSizeCodec<bigint | number, number, 1>;
+//# sourceMappingURL=u8.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/u8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"u8.d.ts","sourceRoot":"","sources":["../../src/u8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAM7D,CAAC;AAEP;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,QAAO,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAKpD,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,UAAU,QAAO,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACvB,CAAC"}

node_modules/@solana/codecs-numbers/dist/types/utils.d.ts

@@ -0,0 +1,18 @@
+import { FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+import { NumberCodecConfig } from './common';
+type NumberFactorySharedInput<TSize extends number> = {
+    config?: NumberCodecConfig;
+    name: string;
+    size: TSize;
+};
+type NumberFactoryEncoderInput<TFrom, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    range?: [bigint | number, bigint | number];
+    set: (view: DataView, value: TFrom, littleEndian?: boolean) => void;
+};
+type NumberFactoryDecoderInput<TTo, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    get: (view: DataView, littleEndian?: boolean) => TTo;
+};
+export declare function numberEncoderFactory<TFrom extends bigint | number, TSize extends number>(input: NumberFactoryEncoderInput<TFrom, TSize>): FixedSizeEncoder<TFrom, TSize>;
+export declare function numberDecoderFactory<TTo extends bigint | number, TSize extends number>(input: NumberFactoryDecoderInput<TTo, TSize>): FixedSizeDecoder<TTo, TSize>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

node_modules/@solana/codecs-numbers/dist/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,gBAAgB,EAChB,gBAAgB,EAGnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAU,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAErD,KAAK,wBAAwB,CAAC,KAAK,SAAS,MAAM,IAAI;IAClD,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,KAAK,yBAAyB,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IAAI,wBAAwB,CAAC,KAAK,CAAC,GAAG;IAC5F,KAAK,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAC3C,GAAG,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACvE,CAAC;AAEF,KAAK,yBAAyB,CAAC,GAAG,EAAE,KAAK,SAAS,MAAM,IAAI,wBAAwB,CAAC,KAAK,CAAC,GAAG;IAC1F,GAAG,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,OAAO,KAAK,GAAG,CAAC;CACxD,CAAC;AAMF,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,SAAS,MAAM,EACpF,KAAK,EAAE,yBAAyB,CAAC,KAAK,EAAE,KAAK,CAAC,GAC/C,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAahC;AAED,wBAAgB,oBAAoB,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,SAAS,MAAM,EAClF,KAAK,EAAE,yBAAyB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC7C,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAU9B"}

node_modules/@solana/codecs-numbers/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@solana/codecs-numbers",
+  "version": "6.8.0",
+  "description": "Codecs for numbers of different sizes and endianness",
+  "homepage": "https://www.solanakit.com/api#solanacodecs-numbers",
+  "exports": {
+    "edge-light": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "workerd": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "browser": {
+      "import": "./dist/index.browser.mjs",
+      "require": "./dist/index.browser.cjs"
+    },
+    "node": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "react-native": "./dist/index.native.mjs",
+    "types": "./dist/types/index.d.ts"
+  },
+  "browser": {
+    "./dist/index.node.cjs": "./dist/index.browser.cjs",
+    "./dist/index.node.mjs": "./dist/index.browser.mjs"
+  },
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.mjs",
+  "react-native": "./dist/index.native.mjs",
+  "types": "./dist/types/index.d.ts",
+  "type": "commonjs",
+  "files": [
+    "./dist/",
+    "./src/"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "blockchain",
+    "solana",
+    "web3"
+  ],
+  "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anza-xyz/kit"
+  },
+  "bugs": {
+    "url": "https://github.com/anza-xyz/kit/issues"
+  },
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
+  "dependencies": {
+    "@solana/errors": "6.8.0",
+    "@solana/codecs-core": "6.8.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "scripts": {
+    "compile:docs": "typedoc",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "dev": "NODE_OPTIONS=\"--no-experimental-webstorage\" jest -c ../../node_modules/@solana/test-config/jest-dev.config.js --rootDir . --watch",
+    "publish-impl": "npm view $npm_package_name@$npm_package_version > /dev/null 2>&1 || (pnpm publish --tag ${PUBLISH_TAG:-canary} --access public --no-git-checks && (([ -n \"${GITHUB_OUTPUT:-}\" ] && echo 'published=true' >> \"$GITHUB_OUTPUT\") || true) && (([ \"$PUBLISH_TAG\" != \"canary\" ] && ../build-scripts/maybe-tag-latest.ts --token \"$GITHUB_TOKEN\" $npm_package_name@$npm_package_version) || true))",
+    "publish-packages": "pnpm prepublishOnly && pnpm publish-impl",
+    "style:fix": "pnpm eslint --fix src && pnpm prettier --log-level warn --ignore-unknown --write ./*",
+    "test:lint": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-lint.config.js --rootDir . --silent",
+    "test:prettier": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.js --rootDir . --silent",
+    "test:treeshakability:browser": "agadoo dist/index.browser.mjs",
+    "test:treeshakability:native": "agadoo dist/index.native.mjs",
+    "test:treeshakability:node": "agadoo dist/index.node.mjs",
+    "test:typecheck": "tsc --noEmit",
+    "test:unit:browser": "NODE_OPTIONS=\"--no-experimental-webstorage\" TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.browser.js --rootDir . --silent",
+    "test:unit:node": "NODE_OPTIONS=\"--no-experimental-webstorage\" TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.node.js --rootDir . --silent"
+  }
+}

node_modules/@solana/codecs-numbers/src/assertions.ts

@@ -0,0 +1,42 @@
+import { SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, SolanaError } from '@solana/errors';
+
+/**
+ * Ensures that a given number falls within a specified range.
+ *
+ * If the number is outside the allowed range, an error is thrown.
+ * This function is primarily used to validate values before encoding them in a codec.
+ *
+ * @param codecDescription - A string describing the codec that is performing the validation.
+ * @param min - The minimum allowed value (inclusive).
+ * @param max - The maximum allowed value (inclusive).
+ * @param value - The number to validate.
+ *
+ * @throws {@link SolanaError} if the value is out of range.
+ *
+ * @example
+ * Validating a number within range.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 42); // Passes
+ * ```
+ *
+ * @example
+ * Throwing an error for an out-of-range value.
+ * ```ts
+ * assertNumberIsBetweenForCodec('u8', 0, 255, 300); // Throws
+ * ```
+ */
+export function assertNumberIsBetweenForCodec(
+    codecDescription: string,
+    min: bigint | number,
+    max: bigint | number,
+    value: bigint | number,
+) {
+    if (value < min || value > max) {
+        throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+            codecDescription,
+            max,
+            min,
+            value,
+        });
+    }
+}

node_modules/@solana/codecs-numbers/src/common.ts

@@ -0,0 +1,94 @@
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+/**
+ * Represents an encoder for numbers and bigints.
+ *
+ * This type allows encoding values that are either `number` or `bigint`.
+ * Depending on the specific implementation, the encoded output may have a fixed or variable size.
+ *
+ * @see {@link FixedSizeNumberEncoder}
+ */
+export type NumberEncoder = Encoder<bigint | number>;
+
+/**
+ * Represents a fixed-size encoder for numbers and bigints.
+ *
+ * This encoder serializes values using an exact number of bytes, defined by `TSize`.
+ *
+ * @typeParam TSize - The number of bytes used for encoding.
+ *
+ * @see {@link NumberEncoder}
+ */
+export type FixedSizeNumberEncoder<TSize extends number = number> = FixedSizeEncoder<bigint | number, TSize>;
+
+/**
+ * Represents a decoder for numbers and bigints.
+ *
+ * This type supports decoding values as either `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberDecoder}
+ */
+export type NumberDecoder = Decoder<bigint> | Decoder<number>;
+
+/**
+ * Represents a fixed-size decoder for numbers and bigints.
+ *
+ * This decoder reads a fixed number of bytes (`TSize`) and converts them into a `number` or `bigint`.
+ *
+ * @typeParam TSize - The number of bytes expected for decoding.
+ *
+ * @see {@link NumberDecoder}
+ */
+export type FixedSizeNumberDecoder<TSize extends number = number> =
+    | FixedSizeDecoder<bigint, TSize>
+    | FixedSizeDecoder<number, TSize>;
+
+/**
+ * Represents a codec for encoding and decoding numbers and bigints.
+ *
+ * - The encoded value can be either a `number` or a `bigint`.
+ * - The decoded value will always be either a `number` or `bigint`, depending on the implementation.
+ *
+ * @see {@link FixedSizeNumberCodec}
+ */
+export type NumberCodec = Codec<bigint | number, bigint> | Codec<bigint | number, number>;
+
+/**
+ * Represents a fixed-size codec for encoding and decoding numbers and bigints.
+ *
+ * This codec uses a specific number of bytes (`TSize`) for serialization.
+ * The encoded value can be either a `number` or `bigint`, but the decoded value will always be a `number` or `bigint`,
+ * depending on the implementation.
+ *
+ * @typeParam TSize - The number of bytes used for encoding and decoding.
+ *
+ * @see {@link NumberCodec}
+ */
+export type FixedSizeNumberCodec<TSize extends number = number> =
+    | FixedSizeCodec<bigint | number, bigint, TSize>
+    | FixedSizeCodec<bigint | number, number, TSize>;
+
+/**
+ * Configuration options for number codecs that use more than one byte.
+ *
+ * This configuration applies to all number codecs except `u8` and `i8`,
+ * allowing the user to specify the endianness of serialization.
+ */
+export type NumberCodecConfig = {
+    /**
+     * Specifies whether numbers should be encoded in little-endian or big-endian format.
+     *
+     * @defaultValue `Endian.Little`
+     */
+    endian?: Endian;
+};
+
+/**
+ * Defines the byte order used for number serialization.
+ *
+ * - `Little`: The least significant byte is stored first.
+ * - `Big`: The most significant byte is stored first.
+ */
+export enum Endian {
+    Little,
+    Big,
+}

node_modules/@solana/codecs-numbers/src/f32.ts

@@ -0,0 +1,104 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This encoder serializes `f32` values using 4 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 4>` for encoding `f32` values.
+ *
+ * @example
+ * Encoding an `f32` value.
+ * ```ts
+ * const encoder = getF32Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x0000c0bf
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export const getF32Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 4> =>
+    numberEncoderFactory({
+        config,
+        name: 'f32',
+        set: (view, value, le) => view.setFloat32(0, Number(value), le),
+        size: 4,
+    });
+
+/**
+ * Returns a decoder for 32-bit floating-point numbers (`f32`).
+ *
+ * This decoder deserializes `f32` values from 4 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `f32` values.
+ *
+ * @example
+ * Decoding an `f32` value.
+ * ```ts
+ * const decoder = getF32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0xc0, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF32Codec}
+ */
+export const getF32Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 4> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getFloat32(0, le),
+        name: 'f32',
+        size: 4,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 32-bit floating-point numbers (`f32`).
+ *
+ * This codec serializes `f32` values using 4 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 4>` for encoding and decoding `f32` values.
+ *
+ * @example
+ * Encoding and decoding an `f32` value.
+ * ```ts
+ * const codec = getF32Codec();
+ * const bytes = codec.encode(-1.5); // 0x0000c0bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbfc00000
+ * ```
+ *
+ * @remarks
+ * `f32` values follow the IEEE 754 single-precision floating-point standard.
+ * Precision loss may occur for certain values.
+ *
+ * - If you need higher precision, consider using {@link getF64Codec}.
+ * - If you need integer values, consider using {@link getI32Codec} or {@link getU32Codec}.
+ *
+ * Separate {@link getF32Encoder} and {@link getF32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF32Encoder().encode(-1.5);
+ * const value = getF32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF32Encoder}
+ * @see {@link getF32Decoder}
+ */
+export const getF32Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 4> =>
+    combineCodec(getF32Encoder(config), getF32Decoder(config));

node_modules/@solana/codecs-numbers/src/f64.ts

@@ -0,0 +1,104 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This encoder serializes `f64` values using 8 bytes.
+ * Floating-point values may lose precision when encoded.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number, 8>` for encoding `f64` values.
+ *
+ * @example
+ * Encoding an `f64` value.
+ * ```ts
+ * const encoder = getF64Encoder();
+ * const bytes = encoder.encode(-1.5); // 0x000000000000f8bf
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export const getF64Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 8> =>
+    numberEncoderFactory({
+        config,
+        name: 'f64',
+        set: (view, value, le) => view.setFloat64(0, Number(value), le),
+        size: 8,
+    });
+
+/**
+ * Returns a decoder for 64-bit floating-point numbers (`f64`).
+ *
+ * This decoder deserializes `f64` values from 8 bytes.
+ * Some precision may be lost during decoding due to floating-point representation.
+ *
+ * For more details, see {@link getF64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 8>` for decoding `f64` values.
+ *
+ * @example
+ * Decoding an `f64` value.
+ * ```ts
+ * const decoder = getF64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xbf])); // -1.5
+ * ```
+ *
+ * @see {@link getF64Codec}
+ */
+export const getF64Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 8> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getFloat64(0, le),
+        name: 'f64',
+        size: 8,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 64-bit floating-point numbers (`f64`).
+ *
+ * This codec serializes `f64` values using 8 bytes.
+ * Due to the IEEE 754 floating-point representation, some precision loss may occur.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number, number, 8>` for encoding and decoding `f64` values.
+ *
+ * @example
+ * Encoding and decoding an `f64` value.
+ * ```ts
+ * const codec = getF64Codec();
+ * const bytes = codec.encode(-1.5); // 0x000000000000f8bf
+ * const value = codec.decode(bytes); // -1.5
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getF64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-1.5); // 0xbff8000000000000
+ * ```
+ *
+ * @remarks
+ * `f64` values follow the IEEE 754 double-precision floating-point standard.
+ * Precision loss may still occur but is significantly lower than `f32`.
+ *
+ * - If you need smaller floating-point values, consider using {@link getF32Codec}.
+ * - If you need integer values, consider using {@link getI64Codec} or {@link getU64Codec}.
+ *
+ * Separate {@link getF64Encoder} and {@link getF64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getF64Encoder().encode(-1.5);
+ * const value = getF64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getF64Encoder}
+ * @see {@link getF64Decoder}
+ */
+export const getF64Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 8> =>
+    combineCodec(getF64Encoder(config), getF64Decoder(config));

node_modules/@solana/codecs-numbers/src/i128.ts

@@ -0,0 +1,121 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 128-bit signed integers (`i128`).
+ *
+ * This encoder serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `i128` values.
+ *
+ * @example
+ * Encoding an `i128` value.
+ * ```ts
+ * const encoder = getI128Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export const getI128Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 16> =>
+    numberEncoderFactory({
+        config,
+        name: 'i128',
+        range: [-BigInt('0x7fffffffffffffffffffffffffffffff') - 1n, BigInt('0x7fffffffffffffffffffffffffffffff')],
+        set: (view, value, le) => {
+            const leftOffset = le ? 8 : 0;
+            const rightOffset = le ? 0 : 8;
+            const rightMask = 0xffffffffffffffffn;
+            view.setBigInt64(leftOffset, BigInt(value) >> 64n, le);
+            view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+        },
+        size: 16,
+    });
+
+/**
+ * Returns a decoder for 128-bit signed integers (`i128`).
+ *
+ * This decoder deserializes `i128` values from 16 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI128Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `i128` values.
+ *
+ * @example
+ * Decoding an `i128` value.
+ * ```ts
+ * const decoder = getI128Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ *   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI128Codec}
+ */
+export const getI128Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<bigint, 16> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => {
+            const leftOffset = le ? 8 : 0;
+            const rightOffset = le ? 0 : 8;
+            const left = view.getBigInt64(leftOffset, le);
+            const right = view.getBigUint64(rightOffset, le);
+            return (left << 64n) + right;
+        },
+        name: 'i128',
+        size: 16,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 128-bit signed integers (`i128`).
+ *
+ * This codec serializes `i128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `i128` values.
+ *
+ * @example
+ * Encoding and decoding an `i128` value.
+ * ```ts
+ * const codec = getI128Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffffffffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^127` and `2^127 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI64Codec} or {@link getI32Codec}.
+ * - If you need a larger signed integer, consider using a custom codec.
+ * - If you need unsigned integers, consider using {@link getU128Codec}.
+ *
+ * Separate {@link getI128Encoder} and {@link getI128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI128Encoder().encode(-42);
+ * const value = getI128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI128Encoder}
+ * @see {@link getI128Decoder}
+ */
+export const getI128Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, bigint, 16> =>
+    combineCodec(getI128Encoder(config), getI128Decoder(config));

node_modules/@solana/codecs-numbers/src/i16.ts

@@ -0,0 +1,105 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 16-bit signed integers (`i16`).
+ *
+ * This encoder serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `i16` values.
+ *
+ * @example
+ * Encoding an `i16` value.
+ * ```ts
+ * const encoder = getI16Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ff
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export const getI16Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 2> =>
+    numberEncoderFactory({
+        config,
+        name: 'i16',
+        range: [-Number('0x7fff') - 1, Number('0x7fff')],
+        set: (view, value, le) => view.setInt16(0, Number(value), le),
+        size: 2,
+    });
+
+/**
+ * Returns a decoder for 16-bit signed integers (`i16`).
+ *
+ * This decoder deserializes `i16` values from 2 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI16Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `i16` values.
+ *
+ * @example
+ * Decoding an `i16` value.
+ * ```ts
+ * const decoder = getI16Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI16Codec}
+ */
+export const getI16Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 2> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getInt16(0, le),
+        name: 'i16',
+        size: 2,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 16-bit signed integers (`i16`).
+ *
+ * This codec serializes `i16` values using 2 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `i16` values.
+ *
+ * @example
+ * Encoding and decoding an `i16` value.
+ * ```ts
+ * const codec = getI16Codec();
+ * const bytes = codec.encode(-42); // 0xd6ff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^15` (`-32,768`) and `2^15 - 1` (`32,767`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI32Codec}.
+ * - If you need unsigned integers, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getI16Encoder} and {@link getI16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI16Encoder().encode(-42);
+ * const value = getI16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI16Encoder}
+ * @see {@link getI16Decoder}
+ */
+export const getI16Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 2> =>
+    combineCodec(getI16Encoder(config), getI16Decoder(config));

node_modules/@solana/codecs-numbers/src/i32.ts

@@ -0,0 +1,105 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 32-bit signed integers (`i32`).
+ *
+ * This encoder serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 4>` for encoding `i32` values.
+ *
+ * @example
+ * Encoding an `i32` value.
+ * ```ts
+ * const encoder = getI32Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6ffffff
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export const getI32Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 4> =>
+    numberEncoderFactory({
+        config,
+        name: 'i32',
+        range: [-Number('0x7fffffff') - 1, Number('0x7fffffff')],
+        set: (view, value, le) => view.setInt32(0, Number(value), le),
+        size: 4,
+    });
+
+/**
+ * Returns a decoder for 32-bit signed integers (`i32`).
+ *
+ * This decoder deserializes `i32` values from 4 bytes.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI32Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `i32` values.
+ *
+ * @example
+ * Decoding an `i32` value.
+ * ```ts
+ * const decoder = getI32Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6, 0xff, 0xff, 0xff])); // -42
+ * ```
+ *
+ * @see {@link getI32Codec}
+ */
+export const getI32Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 4> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getInt32(0, le),
+        name: 'i32',
+        size: 4,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 32-bit signed integers (`i32`).
+ *
+ * This codec serializes `i32` values using 4 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, number, 4>` for encoding and decoding `i32` values.
+ *
+ * @example
+ * Encoding and decoding an `i32` value.
+ * ```ts
+ * const codec = getI32Codec();
+ * const bytes = codec.encode(-42); // 0xd6ffffff
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42); // 0xffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^31` (`-2,147,483,648`) and `2^31 - 1` (`2,147,483,647`).
+ *
+ * - If you need a smaller signed integer, consider using {@link getI16Codec} or {@link getI8Codec}.
+ * - If you need a larger signed integer, consider using {@link getI64Codec}.
+ * - If you need unsigned integers, consider using {@link getU32Codec}.
+ *
+ * Separate {@link getI32Encoder} and {@link getI32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI32Encoder().encode(-42);
+ * const value = getI32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI32Encoder}
+ * @see {@link getI32Decoder}
+ */
+export const getI32Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 4> =>
+    combineCodec(getI32Encoder(config), getI32Decoder(config));

node_modules/@solana/codecs-numbers/src/i64.ts

@@ -0,0 +1,108 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 64-bit signed integers (`i64`).
+ *
+ * This encoder serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `i64` values.
+ *
+ * @example
+ * Encoding an `i64` value.
+ * ```ts
+ * const encoder = getI64Encoder();
+ * const bytes = encoder.encode(-42n); // 0xd6ffffffffffffff
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export const getI64Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 8> =>
+    numberEncoderFactory({
+        config,
+        name: 'i64',
+        range: [-BigInt('0x7fffffffffffffff') - 1n, BigInt('0x7fffffffffffffff')],
+        set: (view, value, le) => view.setBigInt64(0, BigInt(value), le),
+        size: 8,
+    });
+
+/**
+ * Returns a decoder for 64-bit signed integers (`i64`).
+ *
+ * This decoder deserializes `i64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getI64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `i64` values.
+ *
+ * @example
+ * Decoding an `i64` value.
+ * ```ts
+ * const decoder = getI64Decoder();
+ * const value = decoder.decode(new Uint8Array([
+ *   0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+ * ])); // -42n
+ * ```
+ *
+ * @see {@link getI64Codec}
+ */
+export const getI64Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<bigint, 8> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getBigInt64(0, le),
+        name: 'i64',
+        size: 8,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 64-bit signed integers (`i64`).
+ *
+ * This codec serializes `i64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `i64` values.
+ *
+ * @example
+ * Encoding and decoding an `i64` value.
+ * ```ts
+ * const codec = getI64Codec();
+ * const bytes = codec.encode(-42n); // 0xd6ffffffffffffff
+ * const value = codec.decode(bytes); // -42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getI64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(-42n); // 0xffffffffffffffd6
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^63` and `2^63 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller signed integer, consider using {@link getI32Codec} or {@link getI16Codec}.
+ * - If you need a larger signed integer, consider using {@link getI128Codec}.
+ * - If you need unsigned integers, consider using {@link getU64Codec}.
+ *
+ * Separate {@link getI64Encoder} and {@link getI64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI64Encoder().encode(-42);
+ * const value = getI64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI64Encoder}
+ * @see {@link getI64Decoder}
+ */
+export const getI64Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, bigint, 8> =>
+    combineCodec(getI64Encoder(config), getI64Decoder(config));

node_modules/@solana/codecs-numbers/src/i8.ts

@@ -0,0 +1,91 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 8-bit signed integers (`i8`).
+ *
+ * This encoder serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `i8` values.
+ *
+ * @example
+ * Encoding an `i8` value.
+ * ```ts
+ * const encoder = getI8Encoder();
+ * const bytes = encoder.encode(-42); // 0xd6
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export const getI8Encoder = (): FixedSizeEncoder<bigint | number, 1> =>
+    numberEncoderFactory({
+        name: 'i8',
+        range: [-Number('0x7f') - 1, Number('0x7f')],
+        set: (view, value) => view.setInt8(0, Number(value)),
+        size: 1,
+    });
+
+/**
+ * Returns a decoder for 8-bit signed integers (`i8`).
+ *
+ * This decoder deserializes `i8` values from 1 byte.
+ * The decoded value is always a `number`.
+ *
+ * For more details, see {@link getI8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `i8` values.
+ *
+ * @example
+ * Decoding an `i8` value.
+ * ```ts
+ * const decoder = getI8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xd6])); // -42
+ * ```
+ *
+ * @see {@link getI8Codec}
+ */
+export const getI8Decoder = (): FixedSizeDecoder<number, 1> =>
+    numberDecoderFactory({
+        get: view => view.getInt8(0),
+        name: 'i8',
+        size: 1,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 8-bit signed integers (`i8`).
+ *
+ * This codec serializes `i8` values using 1 byte.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `number`.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `i8` values.
+ *
+ * @example
+ * Encoding and decoding an `i8` value.
+ * ```ts
+ * const codec = getI8Codec();
+ * const bytes = codec.encode(-42); // 0xd6
+ * const value = codec.decode(bytes); // -42
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `-2^7` (`-128`) and `2^7 - 1` (`127`).
+ *
+ * - If you need a larger signed integer, consider using {@link getI16Codec}.
+ * - If you need an unsigned integer, consider using {@link getU8Codec}.
+ *
+ * Separate {@link getI8Encoder} and {@link getI8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getI8Encoder().encode(-42);
+ * const value = getI8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getI8Encoder}
+ * @see {@link getI8Decoder}
+ */
+export const getI8Codec = (): FixedSizeCodec<bigint | number, number, 1> =>
+    combineCodec(getI8Encoder(), getI8Decoder());

node_modules/@solana/codecs-numbers/src/index.ts

@@ -0,0 +1,25 @@
+/**
+ * This package contains codecs for numbers of different sizes and endianness.
+ * It can be used standalone, but it is also exported as part of Kit
+ * [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * This package is also part of the [`@solana/codecs` package](https://github.com/anza-xyz/kit/tree/main/packages/codecs)
+ * which acts as an entry point for all codec packages as well as for their documentation.
+ *
+ * @packageDocumentation
+ */
+export * from './assertions';
+export * from './common';
+export * from './f32';
+export * from './f64';
+export * from './i128';
+export * from './i16';
+export * from './i32';
+export * from './i64';
+export * from './i8';
+export * from './short-u16';
+export * from './u128';
+export * from './u16';
+export * from './u32';
+export * from './u64';
+export * from './u8';

node_modules/@solana/codecs-numbers/src/short-u16.ts

@@ -0,0 +1,158 @@
+import {
+    combineCodec,
+    createDecoder,
+    createEncoder,
+    Offset,
+    ReadonlyUint8Array,
+    VariableSizeCodec,
+    VariableSizeDecoder,
+    VariableSizeEncoder,
+} from '@solana/codecs-core';
+
+import { assertNumberIsBetweenForCodec } from './assertions';
+
+/**
+ * Returns an encoder for `shortU16` values.
+ *
+ * This encoder serializes `shortU16` values using **1 to 3 bytes**.
+ * Smaller values use fewer bytes, while larger values take up more space.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeEncoder<number | bigint>` for encoding `shortU16` values.
+ *
+ * @example
+ * Encoding a `shortU16` value.
+ * ```ts
+ * const encoder = getShortU16Encoder();
+ * encoder.encode(42);    // 0x2a
+ * encoder.encode(128);   // 0x8001
+ * encoder.encode(16384); // 0x808001
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export const getShortU16Encoder = (): VariableSizeEncoder<bigint | number> =>
+    createEncoder({
+        getSizeFromValue: (value: bigint | number): number => {
+            if (value <= 0b01111111) return 1;
+            if (value <= 0b0011111111111111) return 2;
+            return 3;
+        },
+        maxSize: 3,
+        write: (value: bigint | number, bytes: Uint8Array, offset: Offset): Offset => {
+            assertNumberIsBetweenForCodec('shortU16', 0, 65535, value);
+            const shortU16Bytes = [0];
+            for (let ii = 0; ; ii += 1) {
+                // Shift the bits of the value over such that the next 7 bits are at the right edge.
+                const alignedValue = Number(value) >> (ii * 7);
+                if (alignedValue === 0) {
+                    // No more bits to consume.
+                    break;
+                }
+                // Extract those 7 bits using a mask.
+                const nextSevenBits = 0b1111111 & alignedValue;
+                shortU16Bytes[ii] = nextSevenBits;
+                if (ii > 0) {
+                    // Set the continuation bit of the previous slice.
+                    shortU16Bytes[ii - 1] |= 0b10000000;
+                }
+            }
+            bytes.set(shortU16Bytes, offset);
+            return offset + shortU16Bytes.length;
+        },
+    });
+
+/**
+ * Returns a decoder for `shortU16` values.
+ *
+ * This decoder deserializes `shortU16` values from **1 to 3 bytes**.
+ * The number of bytes used depends on the encoded value.
+ *
+ * For more details, see {@link getShortU16Codec}.
+ *
+ * @returns A `VariableSizeDecoder<number>` for decoding `shortU16` values.
+ *
+ * @example
+ * Decoding a `shortU16` value.
+ * ```ts
+ * const decoder = getShortU16Decoder();
+ * decoder.decode(new Uint8Array([0x2a]));             // 42
+ * decoder.decode(new Uint8Array([0x80, 0x01]));       // 128
+ * decoder.decode(new Uint8Array([0x80, 0x80, 0x01])); // 16384
+ * ```
+ *
+ * @see {@link getShortU16Codec}
+ */
+export const getShortU16Decoder = (): VariableSizeDecoder<number> =>
+    createDecoder({
+        maxSize: 3,
+        read: (bytes: ReadonlyUint8Array | Uint8Array, offset): [number, Offset] => {
+            let value = 0;
+            let byteCount = 0;
+            while (++byteCount) {
+                const byteIndex = byteCount - 1;
+                const currentByte = bytes[offset + byteIndex];
+                const nextSevenBits = 0b1111111 & currentByte;
+                // Insert the next group of seven bits into the correct slot of the output value.
+                value |= nextSevenBits << (byteIndex * 7);
+                if ((currentByte & 0b10000000) === 0) {
+                    // This byte does not have its continuation bit set. We're done.
+                    break;
+                }
+            }
+            return [value, offset + byteCount];
+        },
+    });
+
+/**
+ * Returns a codec for encoding and decoding `shortU16` values.
+ *
+ * It serializes unsigned integers using **1 to 3 bytes** based on the encoded value.
+ * The larger the value, the more bytes it uses.
+ *
+ * - If the value is `<= 0x7f` (127), it is stored in a **single byte**
+ *   and the first bit is set to `0` to indicate the end of the value.
+ * - Otherwise, the first bit is set to `1` to indicate that the value continues in the next byte, which follows the same pattern.
+ * - This process repeats until the value is fully encoded in up to 3 bytes. The third and last byte, if needed, uses all 8 bits to store the remaining value.
+ *
+ * In other words, the encoding scheme follows this structure:
+ *
+ * ```txt
+ * 0XXXXXXX                   <- Values 0 to 127 (1 byte)
+ * 1XXXXXXX 0XXXXXXX          <- Values 128 to 16,383 (2 bytes)
+ * 1XXXXXXX 1XXXXXXX XXXXXXXX <- Values 16,384 to 4,194,303 (3 bytes)
+ * ```
+ *
+ * @returns A `VariableSizeCodec<number | bigint, number>` for encoding and decoding `shortU16` values.
+ *
+ * @example
+ * Encoding and decoding `shortU16` values.
+ * ```ts
+ * const codec = getShortU16Codec();
+ * const bytes1 = codec.encode(42);    // 0x2a
+ * const bytes2 = codec.encode(128);   // 0x8001
+ * const bytes3 = codec.encode(16384); // 0x808001
+ *
+ * codec.decode(bytes1); // 42
+ * codec.decode(bytes2); // 128
+ * codec.decode(bytes3); // 16384
+ * ```
+ *
+ * @remarks
+ * This codec efficiently stores small numbers, making it useful for transactions and compact representations.
+ *
+ * If you need a fixed-size `u16` codec, consider using {@link getU16Codec}.
+ *
+ * Separate {@link getShortU16Encoder} and {@link getShortU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getShortU16Encoder().encode(42);
+ * const value = getShortU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getShortU16Encoder}
+ * @see {@link getShortU16Decoder}
+ */
+export const getShortU16Codec = (): VariableSizeCodec<bigint | number, number> =>
+    combineCodec(getShortU16Encoder(), getShortU16Decoder());

node_modules/@solana/codecs-numbers/src/u128.ts

@@ -0,0 +1,117 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 128-bit unsigned integers (`u128`).
+ *
+ * This encoder serializes `u128` values using sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 16>` for encoding `u128` values.
+ *
+ * @example
+ * Encoding a `u128` value.
+ * ```ts
+ * const encoder = getU128Encoder();
+ * const bytes = encoder.encode(42n); // 0x2a000000000000000000000000000000
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export const getU128Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 16> =>
+    numberEncoderFactory({
+        config,
+        name: 'u128',
+        range: [0n, BigInt('0xffffffffffffffffffffffffffffffff')],
+        set: (view, value, le) => {
+            const leftOffset = le ? 8 : 0;
+            const rightOffset = le ? 0 : 8;
+            const rightMask = 0xffffffffffffffffn;
+            view.setBigUint64(leftOffset, BigInt(value) >> 64n, le);
+            view.setBigUint64(rightOffset, BigInt(value) & rightMask, le);
+        },
+        size: 16,
+    });
+
+/**
+ * Returns a decoder for 128-bit unsigned integers (`u128`).
+ *
+ * This decoder deserializes `u128` values from sixteen bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU128Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<bigint, 16>` for decoding `u128` values.
+ *
+ * @example
+ * Decoding a `u128` value.
+ * ```ts
+ * const decoder = getU128Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU128Codec}
+ */
+export const getU128Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<bigint, 16> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => {
+            const leftOffset = le ? 8 : 0;
+            const rightOffset = le ? 0 : 8;
+            const left = view.getBigUint64(leftOffset, le);
+            const right = view.getBigUint64(rightOffset, le);
+            return (left << 64n) + right;
+        },
+        name: 'u128',
+        size: 16,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 128-bit unsigned integers (`u128`).
+ *
+ * This codec serializes `u128` values using 16 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 16>` for encoding and decoding `u128` values.
+ *
+ * @example
+ * Encoding and decoding a `u128` value.
+ * ```ts
+ * const codec = getU128Codec();
+ * const bytes = codec.encode(42); // 0x2a000000000000000000000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU128Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000000000000000000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^128 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU64Codec} or {@link getU32Codec}.
+ * - If you need signed integers, consider using {@link getI128Codec}.
+ *
+ * Separate {@link getU128Encoder} and {@link getU128Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU128Encoder().encode(42);
+ * const value = getU128Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU128Encoder}
+ * @see {@link getU128Decoder}
+ */
+export const getU128Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, bigint, 16> =>
+    combineCodec(getU128Encoder(config), getU128Decoder(config));

node_modules/@solana/codecs-numbers/src/u16.ts

@@ -0,0 +1,103 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 16-bit unsigned integers (`u16`).
+ *
+ * This encoder serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<number | bigint, 2>` for encoding `u16` values.
+ *
+ * @example
+ * Encoding a `u16` value.
+ * ```ts
+ * const encoder = getU16Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export const getU16Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 2> =>
+    numberEncoderFactory({
+        config,
+        name: 'u16',
+        range: [0, Number('0xffff')],
+        set: (view, value, le) => view.setUint16(0, Number(value), le),
+        size: 2,
+    });
+
+/**
+ * Returns a decoder for 16-bit unsigned integers (`u16`).
+ *
+ * This decoder deserializes `u16` values from two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU16Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 2>` for decoding `u16` values.
+ *
+ * @example
+ * Decoding a `u16` value.
+ * ```ts
+ * const decoder = getU16Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU16Codec}
+ */
+export const getU16Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 2> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getUint16(0, le),
+        name: 'u16',
+        size: 2,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 16-bit unsigned integers (`u16`).
+ *
+ * This codec serializes `u16` values using two bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<number | bigint, number, 2>` for encoding and decoding `u16` values.
+ *
+ * @example
+ * Encoding and decoding a `u16` value.
+ * ```ts
+ * const codec = getU16Codec();
+ * const bytes = codec.encode(42); // 0x2a00 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU16Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^16 - 1`.
+ * If you need a larger range, consider using {@link getU32Codec} or {@link getU64Codec}.
+ * For signed integers, use {@link getI16Codec}.
+ *
+ * Separate {@link getU16Encoder} and {@link getU16Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU16Encoder().encode(42);
+ * const value = getU16Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU16Encoder}
+ * @see {@link getU16Decoder}
+ */
+export const getU16Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 2> =>
+    combineCodec(getU16Encoder(config), getU16Decoder(config));

node_modules/@solana/codecs-numbers/src/u32.ts

@@ -0,0 +1,103 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 32-bit unsigned integers (`u32`).
+ *
+ * This encoder serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeEncoder<bigint | number, 4>` for encoding `u32` values.
+ *
+ * @example
+ * Encoding a `u32` value.
+ * ```ts
+ * const encoder = getU32Encoder();
+ * const bytes = encoder.encode(42); // 0x2a000000
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export const getU32Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 4> =>
+    numberEncoderFactory({
+        config,
+        name: 'u32',
+        range: [0, Number('0xffffffff')],
+        set: (view, value, le) => view.setUint32(0, Number(value), le),
+        size: 4,
+    });
+
+/**
+ * Returns a decoder for 32-bit unsigned integers (`u32`).
+ *
+ * This decoder deserializes `u32` values from four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * For more details, see {@link getU32Codec}.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeDecoder<number, 4>` for decoding `u32` values.
+ *
+ * @example
+ * Decoding a `u32` value.
+ * ```ts
+ * const decoder = getU32Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00])); // 42
+ * ```
+ *
+ * @see {@link getU32Codec}
+ */
+export const getU32Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<number, 4> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getUint32(0, le),
+        name: 'u32',
+        size: 4,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 32-bit unsigned integers (`u32`).
+ *
+ * This codec serializes `u32` values using four bytes in little-endian format by default.
+ * You may specify big-endian storage using the `endian` option.
+ *
+ * @param config - Optional settings for endianness.
+ * @returns A `FixedSizeCodec<bigint | number, number, 4>` for encoding and decoding `u32` values.
+ *
+ * @example
+ * Encoding and decoding a `u32` value.
+ * ```ts
+ * const codec = getU32Codec();
+ * const bytes = codec.encode(42); // 0x2a000000 (little-endian)
+ * const value = codec.decode(bytes); // 42
+ * ```
+ *
+ * @example
+ * Storing values in big-endian format.
+ * ```ts
+ * const codec = getU32Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x0000002a
+ * ```
+ *
+ * @remarks
+ * This codec only supports values between `0` and `2^32 - 1`.
+ * If you need a larger range, consider using {@link getU64Codec} or {@link getU128Codec}.
+ * For signed integers, use {@link getI32Codec}.
+ *
+ * Separate {@link getU32Encoder} and {@link getU32Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU32Encoder().encode(42);
+ * const value = getU32Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU32Encoder}
+ * @see {@link getU32Decoder}
+ */
+export const getU32Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, number, 4> =>
+    combineCodec(getU32Encoder(config), getU32Decoder(config));

node_modules/@solana/codecs-numbers/src/u64.ts

@@ -0,0 +1,106 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { NumberCodecConfig } from './common';
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 64-bit unsigned integers (`u64`).
+ *
+ * This encoder serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeEncoder<number | bigint, 8>` for encoding `u64` values.
+ *
+ * @example
+ * Encoding a `u64` value.
+ * ```ts
+ * const encoder = getU64Encoder();
+ * const bytes = encoder.encode(42); // 0x2a00000000000000
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export const getU64Encoder = (config: NumberCodecConfig = {}): FixedSizeEncoder<bigint | number, 8> =>
+    numberEncoderFactory({
+        config,
+        name: 'u64',
+        range: [0n, BigInt('0xffffffffffffffff')],
+        set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+        size: 8,
+    });
+
+/**
+ * Returns a decoder for 64-bit unsigned integers (`u64`).
+ *
+ * This decoder deserializes `u64` values from 8 bytes.
+ * The decoded value is always a `bigint`.
+ *
+ * For more details, see {@link getU64Codec}.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeDecoder<bigint, 8>` for decoding `u64` values.
+ *
+ * @example
+ * Decoding a `u64` value.
+ * ```ts
+ * const decoder = getU64Decoder();
+ * const value = decoder.decode(new Uint8Array([0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])); // 42n
+ * ```
+ *
+ * @see {@link getU64Codec}
+ */
+export const getU64Decoder = (config: NumberCodecConfig = {}): FixedSizeDecoder<bigint, 8> =>
+    numberDecoderFactory({
+        config,
+        get: (view, le) => view.getBigUint64(0, le),
+        name: 'u64',
+        size: 8,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 64-bit unsigned integers (`u64`).
+ *
+ * This codec serializes `u64` values using 8 bytes.
+ * Values can be provided as either `number` or `bigint`, but the decoded value is always a `bigint`.
+ *
+ * @param config - Optional configuration to specify endianness (little by default).
+ * @returns A `FixedSizeCodec<number | bigint, bigint, 8>` for encoding and decoding `u64` values.
+ *
+ * @example
+ * Encoding and decoding a `u64` value.
+ * ```ts
+ * const codec = getU64Codec();
+ * const bytes = codec.encode(42); // 0x2a00000000000000
+ * const value = codec.decode(bytes); // 42n
+ * ```
+ *
+ * @example
+ * Using big-endian encoding.
+ * ```ts
+ * const codec = getU64Codec({ endian: Endian.Big });
+ * const bytes = codec.encode(42); // 0x000000000000002a
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^64 - 1`.
+ * Since JavaScript `number` cannot safely represent values beyond `2^53 - 1`, the decoded value is always a `bigint`.
+ *
+ * - If you need a smaller unsigned integer, consider using {@link getU32Codec} or {@link getU16Codec}.
+ * - If you need a larger unsigned integer, consider using {@link getU128Codec}.
+ * - If you need signed integers, consider using {@link getI64Codec}.
+ *
+ * Separate {@link getU64Encoder} and {@link getU64Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU64Encoder().encode(42);
+ * const value = getU64Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU64Encoder}
+ * @see {@link getU64Decoder}
+ */
+export const getU64Codec = (config: NumberCodecConfig = {}): FixedSizeCodec<bigint | number, bigint, 8> =>
+    combineCodec(getU64Encoder(config), getU64Decoder(config));

node_modules/@solana/codecs-numbers/src/u8.ts

@@ -0,0 +1,87 @@
+import { combineCodec, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from '@solana/codecs-core';
+
+import { numberDecoderFactory, numberEncoderFactory } from './utils';
+
+/**
+ * Returns an encoder for 8-bit unsigned integers (`u8`).
+ *
+ * This encoder serializes `u8` values using a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeEncoder<number | bigint, 1>` for encoding `u8` values.
+ *
+ * @example
+ * Encoding a `u8` value.
+ * ```ts
+ * const encoder = getU8Encoder();
+ * const bytes = encoder.encode(42); // 0x2a
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export const getU8Encoder = (): FixedSizeEncoder<bigint | number, 1> =>
+    numberEncoderFactory({
+        name: 'u8',
+        range: [0, Number('0xff')],
+        set: (view, value) => view.setUint8(0, Number(value)),
+        size: 1,
+    });
+
+/**
+ * Returns a decoder for 8-bit unsigned integers (`u8`).
+ *
+ * This decoder deserializes `u8` values from a single byte.
+ *
+ * For more details, see {@link getU8Codec}.
+ *
+ * @returns A `FixedSizeDecoder<number, 1>` for decoding `u8` values.
+ *
+ * @example
+ * Decoding a `u8` value.
+ * ```ts
+ * const decoder = getU8Decoder();
+ * const value = decoder.decode(new Uint8Array([0xff])); // 255
+ * ```
+ *
+ * @see {@link getU8Codec}
+ */
+export const getU8Decoder = (): FixedSizeDecoder<number, 1> =>
+    numberDecoderFactory({
+        get: view => view.getUint8(0),
+        name: 'u8',
+        size: 1,
+    });
+
+/**
+ * Returns a codec for encoding and decoding 8-bit unsigned integers (`u8`).
+ *
+ * This codec serializes `u8` values using a single byte.
+ *
+ * @returns A `FixedSizeCodec<number | bigint, number, 1>` for encoding and decoding `u8` values.
+ *
+ * @example
+ * Encoding and decoding a `u8` value.
+ * ```ts
+ * const codec = getU8Codec();
+ * const bytes = codec.encode(255); // 0xff
+ * const value = codec.decode(bytes); // 255
+ * ```
+ *
+ * @remarks
+ * This codec supports values between `0` and `2^8 - 1` (0 to 255).
+ * If you need larger integers, consider using {@link getU16Codec}, {@link getU32Codec}, or {@link getU64Codec}.
+ * For signed integers, use {@link getI8Codec}.
+ *
+ * Separate {@link getU8Encoder} and {@link getU8Decoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getU8Encoder().encode(42);
+ * const value = getU8Decoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getU8Encoder}
+ * @see {@link getU8Decoder}
+ */
+export const getU8Codec = (): FixedSizeCodec<bigint | number, number, 1> =>
+    combineCodec(getU8Encoder(), getU8Decoder());

node_modules/@solana/codecs-numbers/src/utils.ts

@@ -0,0 +1,63 @@
+import {
+    assertByteArrayHasEnoughBytesForCodec,
+    assertByteArrayIsNotEmptyForCodec,
+    createDecoder,
+    createEncoder,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    Offset,
+    toArrayBuffer,
+} from '@solana/codecs-core';
+
+import { assertNumberIsBetweenForCodec } from './assertions';
+import { Endian, NumberCodecConfig } from './common';
+
+type NumberFactorySharedInput<TSize extends number> = {
+    config?: NumberCodecConfig;
+    name: string;
+    size: TSize;
+};
+
+type NumberFactoryEncoderInput<TFrom, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    range?: [bigint | number, bigint | number];
+    set: (view: DataView, value: TFrom, littleEndian?: boolean) => void;
+};
+
+type NumberFactoryDecoderInput<TTo, TSize extends number> = NumberFactorySharedInput<TSize> & {
+    get: (view: DataView, littleEndian?: boolean) => TTo;
+};
+
+function isLittleEndian(config?: NumberCodecConfig): boolean {
+    return config?.endian === Endian.Big ? false : true;
+}
+
+export function numberEncoderFactory<TFrom extends bigint | number, TSize extends number>(
+    input: NumberFactoryEncoderInput<TFrom, TSize>,
+): FixedSizeEncoder<TFrom, TSize> {
+    return createEncoder({
+        fixedSize: input.size,
+        write(value: TFrom, bytes: Uint8Array, offset: Offset): Offset {
+            if (input.range) {
+                assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+            }
+            const arrayBuffer = new ArrayBuffer(input.size);
+            input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+            bytes.set(new Uint8Array(arrayBuffer), offset);
+            return offset + input.size;
+        },
+    });
+}
+
+export function numberDecoderFactory<TTo extends bigint | number, TSize extends number>(
+    input: NumberFactoryDecoderInput<TTo, TSize>,
+): FixedSizeDecoder<TTo, TSize> {
+    return createDecoder({
+        fixedSize: input.size,
+        read(bytes, offset = 0): [TTo, number] {
+            assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+            assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+            const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+            return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+        },
+    });
+}