@meteora-ag/cp-amm-sdk 1.0.0-rc.9 → 1.0.1-1.rc-0

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

@@ -0,0 +1,328 @@
+import { Codec, Decoder, Encoder, Offset } from './codec';
+import { ReadonlyUint8Array } from './readonly-uint8array';
+type AnyEncoder = Encoder<any>;
+type AnyDecoder = Decoder<any>;
+type AnyCodec = Codec<any>;
+/**
+ * Configuration object for modifying the offset of an encoder, decoder, or codec.
+ *
+ * This type defines optional functions for adjusting the **pre-offset** (before encoding/decoding)
+ * and the **post-offset** (after encoding/decoding). These functions allow precise control
+ * over where data is written or read within a byte array.
+ *
+ * @property preOffset - A function that modifies the offset before encoding or decoding.
+ * @property postOffset - A function that modifies the offset after encoding or decoding.
+ *
+ * @example
+ * Moving the pre-offset forward by 2 bytes.
+ * ```ts
+ * const config: OffsetConfig = {
+ *     preOffset: ({ preOffset }) => preOffset + 2,
+ * };
+ * ```
+ *
+ * @example
+ * Moving the post-offset forward by 2 bytes.
+ * ```ts
+ * const config: OffsetConfig = {
+ *     postOffset: ({ postOffset }) => postOffset + 2,
+ * };
+ * ```
+ *
+ * @example
+ * Using both pre-offset and post-offset together.
+ * ```ts
+ * const config: OffsetConfig = {
+ *     preOffset: ({ preOffset }) => preOffset + 2,
+ *     postOffset: ({ postOffset }) => postOffset + 4,
+ * };
+ * ```
+ *
+ * @see {@link offsetEncoder}
+ * @see {@link offsetDecoder}
+ * @see {@link offsetCodec}
+ */
+type OffsetConfig = {
+    postOffset?: PostOffsetFunction;
+    preOffset?: PreOffsetFunction;
+};
+/**
+ * Scope provided to the `preOffset` and `postOffset` functions,
+ * containing contextual information about the current encoding or decoding process.
+ *
+ * The pre-offset function modifies where encoding or decoding begins,
+ * while the post-offset function modifies where the next operation continues.
+ *
+ * @property bytes - The entire byte array being encoded or decoded.
+ * @property preOffset - The original offset before encoding or decoding starts.
+ * @property wrapBytes - A helper function that wraps offsets around the byte array length.
+ *
+ * @example
+ * Using `wrapBytes` to wrap a negative offset to the end of the byte array.
+ * ```ts
+ * const config: OffsetConfig = {
+ *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves to last 4 bytes
+ * };
+ * ```
+ *
+ * @example
+ * Adjusting the offset dynamically based on the byte array size.
+ * ```ts
+ * const config: OffsetConfig = {
+ *     preOffset: ({ bytes }) => bytes.length > 10 ? 4 : 2,
+ * };
+ * ```
+ *
+ * @see {@link PreOffsetFunction}
+ * @see {@link PostOffsetFunction}
+ */
+type PreOffsetFunctionScope = {
+    /** The entire byte array. */
+    bytes: ReadonlyUint8Array | Uint8Array;
+    /** The original offset prior to encode or decode. */
+    preOffset: Offset;
+    /** Wraps the offset to the byte array length. */
+    wrapBytes: (offset: Offset) => Offset;
+};
+/**
+ * A function that modifies the pre-offset before encoding or decoding.
+ *
+ * This function is used to adjust the starting position before writing
+ * or reading data in a byte array.
+ *
+ * @param scope - The current encoding or decoding context.
+ * @returns The new offset at which encoding or decoding should start.
+ *
+ * @example
+ * Skipping the first 2 bytes before writing or reading.
+ * ```ts
+ * const preOffset: PreOffsetFunction = ({ preOffset }) => preOffset + 2;
+ * ```
+ *
+ * @example
+ * Wrapping the offset to ensure it stays within bounds.
+ * ```ts
+ * const preOffset: PreOffsetFunction = ({ wrapBytes, preOffset }) => wrapBytes(preOffset + 10);
+ * ```
+ *
+ * @see {@link OffsetConfig}
+ * @see {@link PreOffsetFunctionScope}
+ */
+type PreOffsetFunction = (scope: PreOffsetFunctionScope) => Offset;
+/**
+ * A function that modifies the post-offset after encoding or decoding.
+ *
+ * This function adjusts where the next encoder or decoder should start
+ * after the current operation has completed.
+ *
+ * @param scope - The current encoding or decoding context, including the modified pre-offset
+ * and the original post-offset.
+ * @returns The new offset at which the next operation should begin.
+ *
+ * @example
+ * Moving the post-offset forward by 4 bytes.
+ * ```ts
+ * const postOffset: PostOffsetFunction = ({ postOffset }) => postOffset + 4;
+ * ```
+ *
+ * @example
+ * Wrapping the post-offset within the byte array length.
+ * ```ts
+ * const postOffset: PostOffsetFunction = ({ wrapBytes, postOffset }) => wrapBytes(postOffset);
+ * ```
+ *
+ * @example
+ * Ensuring a minimum spacing of 8 bytes between values.
+ * ```ts
+ * const postOffset: PostOffsetFunction = ({ postOffset, newPreOffset }) =>
+ *     Math.max(postOffset, newPreOffset + 8);
+ * ```
+ *
+ * @see {@link OffsetConfig}
+ * @see {@link PreOffsetFunctionScope}
+ */
+type PostOffsetFunction = (scope: PreOffsetFunctionScope & {
+    /** The modified offset used to encode or decode. */
+    newPreOffset: Offset;
+    /** The original offset returned by the encoder or decoder. */
+    postOffset: Offset;
+}) => Offset;
+/**
+ * Moves the offset of a given encoder before and/or after encoding.
+ *
+ * This function allows an encoder to write its encoded value at a different offset
+ * than the one originally provided. It supports both pre-offset adjustments
+ * (before encoding) and post-offset adjustments (after encoding).
+ *
+ * The pre-offset function determines where encoding should start, while the
+ * post-offset function adjusts where the next encoder should continue writing.
+ *
+ * For more details, see {@link offsetCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ *
+ * @param encoder - The encoder to adjust.
+ * @param config - An object specifying how the offset should be modified.
+ * @returns A new encoder with adjusted offsets.
+ *
+ * @example
+ * Moving the pre-offset forward by 2 bytes.
+ * ```ts
+ * const encoder = offsetEncoder(getU32Encoder(), {
+ *     preOffset: ({ preOffset }) => preOffset + 2,
+ * });
+ * const bytes = new Uint8Array(10);
+ * encoder.write(42, bytes, 0); // Actually written at offset 2
+ * ```
+ *
+ * @example
+ * Moving the post-offset forward by 2 bytes.
+ * ```ts
+ * const encoder = offsetEncoder(getU32Encoder(), {
+ *     postOffset: ({ postOffset }) => postOffset + 2,
+ * });
+ * const bytes = new Uint8Array(10);
+ * const nextOffset = encoder.write(42, bytes, 0); // Next encoder starts at offset 6 instead of 4
+ * ```
+ *
+ * @example
+ * Using `wrapBytes` to ensure an offset wraps around the byte array length.
+ * ```ts
+ * const encoder = offsetEncoder(getU32Encoder(), {
+ *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes of the array
+ * });
+ * const bytes = new Uint8Array(10);
+ * encoder.write(42, bytes, 0); // Writes at bytes.length - 4
+ * ```
+ *
+ * @remarks
+ * If you need both encoding and decoding offsets to be adjusted, use {@link offsetCodec}.
+ *
+ * @see {@link offsetCodec}
+ * @see {@link offsetDecoder}
+ */
+export declare function offsetEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, config: OffsetConfig): TEncoder;
+/**
+ * Moves the offset of a given decoder before and/or after decoding.
+ *
+ * This function allows a decoder to read its input from a different offset
+ * than the one originally provided. It supports both pre-offset adjustments
+ * (before decoding) and post-offset adjustments (after decoding).
+ *
+ * The pre-offset function determines where decoding should start, while the
+ * post-offset function adjusts where the next decoder should continue reading.
+ *
+ * For more details, see {@link offsetCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param decoder - The decoder to adjust.
+ * @param config - An object specifying how the offset should be modified.
+ * @returns A new decoder with adjusted offsets.
+ *
+ * @example
+ * Moving the pre-offset forward by 2 bytes.
+ * ```ts
+ * const decoder = offsetDecoder(getU32Decoder(), {
+ *     preOffset: ({ preOffset }) => preOffset + 2,
+ * });
+ * const bytes = new Uint8Array([0, 0, 42, 0]); // Value starts at offset 2
+ * decoder.read(bytes, 0); // Actually reads from offset 2
+ * ```
+ *
+ * @example
+ * Moving the post-offset forward by 2 bytes.
+ * ```ts
+ * const decoder = offsetDecoder(getU32Decoder(), {
+ *     postOffset: ({ postOffset }) => postOffset + 2,
+ * });
+ * const bytes = new Uint8Array([42, 0, 0, 0]);
+ * const [value, nextOffset] = decoder.read(bytes, 0); // Next decoder starts at offset 6 instead of 4
+ * ```
+ *
+ * @example
+ * Using `wrapBytes` to read from the last 4 bytes of an array.
+ * ```ts
+ * const decoder = offsetDecoder(getU32Decoder(), {
+ *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes of the array
+ * });
+ * const bytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 42]); // Value stored at the last 4 bytes
+ * decoder.read(bytes, 0); // Reads from bytes.length - 4
+ * ```
+ *
+ * @remarks
+ * If you need both encoding and decoding offsets to be adjusted, use {@link offsetCodec}.
+ *
+ * @see {@link offsetCodec}
+ * @see {@link offsetEncoder}
+ */
+export declare function offsetDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, config: OffsetConfig): TDecoder;
+/**
+ * Moves the offset of a given codec before and/or after encoding and decoding.
+ *
+ * This function allows a codec to encode and decode values at custom offsets
+ * within a byte array. It modifies both the **pre-offset** (where encoding/decoding starts)
+ * and the **post-offset** (where the next operation should continue).
+ *
+ * This is particularly useful when working with structured binary formats
+ * that require skipping reserved bytes, inserting padding, or aligning fields at
+ * specific locations.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param codec - The codec to adjust.
+ * @param config - An object specifying how the offset should be modified.
+ * @returns A new codec with adjusted offsets.
+ *
+ * @example
+ * Moving the pre-offset forward by 2 bytes when encoding and decoding.
+ * ```ts
+ * const codec = offsetCodec(getU32Codec(), {
+ *     preOffset: ({ preOffset }) => preOffset + 2,
+ * });
+ * const bytes = new Uint8Array(10);
+ * codec.write(42, bytes, 0); // Actually written at offset 2
+ * codec.read(bytes, 0);      // Actually read from offset 2
+ * ```
+ *
+ * @example
+ * Moving the post-offset forward by 2 bytes when encoding and decoding.
+ * ```ts
+ * const codec = offsetCodec(getU32Codec(), {
+ *     postOffset: ({ postOffset }) => postOffset + 2,
+ * });
+ * const bytes = new Uint8Array(10);
+ * codec.write(42, bytes, 0);
+ * // Next encoding starts at offset 6 instead of 4
+ * codec.read(bytes, 0);
+ * // Next decoding starts at offset 6 instead of 4
+ * ```
+ *
+ * @example
+ * Using `wrapBytes` to loop around negative offsets.
+ * ```ts
+ * const codec = offsetCodec(getU32Codec(), {
+ *     preOffset: ({ wrapBytes }) => wrapBytes(-4), // Moves offset to last 4 bytes
+ * });
+ * const bytes = new Uint8Array(10);
+ * codec.write(42, bytes, 0); // Writes at bytes.length - 4
+ * codec.read(bytes, 0); // Reads from bytes.length - 4
+ * ```
+ *
+ * @remarks
+ * If you only need to adjust offsets for encoding, use {@link offsetEncoder}.
+ * If you only need to adjust offsets for decoding, use {@link offsetDecoder}.
+ *
+ * ```ts
+ * const bytes = new Uint8Array(10);
+ * offsetEncoder(getU32Encoder(), { preOffset: ({ preOffset }) => preOffset + 2 }).write(42, bytes, 0);
+ * const [value] = offsetDecoder(getU32Decoder(), { preOffset: ({ preOffset }) => preOffset + 2 }).read(bytes, 0);
+ * ```
+ *
+ * @see {@link offsetEncoder}
+ * @see {@link offsetDecoder}
+ */
+export declare function offsetCodec<TCodec extends AnyCodec>(codec: TCodec, config: OffsetConfig): TCodec;
+export {};
+//# sourceMappingURL=offset-codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"offset-codec.d.ts","sourceRoot":"","sources":["../../src/offset-codec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAgC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAExF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,KAAK,YAAY,GAAG;IAChB,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,SAAS,CAAC,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,KAAK,sBAAsB,GAAG;IAC1B,6BAA6B;IAC7B,KAAK,EAAE,kBAAkB,GAAG,UAAU,CAAC;IACvC,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,MAAM,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,KAAK,kBAAkB,GAAG,CACtB,KAAK,EAAE,sBAAsB,GAAG;IAC5B,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;CACtB,KACA,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,CAe5G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,CAe5G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,WAAW,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAEhG"}

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

