@meteora-ag/cp-amm-sdk 1.0.2 → 1.0.4

package/node_modules/@solana/codecs-core/dist/types/reverse-codec.d.ts

@@ -0,0 +1,92 @@
+import { FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec';
+/**
+ * Reverses the bytes of a fixed-size encoder.
+ *
+ * Given a `FixedSizeEncoder`, this function returns a new `FixedSizeEncoder` that
+ * reverses the bytes within the fixed-size byte array when encoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * For more details, see {@link reverseCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TSize - The fixed size of the encoded value in bytes.
+ *
+ * @param encoder - The fixed-size encoder to reverse.
+ * @returns A new encoder that writes bytes in reverse order.
+ *
+ * @example
+ * Encoding a `u16` value in reverse order.
+ * ```ts
+ * const encoder = reverseEncoder(getU16Encoder({ endian: Endian.Big }));
+ * const bytes = encoder.encode(0x1234); // 0x3412 (bytes are flipped)
+ * ```
+ *
+ * @see {@link reverseCodec}
+ * @see {@link reverseDecoder}
+ */
+export declare function reverseEncoder<TFrom, TSize extends number>(encoder: FixedSizeEncoder<TFrom, TSize>): FixedSizeEncoder<TFrom, TSize>;
+/**
+ * Reverses the bytes of a fixed-size decoder.
+ *
+ * Given a `FixedSizeDecoder`, this function returns a new `FixedSizeDecoder` that
+ * reverses the bytes within the fixed-size byte array before decoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * For more details, see {@link reverseCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The fixed size of the decoded value in bytes.
+ *
+ * @param decoder - The fixed-size decoder to reverse.
+ * @returns A new decoder that reads bytes in reverse order.
+ *
+ * @example
+ * Decoding a reversed `u16` value.
+ * ```ts
+ * const decoder = reverseDecoder(getU16Decoder({ endian: Endian.Big }));
+ * const value = decoder.decode(new Uint8Array([0x34, 0x12])); // 0x1234 (bytes are flipped back)
+ * ```
+ *
+ * @see {@link reverseCodec}
+ * @see {@link reverseEncoder}
+ */
+export declare function reverseDecoder<TTo, TSize extends number>(decoder: FixedSizeDecoder<TTo, TSize>): FixedSizeDecoder<TTo, TSize>;
+/**
+ * Reverses the bytes of a fixed-size codec.
+ *
+ * Given a `FixedSizeCodec`, this function returns a new `FixedSizeCodec` that
+ * reverses the bytes within the fixed-size byte array during encoding and decoding.
+ *
+ * This can be useful to modify endianness or for other byte-order transformations.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The fixed size of the encoded/decoded value in bytes.
+ *
+ * @param codec - The fixed-size codec to reverse.
+ * @returns A new codec that encodes and decodes bytes in reverse order.
+ *
+ * @example
+ * Reversing a `u16` codec.
+ * ```ts
+ * const codec = reverseCodec(getU16Codec({ endian: Endian.Big }));
+ * const bytes = codec.encode(0x1234); // 0x3412 (bytes are flipped)
+ * const value = codec.decode(bytes);  // 0x1234 (bytes are flipped back)
+ * ```
+ *
+ * @remarks
+ * If you only need to reverse an encoder, use {@link reverseEncoder}.
+ * If you only need to reverse a decoder, use {@link reverseDecoder}.
+ *
+ * ```ts
+ * const bytes = reverseEncoder(getU16Encoder()).encode(0x1234);
+ * const value = reverseDecoder(getU16Decoder()).decode(bytes);
+ * ```
+ *
+ * @see {@link reverseEncoder}
+ * @see {@link reverseDecoder}
+ */
+export declare function reverseCodec<TFrom, TTo extends TFrom, TSize extends number>(codec: FixedSizeCodec<TFrom, TTo, TSize>): FixedSizeCodec<TFrom, TTo, TSize>;
+//# sourceMappingURL=reverse-codec.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/reverse-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-codec.d.ts","sourceRoot":"","sources":["../../src/reverse-codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EACnB,MAAM,SAAS,CAAC;AAsBjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,EACtD,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,GACxC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAehC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,KAAK,SAAS,MAAM,EACpD,OAAO,EAAE,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,GACtC,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAe9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE,KAAK,SAAS,MAAM,EACvE,KAAK,EAAE,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,GACzC,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAEnC"}

package/node_modules/@solana/codecs-core/dist/types/transform-codec.d.ts

@@ -0,0 +1,114 @@
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, VariableSizeCodec, VariableSizeDecoder, VariableSizeEncoder } from './codec';
+import { ReadonlyUint8Array } from './readonly-uint8array';
+/**
+ * Transforms an encoder by mapping its input values.
+ *
+ * This function takes an existing `Encoder<A>` and returns an `Encoder<B>`, allowing values of type `B`
+ * to be converted into values of type `A` before encoding. The transformation is applied via the `unmap` function.
+ *
+ * This is useful for handling type conversions, applying default values, or structuring data before encoding.
+ *
+ * For more details, see {@link transformCodec}.
+ *
+ * @typeParam TOldFrom - The original type expected by the encoder.
+ * @typeParam TNewFrom - The new type that will be transformed before encoding.
+ *
+ * @param encoder - The encoder to transform.
+ * @param unmap - A function that converts values of `TNewFrom` into `TOldFrom` before encoding.
+ * @returns A new encoder that accepts `TNewFrom` values and transforms them before encoding.
+ *
+ * @example
+ * Encoding a string by counting its characters and storing the length as a `u32`.
+ * ```ts
+ * const encoder = transformEncoder(getU32Encoder(), (value: string) => value.length);
+ * encoder.encode("hello"); // 0x05000000 (stores length 5)
+ * ```
+ *
+ * @see {@link transformCodec}
+ * @see {@link transformDecoder}
+ */
+export declare function transformEncoder<TOldFrom, TNewFrom, TSize extends number>(encoder: FixedSizeEncoder<TOldFrom, TSize>, unmap: (value: TNewFrom) => TOldFrom): FixedSizeEncoder<TNewFrom, TSize>;
+export declare function transformEncoder<TOldFrom, TNewFrom>(encoder: VariableSizeEncoder<TOldFrom>, unmap: (value: TNewFrom) => TOldFrom): VariableSizeEncoder<TNewFrom>;
+export declare function transformEncoder<TOldFrom, TNewFrom>(encoder: Encoder<TOldFrom>, unmap: (value: TNewFrom) => TOldFrom): Encoder<TNewFrom>;
+/**
+ * Transforms a decoder by mapping its output values.
+ *
+ * This function takes an existing `Decoder<A>` and returns a `Decoder<B>`, allowing values of type `A`
+ * to be converted into values of type `B` after decoding. The transformation is applied via the `map` function.
+ *
+ * This is useful for post-processing, type conversions, or enriching decoded data.
+ *
+ * For more details, see {@link transformCodec}.
+ *
+ * @typeParam TOldTo - The original type returned by the decoder.
+ * @typeParam TNewTo - The new type that will be transformed after decoding.
+ *
+ * @param decoder - The decoder to transform.
+ * @param map - A function that converts values of `TOldTo` into `TNewTo` after decoding.
+ * @returns A new decoder that decodes into `TNewTo`.
+ *
+ * @example
+ * Decoding a stored `u32` length into a string of `'x'` characters.
+ * ```ts
+ * const decoder = transformDecoder(getU32Decoder(), (length) => 'x'.repeat(length));
+ * decoder.decode(new Uint8Array([0x05, 0x00, 0x00, 0x00])); // "xxxxx"
+ * ```
+ *
+ * @see {@link transformCodec}
+ * @see {@link transformEncoder}
+ */
+export declare function transformDecoder<TOldTo, TNewTo, TSize extends number>(decoder: FixedSizeDecoder<TOldTo, TSize>, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): FixedSizeDecoder<TNewTo, TSize>;
+export declare function transformDecoder<TOldTo, TNewTo>(decoder: VariableSizeDecoder<TOldTo>, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): VariableSizeDecoder<TNewTo>;
+export declare function transformDecoder<TOldTo, TNewTo>(decoder: Decoder<TOldTo>, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): Decoder<TNewTo>;
+/**
+ * Transforms a codec by mapping its input and output values.
+ *
+ * This function takes an existing `Codec<A, B>` and returns a `Codec<C, D>`, allowing:
+ * - Values of type `C` to be transformed into `A` before encoding.
+ * - Values of type `B` to be transformed into `D` after decoding.
+ *
+ * This is useful for adapting codecs to work with different representations, handling default values, or
+ * converting between primitive and structured types.
+ *
+ * @typeParam TOldFrom - The original type expected by the codec.
+ * @typeParam TNewFrom - The new type that will be transformed before encoding.
+ * @typeParam TOldTo - The original type returned by the codec.
+ * @typeParam TNewTo - The new type that will be transformed after decoding.
+ *
+ * @param codec - The codec to transform.
+ * @param unmap - A function that converts values of `TNewFrom` into `TOldFrom` before encoding.
+ * @param map - A function that converts values of `TOldTo` into `TNewTo` after decoding (optional).
+ * @returns A new codec that encodes `TNewFrom` and decodes into `TNewTo`.
+ *
+ * @example
+ * Mapping a `u32` codec to encode string lengths and decode them into `'x'` characters.
+ * ```ts
+ * const codec = transformCodec(
+ *     getU32Codec(),
+ *     (value: string) => value.length, // Encode string length
+ *     (length) => 'x'.repeat(length)  // Decode length into a string of 'x's
+ * );
+ *
+ * const bytes = codec.encode("hello"); // 0x05000000 (stores length 5)
+ * const value = codec.decode(bytes);   // "xxxxx"
+ * ```
+ *
+ * @remarks
+ * If only input transformation is needed, use {@link transformEncoder}.
+ * If only output transformation is needed, use {@link transformDecoder}.
+ *
+ * ```ts
+ * const bytes = transformEncoder(getU32Encoder(), (value: string) => value.length).encode("hello");
+ * const value = transformDecoder(getU32Decoder(), (length) => 'x'.repeat(length)).decode(bytes);
+ * ```
+ *
+ * @see {@link transformEncoder}
+ * @see {@link transformDecoder}
+ */
+export declare function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom, TSize extends number>(codec: FixedSizeCodec<TOldFrom, TTo, TSize>, unmap: (value: TNewFrom) => TOldFrom): FixedSizeCodec<TNewFrom, TTo, TSize>;
+export declare function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(codec: VariableSizeCodec<TOldFrom, TTo>, unmap: (value: TNewFrom) => TOldFrom): VariableSizeCodec<TNewFrom, TTo>;
+export declare function transformCodec<TOldFrom, TNewFrom, TTo extends TNewFrom & TOldFrom>(codec: Codec<TOldFrom, TTo>, unmap: (value: TNewFrom) => TOldFrom): Codec<TNewFrom, TTo>;
+export declare function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom, TSize extends number>(codec: FixedSizeCodec<TOldFrom, TOldTo, TSize>, unmap: (value: TNewFrom) => TOldFrom, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): FixedSizeCodec<TNewFrom, TNewTo, TSize>;
+export declare function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(codec: VariableSizeCodec<TOldFrom, TOldTo>, unmap: (value: TNewFrom) => TOldFrom, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): VariableSizeCodec<TNewFrom, TNewTo>;
+export declare function transformCodec<TOldFrom, TNewFrom, TOldTo extends TOldFrom, TNewTo extends TNewFrom>(codec: Codec<TOldFrom, TOldTo>, unmap: (value: TNewFrom) => TOldFrom, map: (value: TOldTo, bytes: ReadonlyUint8Array | Uint8Array, offset: number) => TNewTo): Codec<TNewFrom, TNewTo>;
+//# sourceMappingURL=transform-codec.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/transform-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-codec.d.ts","sourceRoot":"","sources":["../../src/transform-codec.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,83 @@
+{
+  "name": "@solana/codecs-core",
+  "version": "2.1.1",
+  "description": "Core types and helpers for encoding and decoding byte arrays on Solana",
+  "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/"
+  ],
+  "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": "2.1.1"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.3.3"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "scripts": {
+    "benchmark": "./src/__benchmarks__/run.ts",
+    "compile:docs": "typedoc",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "dev": "jest -c ../../node_modules/@solana/test-config/jest-dev.config.ts --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 && (([ \"$PUBLISH_TAG\" != \"canary\" ] && pnpm dist-tag add $npm_package_name@$npm_package_version latest) || 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.ts --rootDir . --silent",
+    "test:prettier": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.ts --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": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.browser.ts --rootDir . --silent",
+    "test:unit:node": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.node.ts --rootDir . --silent"
+  }
+}

package/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.

package/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).