@solana/codecs-data-structures 2.0.0-experimental.3bc22e7 → 2.0.0-experimental.3fc662d

package/dist/index.browser.js

@@ -1,12 +1,15 @@
-import { assertIsFixedSize, createEncoder, getEncodedSize, createDecoder, combineCodec, assertByteArrayHasEnoughBytesForCodec, mapEncoder, mapDecoder, fixEncoder, fixDecoder, assertByteArrayIsNotEmptyForCodec, isFixedSize } from '@solana/codecs-core';
+import { createEncoder, getEncodedSize, createDecoder, combineCodec, assertByteArrayHasEnoughBytesForCodec, assertIsFixedSize, mapEncoder, mapDecoder, fixEncoder, fixDecoder, assertByteArrayIsNotEmptyForCodec, isFixedSize } from '@solana/codecs-core';
 import { getU32Encoder, getU32Decoder, getU8Encoder, getU8Decoder } from '@solana/codecs-numbers';
+import { SolanaError, SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE, SOLANA_ERROR__CODECS__INVALID_DATA_ENUM_VARIANT, SOLANA_ERROR__CODECS__INVALID_SCALAR_ENUM_VARIANT } from '@solana/errors';
 
 // src/array.ts
-
-// src/assertions.ts
 function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
   if (expected !== actual) {
-    throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+      actual,
+      codecDescription,
+      expected
+    });
   }
 }
 function maxCodecSizes(sizes) {
@@ -28,9 +31,6 @@ function getMaxSize(codec) {
 // src/array.ts
 function getArrayEncoder(item, config = {}) {
   const size = config.size ?? getU32Encoder();
-  if (size === "remainder") {
-    assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-  }
   const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
   const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
   return createEncoder({
@@ -57,9 +57,6 @@ function getArrayEncoder(item, config = {}) {
 }
 function getArrayDecoder(item, config = {}) {
   const size = config.size ?? getU32Decoder();
-  if (size === "remainder") {
-    assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-  }
   const itemSize = getFixedSize(item);
   const fixedSize = computeArrayLikeCodecSize(size, itemSize);
   const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
@@ -70,7 +67,15 @@ function getArrayDecoder(item, config = {}) {
       if (typeof size === "object" && bytes.slice(offset).length === 0) {
         return [array, offset];
       }
-      const [resolvedSize, newOffset] = readArrayLikeCodecSize(size, itemSize, bytes, offset);
+      if (size === "remainder") {
+        while (offset < bytes.length) {
+          const [value, newOffset2] = item.read(bytes, offset);
+          offset = newOffset2;
+          array.push(value);
+        }
+        return [array, offset];
+      }
+      const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
       offset = newOffset;
       for (let i = 0; i < resolvedSize; i += 1) {
         const [value, newOffset2] = item.read(bytes, offset);
@@ -84,27 +89,6 @@ function getArrayDecoder(item, config = {}) {
 function getArrayCodec(item, config = {}) {
   return combineCodec(getArrayEncoder(item, config), getArrayDecoder(item, config));
 }
-function readArrayLikeCodecSize(size, itemSize, bytes, offset) {
-  if (typeof size === "number") {
-    return [size, offset];
-  }
-  if (typeof size === "object") {
-    return size.read(bytes, offset);
-  }
-  if (size === "remainder") {
-    if (itemSize === null) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
-    }
-    const remainder = Math.max(0, bytes.length - offset);
-    if (remainder % itemSize !== 0) {
-      throw new Error(
-        `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${itemSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${itemSize} should be equal to zero.`
-      );
-    }
-    return [remainder / itemSize, offset];
-  }
-  throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
-}
 function computeArrayLikeCodecSize(size, itemSize) {
   if (typeof size !== "number")
     return null;
@@ -166,12 +150,12 @@ function getBitArrayCodec(size, config = {}) {
 }
 function getBooleanEncoder(config = {}) {
   const size = config.size ?? getU8Encoder();
-  assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  assertIsFixedSize(size);
   return mapEncoder(size, (value) => value ? 1 : 0);
 }
 function getBooleanDecoder(config = {}) {
   const size = config.size ?? getU8Decoder();
-  assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  assertIsFixedSize(size);
   return mapDecoder(size, (value) => Number(value) === 1);
 }
 function getBooleanCodec(config = {}) {
@@ -262,9 +246,11 @@ function getDataEnumDecoder(variants, config = {}) {
       offset = dOffset;
       const variantField = variants[Number(discriminator)] ?? null;
       if (!variantField) {
-        throw new Error(
-          `Enum discriminator out of range. Expected a number between 0 and ${variants.length - 1}, got ${discriminator}.`
-        );
+        throw new SolanaError(SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+          discriminator,
+          maxRange: variants.length - 1,
+          minRange: 0
+        });
       }
       const [variant, vOffset] = variantField[1].read(bytes, offset);
       offset = vOffset;
@@ -273,7 +259,10 @@ function getDataEnumDecoder(variants, config = {}) {
   });
 }
 function getDataEnumCodec(variants, config = {}) {
-  return combineCodec(getDataEnumEncoder(variants, config), getDataEnumDecoder(variants, config));
+  return combineCodec(
+    getDataEnumEncoder(variants, config),
+    getDataEnumDecoder(variants, config)
+  );
 }
 function getDataEnumFixedSize(variants, prefix) {
   if (variants.length === 0)
@@ -295,9 +284,10 @@ function getDataEnumMaxSize(variants, prefix) {
 function getVariantDiscriminator(variants, variant) {
   const discriminator = variants.findIndex(([key]) => variant.__kind === key);
   if (discriminator < 0) {
-    throw new Error(
-      `Invalid data enum variant. Expected one of [${variants.map(([key]) => key).join(", ")}], got "${variant.__kind}".`
-    );
+    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_DATA_ENUM_VARIANT, {
+      value: variant.__kind,
+      variants: variants.map(([key]) => key)
+    });
   }
   return discriminator;
 }
@@ -362,8 +352,8 @@ function getNullableEncoder(item, config = {}) {
   const fixed = config.fixed ?? false;
   const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
   if (fixed || isZeroSizeItem) {
-    assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-    assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+    assertIsFixedSize(item);
+    assertIsFixedSize(prefix);
     const fixedSize = prefix.fixedSize + item.fixedSize;
     return createEncoder({
       fixedSize,
@@ -394,8 +384,8 @@ function getNullableDecoder(item, config = {}) {
   let fixedSize = null;
   const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
   if (fixed || isZeroSizeItem) {
-    assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-    assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+    assertIsFixedSize(item);
+    assertIsFixedSize(prefix);
     fixedSize = prefix.fixedSize + item.fixedSize;
   }
   return createDecoder({
@@ -419,14 +409,17 @@ function getNullableCodec(item, config = {}) {
 }
 function getScalarEnumEncoder(constructor, config = {}) {
   const prefix = config.size ?? getU8Encoder();
-  const { minRange, maxRange, stringValues, enumKeys, enumValues } = getScalarEnumStats(constructor);
+  const { minRange, maxRange, allStringInputs, enumKeys, enumValues } = getScalarEnumStats(constructor);
   return mapEncoder(prefix, (value) => {
     const isInvalidNumber = typeof value === "number" && (value < minRange || value > maxRange);
-    const isInvalidString = typeof value === "string" && !stringValues.includes(value);
+    const isInvalidString = typeof value === "string" && !allStringInputs.includes(value);
     if (isInvalidNumber || isInvalidString) {
-      throw new Error(
-        `Invalid scalar enum variant. Expected one of [${stringValues.join(", ")}] or a number between ${minRange} and ${maxRange}, got "${value}".`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_SCALAR_ENUM_VARIANT, {
+        maxRange,
+        minRange,
+        value,
+        variants: allStringInputs
+      });
     }
     if (typeof value === "number")
       return value;
@@ -438,34 +431,40 @@ function getScalarEnumEncoder(constructor, config = {}) {
 }
 function getScalarEnumDecoder(constructor, config = {}) {
   const prefix = config.size ?? getU8Decoder();
-  const { minRange, maxRange, isNumericEnum, enumValues } = getScalarEnumStats(constructor);
+  const { minRange, maxRange, enumKeys } = getScalarEnumStats(constructor);
   return mapDecoder(prefix, (value) => {
     const valueAsNumber = Number(value);
     if (valueAsNumber < minRange || valueAsNumber > maxRange) {
-      throw new Error(
-        `Enum discriminator out of range. Expected a number between ${minRange} and ${maxRange}, got ${valueAsNumber}.`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+        discriminator: valueAsNumber,
+        maxRange,
+        minRange
+      });
     }
-    return isNumericEnum ? valueAsNumber : enumValues[valueAsNumber];
+    return constructor[enumKeys[valueAsNumber]];
   });
 }
 function getScalarEnumCodec(constructor, config = {}) {
   return combineCodec(getScalarEnumEncoder(constructor, config), getScalarEnumDecoder(constructor, config));
 }
 function getScalarEnumStats(constructor) {
-  const enumKeys = Object.keys(constructor);
-  const enumValues = Object.values(constructor);
-  const isNumericEnum = enumValues.some((v) => typeof v === "number");
+  const numericValues = Object.values(constructor).filter((v) => typeof v === "number");
+  const deduplicatedConstructor = Object.fromEntries(
+    Object.entries(constructor).slice(numericValues.length)
+  );
+  const enumKeys = Object.keys(deduplicatedConstructor);
+  const enumValues = Object.values(deduplicatedConstructor);
   const minRange = 0;
-  const maxRange = isNumericEnum ? enumValues.length / 2 - 1 : enumValues.length - 1;
-  const stringValues = isNumericEnum ? [...enumKeys] : [.../* @__PURE__ */ new Set([...enumKeys, ...enumValues])];
+  const maxRange = enumValues.length - 1;
+  const allStringInputs = [
+    .../* @__PURE__ */ new Set([...enumKeys, ...enumValues.filter((v) => typeof v === "string")])
+  ];
   return {
+    allStringInputs,
     enumKeys,
     enumValues,
-    isNumericEnum,
     maxRange,
-    minRange,
-    stringValues
+    minRange
   };
 }
 function getSetEncoder(item, config = {}) {
@@ -512,7 +511,10 @@ function getStructDecoder(fields) {
   });
 }
 function getStructCodec(fields) {
-  return combineCodec(getStructEncoder(fields), getStructDecoder(fields));
+  return combineCodec(
+    getStructEncoder(fields),
+    getStructDecoder(fields)
+  );
 }
 function getUnitEncoder() {
   return createEncoder({