@@ -0,0 +1,162 @@
+import { Codec, Decoder, Encoder, Offset } from './codec';
+type AnyEncoder = Encoder<any>;
+type AnyDecoder = Decoder<any>;
+type AnyCodec = Codec<any>;
+/**
+ * Adds left padding to the given encoder, shifting the encoded value forward
+ * by `offset` bytes whilst increasing the size of the encoder accordingly.
+ *
+ * For more details, see {@link padLeftCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ *
+ * @param encoder - The encoder to pad.
+ * @param offset - The number of padding bytes to add before encoding.
+ * @returns A new encoder with left padding applied.
+ *
+ * @example
+ * ```ts
+ * const encoder = padLeftEncoder(getU16Encoder(), 2);
+ * const bytes = encoder.encode(0xffff); // 0x0000ffff (0xffff written at offset 2)
+ * ```
+ *
+ * @see {@link padLeftCodec}
+ * @see {@link padLeftDecoder}
+ */
+export declare function padLeftEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, offset: Offset): TEncoder;
+/**
+ * Adds right padding to the given encoder, extending the encoded value by `offset`
+ * bytes whilst increasing the size of the encoder accordingly.
+ *
+ * For more details, see {@link padRightCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ *
+ * @param encoder - The encoder to pad.
+ * @param offset - The number of padding bytes to add after encoding.
+ * @returns A new encoder with right padding applied.
+ *
+ * @example
+ * ```ts
+ * const encoder = padRightEncoder(getU16Encoder(), 2);
+ * const bytes = encoder.encode(0xffff); // 0xffff0000 (two extra bytes added at the end)
+ * ```
+ *
+ * @see {@link padRightCodec}
+ * @see {@link padRightDecoder}
+ */
+export declare function padRightEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, offset: Offset): TEncoder;
+/**
+ * Adds left padding to the given decoder, shifting the decoding position forward
+ * by `offset` bytes whilst increasing the size of the decoder accordingly.
+ *
+ * For more details, see {@link padLeftCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param decoder - The decoder to pad.
+ * @param offset - The number of padding bytes to skip before decoding.
+ * @returns A new decoder with left padding applied.
+ *
+ * @example
+ * ```ts
+ * const decoder = padLeftDecoder(getU16Decoder(), 2);
+ * const value = decoder.decode(new Uint8Array([0, 0, 0x12, 0x34])); // 0xffff (reads from offset 2)
+ * ```
+ *
+ * @see {@link padLeftCodec}
+ * @see {@link padLeftEncoder}
+ */
+export declare function padLeftDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, offset: Offset): TDecoder;
+/**
+ * Adds right padding to the given decoder, extending the post-offset by `offset`
+ * bytes whilst increasing the size of the decoder accordingly.
+ *
+ * For more details, see {@link padRightCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param decoder - The decoder to pad.
+ * @param offset - The number of padding bytes to skip after decoding.
+ * @returns A new decoder with right padding applied.
+ *
+ * @example
+ * ```ts
+ * const decoder = padRightDecoder(getU16Decoder(), 2);
+ * const value = decoder.decode(new Uint8Array([0x12, 0x34, 0, 0])); // 0xffff (ignores trailing bytes)
+ * ```
+ *
+ * @see {@link padRightCodec}
+ * @see {@link padRightEncoder}
+ */
+export declare function padRightDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, offset: Offset): TDecoder;
+/**
+ * Adds left padding to the given codec, shifting the encoding and decoding positions
+ * forward by `offset` bytes whilst increasing the size of the codec accordingly.
+ *
+ * This ensures that values are read and written at a later position in the byte array,
+ * while the padding bytes remain unused.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param codec - The codec to pad.
+ * @param offset - The number of padding bytes to add before encoding and decoding.
+ * @returns A new codec with left padding applied.
+ *
+ * @example
+ * ```ts
+ * const codec = padLeftCodec(getU16Codec(), 2);
+ * const bytes = codec.encode(0xffff); // 0x0000ffff (0xffff written at offset 2)
+ * const value = codec.decode(bytes);  // 0xffff (reads from offset 2)
+ * ```
+ *
+ * @remarks
+ * If you only need to apply padding for encoding, use {@link padLeftEncoder}.
+ * If you only need to apply padding for decoding, use {@link padLeftDecoder}.
+ *
+ * ```ts
+ * const bytes = padLeftEncoder(getU16Encoder(), 2).encode(0xffff);
+ * const value = padLeftDecoder(getU16Decoder(), 2).decode(bytes);
+ * ```
+ *
+ * @see {@link padLeftEncoder}
+ * @see {@link padLeftDecoder}
+ */
+export declare function padLeftCodec<TCodec extends AnyCodec>(codec: TCodec, offset: Offset): TCodec;
+/**
+ * Adds right padding to the given codec, extending the encoded and decoded value
+ * by `offset` bytes whilst increasing the size of the codec accordingly.
+ *
+ * The extra bytes remain unused, ensuring that the next operation starts further
+ * along the byte array.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ *
+ * @param codec - The codec to pad.
+ * @param offset - The number of padding bytes to add after encoding and decoding.
+ * @returns A new codec with right padding applied.
+ *
+ * @example
+ * ```ts
+ * const codec = padRightCodec(getU16Codec(), 2);
+ * const bytes = codec.encode(0xffff); // 0xffff0000 (two extra bytes added)
+ * const value = codec.decode(bytes);  // 0xffff (ignores padding bytes)
+ * ```
+ *
+ * @remarks
+ * If you only need to apply padding for encoding, use {@link padRightEncoder}.
+ * If you only need to apply padding for decoding, use {@link padRightDecoder}.
+ *
+ * ```ts
+ * const bytes = padRightEncoder(getU16Encoder(), 2).encode(0xffff);
+ * const value = padRightDecoder(getU16Decoder(), 2).decode(bytes);
+ * ```
+ *
+ * @see {@link padRightEncoder}
+ * @see {@link padRightDecoder}
+ */
+export declare function padRightCodec<TCodec extends AnyCodec>(codec: TCodec, offset: Offset): TCodec;
+export {};
+//# sourceMappingURL=pad-codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pad-codec.d.ts","sourceRoot":"","sources":["../../src/pad-codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAM1D,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKvG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKxG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKvG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKxG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE5F"}

