@solana/codecs-data-structures 2.0.0-experimental.7ed772d → 2.0.0-experimental.803b2d8

package/dist/index.browser.cjs

@@ -2,13 +2,16 @@
 
 var codecsCore = require('@solana/codecs-core');
 var codecsNumbers = require('@solana/codecs-numbers');
+var errors = require('@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 errors.SolanaError(errors.SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_ITEMS, {
+      actual,
+      codecDescription,
+      expected
+    });
   }
 }
 function maxCodecSizes(sizes) {
@@ -30,9 +33,6 @@ function getMaxSize(codec) {
 // src/array.ts
 function getArrayEncoder(item, config = {}) {
   const size = config.size ?? codecsNumbers.getU32Encoder();
-  if (size === "remainder") {
-    codecsCore.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 codecsCore.createEncoder({
@@ -59,9 +59,6 @@ function getArrayEncoder(item, config = {}) {
 }
 function getArrayDecoder(item, config = {}) {
   const size = config.size ?? codecsNumbers.getU32Decoder();
-  if (size === "remainder") {
-    codecsCore.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;
@@ -72,7 +69,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);
@@ -86,27 +91,6 @@ function getArrayDecoder(item, config = {}) {
 function getArrayCodec(item, config = {}) {
   return codecsCore.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;
@@ -168,12 +152,32 @@ function getBitArrayCodec(size, config = {}) {
 }
 function getBooleanEncoder(config = {}) {
   const size = config.size ?? codecsNumbers.getU8Encoder();
-  codecsCore.assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  try {
+    codecsCore.assertIsFixedSize(size);
+  } catch (e) {
+    if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+      throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE, {
+        codecDescription: "bool"
+      });
+    } else {
+      throw e;
+    }
+  }
   return codecsCore.mapEncoder(size, (value) => value ? 1 : 0);
 }
 function getBooleanDecoder(config = {}) {
   const size = config.size ?? codecsNumbers.getU8Decoder();
-  codecsCore.assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  try {
+    codecsCore.assertIsFixedSize(size);
+  } catch (e) {
+    if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+      throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE, {
+        codecDescription: "bool"
+      });
+    } else {
+      throw e;
+    }
+  }
   return codecsCore.mapDecoder(size, (value) => Number(value) === 1);
 }
 function getBooleanCodec(config = {}) {
@@ -264,9 +268,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 errors.SolanaError(errors.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;
@@ -275,7 +281,10 @@ function getDataEnumDecoder(variants, config = {}) {
   });
 }
 function getDataEnumCodec(variants, config = {}) {
-  return codecsCore.combineCodec(getDataEnumEncoder(variants, config), getDataEnumDecoder(variants, config));
+  return codecsCore.combineCodec(
+    getDataEnumEncoder(variants, config),
+    getDataEnumDecoder(variants, config)
+  );
 }
 function getDataEnumFixedSize(variants, prefix) {
   if (variants.length === 0)
@@ -297,9 +306,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 errors.SolanaError(errors.SOLANA_ERROR__CODECS_INVALID_DATA_ENUM_VARIANT, {
+      value: variant.__kind,
+      variants: variants.map(([key]) => key)
+    });
   }
   return discriminator;
 }
@@ -364,8 +374,24 @@ function getNullableEncoder(item, config = {}) {
   const fixed = config.fixed ?? false;
   const isZeroSizeItem = codecsCore.isFixedSize(item) && codecsCore.isFixedSize(prefix) && item.fixedSize === 0;
   if (fixed || isZeroSizeItem) {
-    codecsCore.assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-    codecsCore.assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+    try {
+      codecsCore.assertIsFixedSize(item);
+    } catch (e) {
+      if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_CODEC);
+      } else {
+        throw e;
+      }
+    }
+    try {
+      codecsCore.assertIsFixedSize(prefix);
+    } catch (e) {
+      if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX);
+      } else {
+        throw e;
+      }
+    }
     const fixedSize = prefix.fixedSize + item.fixedSize;
     return codecsCore.createEncoder({
       fixedSize,
@@ -396,8 +422,24 @@ function getNullableDecoder(item, config = {}) {
   let fixedSize = null;
   const isZeroSizeItem = codecsCore.isFixedSize(item) && codecsCore.isFixedSize(prefix) && item.fixedSize === 0;
   if (fixed || isZeroSizeItem) {
-    codecsCore.assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-    codecsCore.assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+    try {
+      codecsCore.assertIsFixedSize(item);
+    } catch (e) {
+      if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_CODEC);
+      } else {
+        throw e;
+      }
+    }
+    try {
+      codecsCore.assertIsFixedSize(prefix);
+    } catch (e) {
+      if (errors.isSolanaError(e, errors.SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX);
+      } else {
+        throw e;
+      }
+    }
     fixedSize = prefix.fixedSize + item.fixedSize;
   }
   return codecsCore.createDecoder({
@@ -421,14 +463,17 @@ function getNullableCodec(item, config = {}) {
 }
 function getScalarEnumEncoder(constructor, config = {}) {
   const prefix = config.size ?? codecsNumbers.getU8Encoder();
-  const { minRange, maxRange, stringValues, enumKeys, enumValues } = getScalarEnumStats(constructor);
+  const { minRange, maxRange, allStringInputs, enumKeys, enumValues } = getScalarEnumStats(constructor);
   return codecsCore.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 errors.SolanaError(errors.SOLANA_ERROR__CODECS_INVALID_SCALAR_ENUM_VARIANT, {
+        maxRange,
+        minRange,
+        value,
+        variants: allStringInputs
+      });
     }
     if (typeof value === "number")
       return value;
@@ -440,34 +485,40 @@ function getScalarEnumEncoder(constructor, config = {}) {
 }
 function getScalarEnumDecoder(constructor, config = {}) {
   const prefix = config.size ?? codecsNumbers.getU8Decoder();
-  const { minRange, maxRange, isNumericEnum, enumValues } = getScalarEnumStats(constructor);
+  const { minRange, maxRange, enumKeys } = getScalarEnumStats(constructor);
   return codecsCore.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 errors.SolanaError(errors.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 codecsCore.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 = {}) {
@@ -514,7 +565,10 @@ function getStructDecoder(fields) {
   });
 }
 function getStructCodec(fields) {
-  return codecsCore.combineCodec(getStructEncoder(fields), getStructDecoder(fields));
+  return codecsCore.combineCodec(
+    getStructEncoder(fields),
+    getStructDecoder(fields)
+  );
 }
 function getUnitEncoder() {
   return codecsCore.createEncoder({