@shelby-protocol/sdk 0.2.4 → 0.3.1

package/dist/core/erasure/default.mjs

@@ -1,13 +1,195 @@
+// src/core/erasure/constants.ts
+var ERASURE_CODE_PARAMS = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 16,
+    // data chunks
+    erasure_k: 10,
+    // helper nodes
+    erasure_d: 13,
+    // enum index
+    enumIndex: 0
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 4,
+    // data chunks
+    erasure_k: 2,
+    // helper nodes
+    erasure_d: 3,
+    // enum index
+    enumIndex: 1
+  }
+};
+var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_n;
+var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_k;
+var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_d;
+var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
+
+// src/core/chunk.ts
+var CHUNK_SIZE_PARAMS = {
+  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 10MiB
+    chunksetSizeBytes: 10 * 1024 * 1024
+  },
+  ["ChunkSet2MiB_Chunk1MiB" /* ChunkSet2MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 2MiB
+    chunksetSizeBytes: 2 * 1024 * 1024
+  }
+};
+var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunkSizeBytes;
+var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunksetSizeBytes;
+var ERASURE_CODE_AND_CHUNK_MAPPING = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet2MiB_Chunk1MiB
+  }
+};
+
+// src/core/erasure/clay-codes.ts
 import {
-  createDefaultErasureCodingProvider,
-  defaultErasureCodingConfig,
-  erasureCodingConfig16Total10Data13Helper,
-  erasureCodingConfig4Total2Data3Helper
-} from "../../chunk-XRLHLAOW.mjs";
-import "../../chunk-OGKZ575S.mjs";
-import "../../chunk-JTXYKO3U.mjs";
-import "../../chunk-AUQDI5BS.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  createDecoder,
+  createEncoder
+} from "@shelby-protocol/clay-codes";
+function getTotalChunks(config) {
+  return config.erasure_n;
+}
+var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
+  config;
+  encoderCache;
+  decoderCache;
+  lastFunction;
+  constructor(config) {
+    this.config = config;
+    this.lastFunction = "none" /* NONE */;
+  }
+  /**
+   * Static factory method to create an initialized ClayErasureCodingProvider
+   */
+  static async create(config) {
+    const provider = new _ClayErasureCodingProvider(config);
+    [provider.encoderCache, provider.decoderCache] = await Promise.all([
+      createEncoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes
+      }),
+      createDecoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes,
+        erasedChunkIndexes: []
+      })
+    ]);
+    return provider;
+  }
+  encode(data) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (!this.encoderCache) {
+      throw new Error("Encoder cache is missing");
+    }
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (this.requiresPadding(data.length)) {
+      throw new Error(
+        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    this.lastFunction = "encoded" /* ENCODED */;
+    return this.encoderCache.erasureCode(data);
+  }
+  decode(available, config) {
+    if (!this.decoderCache) {
+      throw new Error("Decoder cache is missing");
+    }
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (available.length < erasure_k) {
+      throw new Error(
+        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
+      );
+    }
+    for (let i = 0; i < available.length; i++) {
+      const chunk = available[i];
+      if (chunk.length !== chunkSizeBytes) {
+        throw new Error(
+          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
+        );
+      }
+    }
+    this.lastFunction = "decoded" /* DECODED */;
+    return this.decoderCache.decode(available, config);
+  }
+  getChunkMerkleRoots() {
+    if (this.decoderCache && this.lastFunction === "decoded" /* DECODED */)
+      return this.decoderCache.getChunkMerkleRoots();
+    if (this.encoderCache && this.lastFunction === "encoded" /* ENCODED */)
+      return this.encoderCache.getChunkMerkleRoots();
+    throw new Error(
+      "You must call encode or decode before calling getChunkMerkleRoots"
+    );
+  }
+  /**
+   * Determines if data can be erasure coded as-is or requires padding.
+   *
+   * Data can be erasure coded without padding if its size exactly matches
+   * the total systematic data capacity (k * chunkSizeBytes).
+   *
+   * @param dataSize - Size of the data in bytes
+   * @returns true if data needs padding, false if it can be coded as-is
+   */
+  requiresPadding(dataSize) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    return dataSize !== systematicCapacity;
+  }
+};
+
+// src/core/erasure/default.ts
+var defaultProviderPromise;
+function createDefaultErasureCodingProvider() {
+  if (!defaultProviderPromise) {
+    defaultProviderPromise = ClayErasureCodingProvider.create(
+      defaultErasureCodingConfig()
+    );
+  }
+  return defaultProviderPromise;
+}
+function defaultErasureCodingConfig() {
+  const encoding = Number(process.env.SHELBY_ENCODING) || 0;
+  if (encoding === 0) {
+    return erasureCodingConfig16Total10Data13Helper();
+  }
+  return erasureCodingConfig4Total2Data3Helper();
+}
+function erasureCodingConfig16Total10Data13Helper() {
+  return erasureCodingConfig(
+    "ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */
+  );
+}
+function erasureCodingConfig4Total2Data3Helper() {
+  return erasureCodingConfig("ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */);
+}
+function erasureCodingConfig(encodingScheme) {
+  return {
+    erasure_n: ERASURE_CODE_PARAMS[encodingScheme].erasure_n,
+    erasure_k: ERASURE_CODE_PARAMS[encodingScheme].erasure_k,
+    erasure_d: ERASURE_CODE_PARAMS[encodingScheme].erasure_d,
+    chunkSizeBytes: DEFAULT_CHUNK_SIZE_BYTES,
+    enumIndex: ERASURE_CODE_PARAMS[encodingScheme].enumIndex
+  };
+}
 export {
   createDefaultErasureCodingProvider,
   defaultErasureCodingConfig,

package/dist/core/erasure/index.d.ts

@@ -1,4 +1,4 @@
-export { C as ClayErasureCodingProvider, D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, R as ReedSolomonErasureCodingProvider } from '../../clay-codes-DHP-bYcP.js';
+export { C as ClayErasureCodingProvider, D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, R as ReedSolomonErasureCodingProvider } from '../../clay-codes-DdXABBDx.js';
 export { DEFAULT_ERASURE_D, DEFAULT_ERASURE_K, DEFAULT_ERASURE_M, DEFAULT_ERASURE_N, DEFAULT_SAMPLE_SIZE, ERASURE_CODE_PARAMS, ErasureCodeParams, ErasureCodingScheme, ErasureSchemeParams } from './constants.js';
 export { createDefaultErasureCodingProvider, defaultErasureCodingConfig, erasureCodingConfig16Total10Data13Helper, erasureCodingConfig4Total2Data3Helper } from './default.js';
 import '@shelby-protocol/clay-codes';

package/dist/core/erasure/index.mjs

@@ -1,27 +1,270 @@
-import "../../chunk-XNEIWM4O.mjs";
+// src/core/erasure/clay-codes.ts
 import {
-  ReedSolomonErasureCodingProvider
-} from "../../chunk-NHWWORCH.mjs";
-import {
-  createDefaultErasureCodingProvider,
-  defaultErasureCodingConfig,
-  erasureCodingConfig16Total10Data13Helper,
-  erasureCodingConfig4Total2Data3Helper
-} from "../../chunk-XRLHLAOW.mjs";
-import {
-  ClayErasureCodingProvider
-} from "../../chunk-OGKZ575S.mjs";
-import "../../chunk-JTXYKO3U.mjs";
-import {
-  DEFAULT_ERASURE_D,
-  DEFAULT_ERASURE_K,
-  DEFAULT_ERASURE_M,
-  DEFAULT_ERASURE_N,
-  DEFAULT_SAMPLE_SIZE,
-  ERASURE_CODE_PARAMS,
-  ErasureCodingScheme
-} from "../../chunk-AUQDI5BS.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  createDecoder,
+  createEncoder
+} from "@shelby-protocol/clay-codes";
+function getTotalChunks(config) {
+  return config.erasure_n;
+}
+var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
+  config;
+  encoderCache;
+  decoderCache;
+  lastFunction;
+  constructor(config) {
+    this.config = config;
+    this.lastFunction = "none" /* NONE */;
+  }
+  /**
+   * Static factory method to create an initialized ClayErasureCodingProvider
+   */
+  static async create(config) {
+    const provider = new _ClayErasureCodingProvider(config);
+    [provider.encoderCache, provider.decoderCache] = await Promise.all([
+      createEncoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes
+      }),
+      createDecoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes,
+        erasedChunkIndexes: []
+      })
+    ]);
+    return provider;
+  }
+  encode(data) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (!this.encoderCache) {
+      throw new Error("Encoder cache is missing");
+    }
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (this.requiresPadding(data.length)) {
+      throw new Error(
+        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    this.lastFunction = "encoded" /* ENCODED */;
+    return this.encoderCache.erasureCode(data);
+  }
+  decode(available, config) {
+    if (!this.decoderCache) {
+      throw new Error("Decoder cache is missing");
+    }
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (available.length < erasure_k) {
+      throw new Error(
+        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
+      );
+    }
+    for (let i = 0; i < available.length; i++) {
+      const chunk = available[i];
+      if (chunk.length !== chunkSizeBytes) {
+        throw new Error(
+          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
+        );
+      }
+    }
+    this.lastFunction = "decoded" /* DECODED */;
+    return this.decoderCache.decode(available, config);
+  }
+  getChunkMerkleRoots() {
+    if (this.decoderCache && this.lastFunction === "decoded" /* DECODED */)
+      return this.decoderCache.getChunkMerkleRoots();
+    if (this.encoderCache && this.lastFunction === "encoded" /* ENCODED */)
+      return this.encoderCache.getChunkMerkleRoots();
+    throw new Error(
+      "You must call encode or decode before calling getChunkMerkleRoots"
+    );
+  }
+  /**
+   * Determines if data can be erasure coded as-is or requires padding.
+   *
+   * Data can be erasure coded without padding if its size exactly matches
+   * the total systematic data capacity (k * chunkSizeBytes).
+   *
+   * @param dataSize - Size of the data in bytes
+   * @returns true if data needs padding, false if it can be coded as-is
+   */
+  requiresPadding(dataSize) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    return dataSize !== systematicCapacity;
+  }
+};
+
+// src/core/erasure/constants.ts
+var ErasureCodingScheme = /* @__PURE__ */ ((ErasureCodingScheme2) => {
+  ErasureCodingScheme2["ClayCode_16Total_10Data_13Helper"] = "ClayCode_16Total_10Data_13Helper";
+  ErasureCodingScheme2["ClayCode_4Total_2Data_3Helper"] = "ClayCode_4Total_2Data_3Helper";
+  return ErasureCodingScheme2;
+})(ErasureCodingScheme || {});
+var ERASURE_CODE_PARAMS = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 16,
+    // data chunks
+    erasure_k: 10,
+    // helper nodes
+    erasure_d: 13,
+    // enum index
+    enumIndex: 0
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 4,
+    // data chunks
+    erasure_k: 2,
+    // helper nodes
+    erasure_d: 3,
+    // enum index
+    enumIndex: 1
+  }
+};
+var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_n;
+var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_k;
+var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_d;
+var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
+var DEFAULT_SAMPLE_SIZE = 1024;
+
+// src/core/chunk.ts
+var CHUNK_SIZE_PARAMS = {
+  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 10MiB
+    chunksetSizeBytes: 10 * 1024 * 1024
+  },
+  ["ChunkSet2MiB_Chunk1MiB" /* ChunkSet2MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 2MiB
+    chunksetSizeBytes: 2 * 1024 * 1024
+  }
+};
+var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunkSizeBytes;
+var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunksetSizeBytes;
+var ERASURE_CODE_AND_CHUNK_MAPPING = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet2MiB_Chunk1MiB
+  }
+};
+
+// src/core/erasure/default.ts
+var defaultProviderPromise;
+function createDefaultErasureCodingProvider() {
+  if (!defaultProviderPromise) {
+    defaultProviderPromise = ClayErasureCodingProvider.create(
+      defaultErasureCodingConfig()
+    );
+  }
+  return defaultProviderPromise;
+}
+function defaultErasureCodingConfig() {
+  const encoding = Number(process.env.SHELBY_ENCODING) || 0;
+  if (encoding === 0) {
+    return erasureCodingConfig16Total10Data13Helper();
+  }
+  return erasureCodingConfig4Total2Data3Helper();
+}
+function erasureCodingConfig16Total10Data13Helper() {
+  return erasureCodingConfig(
+    "ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */
+  );
+}
+function erasureCodingConfig4Total2Data3Helper() {
+  return erasureCodingConfig("ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */);
+}
+function erasureCodingConfig(encodingScheme) {
+  return {
+    erasure_n: ERASURE_CODE_PARAMS[encodingScheme].erasure_n,
+    erasure_k: ERASURE_CODE_PARAMS[encodingScheme].erasure_k,
+    erasure_d: ERASURE_CODE_PARAMS[encodingScheme].erasure_d,
+    chunkSizeBytes: DEFAULT_CHUNK_SIZE_BYTES,
+    enumIndex: ERASURE_CODE_PARAMS[encodingScheme].enumIndex
+  };
+}
+
+// src/core/erasure/reed-solomon.ts
+import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
+var DEFAULT_ERASURE_K2 = 10;
+var DEFAULT_ERASURE_N2 = 16;
+var DEFAULT_CHUNK_SIZE_BYTES2 = 2 * 1024 * 1024;
+var ReedSolomonErasureCodingProvider = class {
+  config;
+  constructor(options) {
+    const erasure_k = options?.erasure_k ?? DEFAULT_ERASURE_K2;
+    const erasure_n = options?.erasure_n ?? DEFAULT_ERASURE_N2;
+    const chunkSizeBytes = options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES2;
+    const enumIndex = -1;
+    if (erasure_k <= 0)
+      throw new Error("erasure_k (number of data chunks) must be > 0");
+    if (erasure_n <= erasure_k)
+      throw new Error(
+        `erasure_n (${erasure_n}) must be > erasure_k (${erasure_k})`
+      );
+    if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
+    this.config = {
+      erasure_n,
+      erasure_k,
+      chunkSizeBytes,
+      enumIndex
+    };
+  }
+  encode(data) {
+    const { erasure_k, erasure_n, chunkSizeBytes } = this.config;
+    const erasure_m = erasure_n - erasure_k;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (data.byteLength !== systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    const reedSolomon = createWasmReedSolomonBinding();
+    const shards = new Uint8Array(
+      systematicCapacity + erasure_m * chunkSizeBytes
+    );
+    shards.set(data, 0);
+    reedSolomon.encode(shards, erasure_k, erasure_m);
+    const chunks = new Array(erasure_n);
+    for (let idx = 0; idx < erasure_n; idx++) {
+      const start = idx * chunkSizeBytes;
+      chunks[idx] = shards.slice(start, start + chunkSizeBytes);
+    }
+    return {
+      chunks,
+      systematic: chunks.slice(0, erasure_k),
+      parity: chunks.slice(erasure_k)
+    };
+  }
+  decode(_available, _config) {
+    throw new Error(
+      "ReedSolomonErasureCodingProvider does not implement decode"
+    );
+  }
+  getChunkMerkleRoots() {
+    throw new Error(
+      "ReedSolomonErasureCodingProvider does not implement getChunkMerkleRoots"
+    );
+  }
+};
 export {
   ClayErasureCodingProvider,
   DEFAULT_ERASURE_D,

package/dist/core/erasure/provider.d.ts

@@ -1,2 +1,2 @@
 import '@shelby-protocol/clay-codes';
-export { D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, I as InitConfig } from '../../clay-codes-DHP-bYcP.js';
+export { D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, I as InitConfig } from '../../clay-codes-DdXABBDx.js';

package/dist/core/erasure/reed-solomon.d.ts

@@ -1,2 +1,2 @@
 import '@shelby-protocol/clay-codes';
-export { d as ReedSolomonConfig, R as ReedSolomonErasureCodingProvider, e as ReedSolomonProviderOptions } from '../../clay-codes-DHP-bYcP.js';
+export { d as ReedSolomonConfig, R as ReedSolomonErasureCodingProvider, e as ReedSolomonProviderOptions } from '../../clay-codes-DdXABBDx.js';

package/dist/core/erasure/reed-solomon.mjs

@@ -1,7 +1,71 @@
-import {
-  ReedSolomonErasureCodingProvider
-} from "../../chunk-NHWWORCH.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+// src/core/erasure/reed-solomon.ts
+import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
+var DEFAULT_ERASURE_K = 10;
+var DEFAULT_ERASURE_N = 16;
+var DEFAULT_CHUNK_SIZE_BYTES = 2 * 1024 * 1024;
+var ReedSolomonErasureCodingProvider = class {
+  config;
+  constructor(options) {
+    const erasure_k = options?.erasure_k ?? DEFAULT_ERASURE_K;
+    const erasure_n = options?.erasure_n ?? DEFAULT_ERASURE_N;
+    const chunkSizeBytes = options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES;
+    const enumIndex = -1;
+    if (erasure_k <= 0)
+      throw new Error("erasure_k (number of data chunks) must be > 0");
+    if (erasure_n <= erasure_k)
+      throw new Error(
+        `erasure_n (${erasure_n}) must be > erasure_k (${erasure_k})`
+      );
+    if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
+    this.config = {
+      erasure_n,
+      erasure_k,
+      chunkSizeBytes,
+      enumIndex
+    };
+  }
+  encode(data) {
+    const { erasure_k, erasure_n, chunkSizeBytes } = this.config;
+    const erasure_m = erasure_n - erasure_k;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (data.byteLength !== systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    const reedSolomon = createWasmReedSolomonBinding();
+    const shards = new Uint8Array(
+      systematicCapacity + erasure_m * chunkSizeBytes
+    );
+    shards.set(data, 0);
+    reedSolomon.encode(shards, erasure_k, erasure_m);
+    const chunks = new Array(erasure_n);
+    for (let idx = 0; idx < erasure_n; idx++) {
+      const start = idx * chunkSizeBytes;
+      chunks[idx] = shards.slice(start, start + chunkSizeBytes);
+    }
+    return {
+      chunks,
+      systematic: chunks.slice(0, erasure_k),
+      parity: chunks.slice(erasure_k)
+    };
+  }
+  decode(_available, _config) {
+    throw new Error(
+      "ReedSolomonErasureCodingProvider does not implement decode"
+    );
+  }
+  getChunkMerkleRoots() {
+    throw new Error(
+      "ReedSolomonErasureCodingProvider does not implement getChunkMerkleRoots"
+    );
+  }
+};
 export {
   ReedSolomonErasureCodingProvider
 };

package/dist/core/erasure/utils.d.ts

@@ -1,4 +1,4 @@
-import { a as ErasureCodingProvider } from '../../clay-codes-DHP-bYcP.js';
+import { a as ErasureCodingProvider } from '../../clay-codes-DdXABBDx.js';
 import '@shelby-protocol/clay-codes';
 
 declare function allocateAndCopy(data: Uint8Array, desiredLength: number): Uint8Array;

package/dist/core/erasure/utils.mjs

@@ -1,5 +1,3 @@
-import "../../chunk-7P6ASYW6.mjs";
-
 // src/core/erasure/utils.ts
 function allocateAndCopy(data, desiredLength) {
   if (data.byteLength === desiredLength) {

package/dist/core/errors.mjs

@@ -1,11 +1,32 @@
-import {
-  ShelbyErrorCodes,
-  isAccessDeniedError,
-  isBlobAlreadyExistsError,
-  isBlobExpiredError,
-  isBlobNotFoundError
-} from "../chunk-CQ6QPIZK.mjs";
-import "../chunk-7P6ASYW6.mjs";
+// src/core/errors.ts
+var ShelbyErrorCodes = {
+  // blob_metadata.move errors
+  E_BLOB_NOT_FOUND: "E_BLOB_NOT_FOUND",
+  E_INVALID_EXPIRATION_TIME: "E_INVALID_EXPIRATION_TIME",
+  E_TEST_ENCODING_NOT_ALLOWED: "E_TEST_ENCODING_NOT_ALLOWED",
+  E_BLOB_NOT_EXPIRED: "E_BLOB_NOT_EXPIRED",
+  E_INVALID_CHUNKSET_COUNT: "E_INVALID_CHUNKSET_COUNT",
+  E_NOT_BLOB_OWNER: "E_NOT_BLOB_OWNER",
+  E_NOT_ADMIN: "E_NOT_ADMIN",
+  E_BLOB_EXPIRED: "E_BLOB_EXPIRED",
+  E_BLOB_NAME_TOO_LONG: "E_BLOB_NAME_TOO_LONG",
+  E_INVALID_PAYMENT_EPOCHS: "E_INVALID_PAYMENT_EPOCHS",
+  E_NO_SLICES_AVAILABLE: "E_NO_SLICES_AVAILABLE",
+  // Common Aptos/Move errors
+  EALREADY_EXISTS: "EALREADY_EXISTS"
+};
+function isBlobAlreadyExistsError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.EALREADY_EXISTS) || errorMessage.includes("already exists");
+}
+function isAccessDeniedError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_NOT_BLOB_OWNER) || errorMessage.includes(ShelbyErrorCodes.E_NOT_ADMIN) || errorMessage.includes("ENOT_AUTHORIZED") || errorMessage.includes("not authorized") || errorMessage.includes("permission denied");
+}
+function isBlobNotFoundError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_BLOB_NOT_FOUND);
+}
+function isBlobExpiredError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_BLOB_EXPIRED);
+}
 export {
   ShelbyErrorCodes,
   isAccessDeniedError,

package/dist/core/index.d.ts

@@ -7,17 +7,17 @@ export { ShelbyClientConfig, ShelbyIndexerConfig, ShelbyRPCConfig } from './clie
 export { ShelbyMetadataClient } from './clients/ShelbyMetadataClient.js';
 export { ShelbyMicropaymentChannelClient } from './clients/ShelbyMicropaymentChannelClient.js';
 export { ShelbyPlacementGroupClient } from './clients/ShelbyPlacementGroupClient.js';
-export { BlobDataSource, PutBlobProgress, ShelbyRPCClient } from './clients/ShelbyRPCClient.js';
-export { BlobCommitments, BlobCommitmentsSchema, COMMITMENT_SCHEMA_VERSION, ChunksetCommitment, ChunksetCommitmentSchema, GenerateCommitmentsOptions, expectedTotalChunksets, generateCommitments, generateMerkleRoot } from './commitments.js';
+export { AuthScheme, BlobDataSource, BlobOwnerAuth, DerivableBlobOwnerAuth, Ed25519BlobOwnerAuth, PutBlobProgress, ShelbyRPCClient } from './clients/ShelbyRPCClient.js';
+export { BlobCommitments, BlobCommitmentsSchema, COMMITMENT_SCHEMA_VERSION, ChunksetCommitment, ChunksetCommitmentSchema, expectedTotalChunksets, generateCommitments, generateMerkleRoot } from './commitments.js';
 export { DEFAULT_PROJECT_DESCRIPTION, DEFAULT_PROJECT_NAME, MICROPAYMENTS_DEPLOYER, NetworkToGasStationBaseUrl, NetworkToShelbyBlobIndexerBaseUrl, NetworkToShelbyRPCBaseUrl, SHELBYUSD_FA_METADATA_ADDRESS, SHELBYUSD_TOKEN_ADDRESS, SHELBYUSD_TOKEN_MODULE, SHELBYUSD_TOKEN_NAME, SHELBY_DEPLOYER, TOKEN_DEPLOYER, TOKEN_OBJECT_ADDRESS } from './constants.js';
-export { C as ClayErasureCodingProvider, D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, R as ReedSolomonErasureCodingProvider } from '../clay-codes-DHP-bYcP.js';
+export { C as ClayErasureCodingProvider, D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, R as ReedSolomonErasureCodingProvider } from '../clay-codes-DdXABBDx.js';
 export { DEFAULT_ERASURE_D, DEFAULT_ERASURE_K, DEFAULT_ERASURE_M, DEFAULT_ERASURE_N, DEFAULT_SAMPLE_SIZE, ERASURE_CODE_PARAMS, ErasureCodeParams, ErasureCodingScheme, ErasureSchemeParams } from './erasure/constants.js';
 export { createDefaultErasureCodingProvider, defaultErasureCodingConfig, erasureCodingConfig16Total10Data13Helper, erasureCodingConfig4Total2Data3Helper } from './erasure/default.js';
 export { ShelbyErrorCodes, isAccessDeniedError, isBlobAlreadyExistsError, isBlobExpiredError, isBlobNotFoundError } from './errors.js';
 export { BlobName, BlobNameSchema, ChunkKey } from './layout.js';
 export { ShelbyNetwork, isShelbyNetwork, shelbyNetworks } from './networks.js';
 export { ShelbyIndexerClient, createShelbyIndexerClient, getShelbyIndexerClient } from './operations/index.js';
-export { CompleteMultipartUploadResponse, CompleteMultipartUploadResponseSchema, RPCErrorResponse, RPCErrorResponseSchema, StaleMicropaymentErrorResponse, StaleMicropaymentErrorResponseSchema, StartMultipartUploadResponse, StartMultipartUploadResponseSchema, UploadPartResponse, UploadPartResponseSchema } from './rpc-responses.js';
+export { ChallengeResponse, ChallengeResponseSchema, CompleteMultipartUploadResponse, CompleteMultipartUploadResponseSchema, MultipartUploadStatusResponse, MultipartUploadStatusResponseSchema, RPCErrorResponse, RPCErrorResponseSchema, StaleMicropaymentErrorResponse, StaleMicropaymentErrorResponseSchema, StartMultipartUploadResponse, StartMultipartUploadResponseSchema, UploadPartResponse, UploadPartResponseSchema } from './rpc-responses.js';
 export { getShelbyAccountBlobsExplorerUrl, getShelbyAccountExplorerUrl, getShelbyBlobExplorerUrl } from './shelby-explorer.js';
 export { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding, StorageProviderAck } from './types/blobs.js';
 export { ChannelInfo, SenderBuiltMicropayment, StaleChannelStateError } from './types/payments.js';