package/node_modules/@solana/codecs-core/dist/types/readonly-uint8array.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A read-only variant of `Uint8Array`.
+ *
+ * This type prevents modifications to the array by omitting mutable methods such as `copyWithin`,
+ * `fill`, `reverse`, `set`, and `sort`, while still allowing indexed access to elements.
+ *
+ * @example
+ * ```ts
+ * const bytes: ReadonlyUint8Array = new Uint8Array([1, 2, 3]);
+ * console.log(bytes[0]); // 1
+ * bytes[0] = 42; // Type error: Cannot assign to '0' because it is a read-only property.
+ * ```
+ */
+export interface ReadonlyUint8Array extends Omit<Uint8Array, TypedArrayMutableProperties> {
+    readonly [n: number]: number;
+}
+type TypedArrayMutableProperties = 'copyWithin' | 'fill' | 'reverse' | 'set' | 'sort';
+export {};
+//# sourceMappingURL=readonly-uint8array.d.ts.map

package/node_modules/@solana/codecs-core/dist/types/readonly-uint8array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readonly-uint8array.d.ts","sourceRoot":"","sources":["../../src/readonly-uint8array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,UAAU,EAAE,2BAA2B,CAAC;IACrF,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC;AAED,KAAK,2BAA2B,GAAG,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC"}

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

@@ -0,0 +1,129 @@
+import { Codec, Decoder, Encoder, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder } from './codec';
+type AnyEncoder = Encoder<any>;
+type AnyDecoder = Decoder<any>;
+type AnyCodec = Codec<any>;
+/**
+ * Updates the size of a given encoder.
+ *
+ * This function modifies the size of an encoder using a provided transformation function.
+ * For fixed-size encoders, it updates the `fixedSize` property, and for variable-size
+ * encoders, it adjusts the size calculation based on the encoded value.
+ *
+ * If the new size is negative, an error will be thrown.
+ *
+ * For more details, see {@link resizeCodec}.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TSize - The original fixed size of the encoded value.
+ * @typeParam TNewSize - The new fixed size after resizing.
+ *
+ * @param encoder - The encoder whose size will be updated.
+ * @param resize - A function that takes the current size and returns the new size.
+ * @returns A new encoder with the updated size.
+ *
+ * @example
+ * Increasing the size of a `u16` encoder by 2 bytes.
+ * ```ts
+ * const encoder = resizeEncoder(getU16Encoder(), size => size + 2);
+ * encoder.encode(0xffff); // 0xffff0000 (two extra bytes added)
+ * ```
+ *
+ * @example
+ * Shrinking a `u32` encoder to only use 2 bytes.
+ * ```ts
+ * const encoder = resizeEncoder(getU32Encoder(), () => 2);
+ * encoder.fixedSize; // 2
+ * ```
+ *
+ * @see {@link resizeCodec}
+ * @see {@link resizeDecoder}
+ */
+export declare function resizeEncoder<TFrom, TSize extends number, TNewSize extends number>(encoder: FixedSizeEncoder<TFrom, TSize>, resize: (size: TSize) => TNewSize): FixedSizeEncoder<TFrom, TNewSize>;
+export declare function resizeEncoder<TEncoder extends AnyEncoder>(encoder: TEncoder, resize: (size: number) => number): TEncoder;
+/**
+ * Updates the size of a given decoder.
+ *
+ * This function modifies the size of a decoder using a provided transformation function.
+ * For fixed-size decoders, it updates the `fixedSize` property to reflect the new size.
+ * Variable-size decoders remain unchanged, as their size is determined dynamically.
+ *
+ * If the new size is negative, an error will be thrown.
+ *
+ * For more details, see {@link resizeCodec}.
+ *
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The original fixed size of the decoded value.
+ * @typeParam TNewSize - The new fixed size after resizing.
+ *
+ * @param decoder - The decoder whose size will be updated.
+ * @param resize - A function that takes the current size and returns the new size.
+ * @returns A new decoder with the updated size.
+ *
+ * @example
+ * Expanding a `u16` decoder to read 4 bytes instead of 2.
+ * ```ts
+ * const decoder = resizeDecoder(getU16Decoder(), size => size + 2);
+ * decoder.fixedSize; // 4
+ * ```
+ *
+ * @example
+ * Shrinking a `u32` decoder to only read 2 bytes.
+ * ```ts
+ * const decoder = resizeDecoder(getU32Decoder(), () => 2);
+ * decoder.fixedSize; // 2
+ * ```
+ *
+ * @see {@link resizeCodec}
+ * @see {@link resizeEncoder}
+ */
+export declare function resizeDecoder<TFrom, TSize extends number, TNewSize extends number>(decoder: FixedSizeDecoder<TFrom, TSize>, resize: (size: TSize) => TNewSize): FixedSizeDecoder<TFrom, TNewSize>;
+export declare function resizeDecoder<TDecoder extends AnyDecoder>(decoder: TDecoder, resize: (size: number) => number): TDecoder;
+/**
+ * Updates the size of a given codec.
+ *
+ * This function modifies the size of both the codec using a provided
+ * transformation function. It is useful for adjusting the allocated byte size for
+ * encoding and decoding without altering the underlying data structure.
+ *
+ * If the new size is negative, an error will be thrown.
+ *
+ * @typeParam TFrom - The type of the value to encode.
+ * @typeParam TTo - The type of the decoded value.
+ * @typeParam TSize - The original fixed size of the encoded/decoded value (for fixed-size codecs).
+ * @typeParam TNewSize - The new fixed size after resizing (for fixed-size codecs).
+ *
+ * @param codec - The codec whose size will be updated.
+ * @param resize - A function that takes the current size and returns the new size.
+ * @returns A new codec with the updated size.
+ *
+ * @example
+ * Expanding a `u16` codec from 2 to 4 bytes.
+ * ```ts
+ * const codec = resizeCodec(getU16Codec(), size => size + 2);
+ * const bytes = codec.encode(0xffff); // 0xffff0000 (two extra bytes added)
+ * const value = codec.decode(bytes);  // 0xffff (reads original two bytes)
+ * ```
+ *
+ * @example
+ * Shrinking a `u32` codec to only use 2 bytes.
+ * ```ts
+ * const codec = resizeCodec(getU32Codec(), () => 2);
+ * codec.fixedSize; // 2
+ * ```
+ *
+ * @remarks
+ * If you only need to resize an encoder, use {@link resizeEncoder}.
+ * If you only need to resize a decoder, use {@link resizeDecoder}.
+ *
+ * ```ts
+ * const bytes = resizeEncoder(getU32Encoder(), (size) => size + 2).encode(0xffff);
+ * const value = resizeDecoder(getU32Decoder(), (size) => size + 2).decode(bytes);
+ * ```
+ *
+ * @see {@link resizeEncoder}
+ * @see {@link resizeDecoder}
+ */
+export declare function resizeCodec<TFrom, TTo extends TFrom, TSize extends number, TNewSize extends number>(codec: FixedSizeCodec<TFrom, TTo, TSize>, resize: (size: TSize) => TNewSize): FixedSizeCodec<TFrom, TTo, TNewSize>;
+export declare function resizeCodec<TCodec extends AnyCodec>(codec: TCodec, resize: (size: number) => number): TCodec;
+export {};
+//# sourceMappingURL=resize-codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resize-codec.d.ts","sourceRoot":"","sources":["../../src/resize-codec.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,EAGL,OAAO,EACP,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAEnB,MAAM,SAAS,CAAC;AAIjB,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/B,KAAK,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC9E,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EACvC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACrC,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EACrD,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,QAAQ,CAAC;AA8BZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC9E,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EACvC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACrC,wBAAgB,aAAa,CAAC,QAAQ,SAAS,UAAU,EACrD,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,QAAQ,CAAC;AAkBZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,SAAS,KAAK,EAAE,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAC/F,KAAK,EAAE,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EACxC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,GAClC,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AACxC,wBAAgB,WAAW,CAAC,MAAM,SAAS,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAAC"}