@shelby-protocol/sdk 0.1.0 → 0.2.1

package/dist/{chunk-3ZL3FSNA.mjs → chunk-CGYJLKBU.mjs}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-AABBONAF.mjs";
 import {
   NetworkToShelbyBlobIndexerBaseUrl
-} from "./chunk-FLLOQZVD.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
 
 // src/core/operations/index.ts
 import { Network } from "@aptos-labs/ts-sdk";

package/dist/{chunk-VRLIOKWG.mjs → chunk-D6GQHO6G.mjs}

@@ -1,6 +1,10 @@
 // src/core/networks.ts
 import { Network } from "@aptos-labs/ts-sdk";
-var shelbyNetworks = [Network.LOCAL, Network.SHELBYNET];
+var shelbyNetworks = [
+  Network.LOCAL,
+  Network.TESTNET,
+  Network.SHELBYNET
+];
 var isShelbyNetwork = (network) => {
   return shelbyNetworks.includes(network.toLowerCase());
 };

package/dist/{chunk-ZAM2EUVN.mjs → chunk-EFR6H3RT.mjs}

@@ -1,12 +1,12 @@
 import {
   StaleChannelStateError
-} from "./chunk-4MG4XGY4.mjs";
+} from "./chunk-KTVNKLBT.mjs";
 import {
   getShelbyIndexerClient
-} from "./chunk-3ZL3FSNA.mjs";
+} from "./chunk-CGYJLKBU.mjs";
 import {
   BlobNameSchema
-} from "./chunk-W5NRGZEP.mjs";
+} from "./chunk-Z4FZ7W6L.mjs";
 import {
   sleep
 } from "./chunk-I6NG5GNL.mjs";
@@ -16,14 +16,14 @@ import {
 } from "./chunk-IE6LYVIA.mjs";
 import {
   buildRequestUrl,
+  normalizeAddress,
   readInChunks
-} from "./chunk-4JZO2D7T.mjs";
+} from "./chunk-UEZNZBJO.mjs";
 import {
   NetworkToShelbyRPCBaseUrl
-} from "./chunk-FLLOQZVD.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
 
 // src/core/clients/ShelbyRPCClient.ts
-import { AccountAddress } from "@aptos-labs/ts-sdk";
 var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
 function encodeURIComponentKeepSlashes(str) {
   return encodeURIComponent(str).replace(/%2F/g, "/");
@@ -399,7 +399,7 @@ var ShelbyRPCClient = class {
       }
     });
     return {
-      account: AccountAddress.from(params.account),
+      account: normalizeAddress(params.account),
       name: params.blobName,
       readable: validatingStream,
       contentLength: expectedContentLength

package/dist/chunk-HPPMI7DC.mjs

@@ -0,0 +1,56 @@
+import {
+  ClayErasureCodingProvider
+} from "./chunk-OGKZ575S.mjs";
+import {
+  DEFAULT_CHUNK_SIZE_BYTES
+} from "./chunk-JTXYKO3U.mjs";
+import {
+  ERASURE_CODE_PARAMS
+} from "./chunk-AUQDI5BS.mjs";
+
+// src/core/erasure/default.ts
+var defaultProviderPromise;
+function createDefaultErasureCodingProvider() {
+  if (!defaultProviderPromise) {
+    defaultProviderPromise = ClayErasureCodingProvider.create(
+      defaultErasureCodingConfig()
+    );
+  }
+  return defaultProviderPromise;
+}
+function defaultErasureCodingConfig() {
+  console.log(
+    `default erasure coding, with env: ${process.env.SHELBY_ENCODING}`
+  );
+  const encoding = Number(process.env.SHELBY_ENCODING) || 0;
+  if (encoding === 0) {
+    console.log("getting default erasure coding (16,10,13)");
+    return erasureCodingConfig16Total10Data13Helper();
+  }
+  console.log("getting default erasure coding (4,2,3)");
+  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,
+  erasureCodingConfig16Total10Data13Helper,
+  erasureCodingConfig4Total2Data3Helper
+};

package/dist/{chunk-AGRRYZWV.mjs → chunk-IBAUPQOF.mjs}

@@ -1,28 +1,31 @@
+import {
+  defaultErasureCodingConfig
+} from "./chunk-HPPMI7DC.mjs";
 import {
   getShelbyIndexerClient
-} from "./chunk-3ZL3FSNA.mjs";
+} from "./chunk-CGYJLKBU.mjs";
 import {
   getAptosConfig
 } from "./chunk-AABBONAF.mjs";
 import {
   createBlobKey
-} from "./chunk-OTBLZL2S.mjs";
+} from "./chunk-3NRBHSMQ.mjs";
 import {
   expectedTotalChunksets
-} from "./chunk-RLRI2533.mjs";
+} from "./chunk-BXEVML7N.mjs";
 import {
-  getBlobNameSuffix
-} from "./chunk-4JZO2D7T.mjs";
+  getBlobNameSuffix,
+  normalizeAddress
+} from "./chunk-UEZNZBJO.mjs";
 import {
-  DEFAULT_CHUNKSET_SIZE_BYTES,
   ERASURE_CODE_AND_CHUNK_MAPPING
-} from "./chunk-67F5YZ25.mjs";
+} from "./chunk-JTXYKO3U.mjs";
 import {
   ERASURE_CODE_PARAMS
-} from "./chunk-LZSIZJYR.mjs";
+} from "./chunk-AUQDI5BS.mjs";
 import {
   SHELBY_DEPLOYER
-} from "./chunk-FLLOQZVD.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
 
 // src/core/clients/ShelbyBlobClient.ts
 import {
@@ -150,6 +153,14 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       const metadata = rawMetadata[0].vec[0];
       let encoding;
       if (metadata.encoding.__variant__ === "ClayCode_16Total_10Data_13Helper") {
+        console.log("read blob metadata with ClayCode_16Total_10Data_13Helper");
+        encoding = {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
+          ...ERASURE_CODE_AND_CHUNK_MAPPING[metadata.encoding.__variant__]
+        };
+      } else if (metadata.encoding.__variant__ === "ClayCode_4Total_2Data_3Helper") {
+        console.log("read blob metadata with ClayCode_4Total_2Data_3Helper");
         encoding = {
           variant: "clay",
           ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
@@ -164,14 +175,14 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         blobMerkleRoot: Hex.fromHexInput(
           metadata.blob_commitment
         ).toUint8Array(),
-        owner: AccountAddress.fromString(metadata.owner),
+        owner: normalizeAddress(metadata.owner),
         name: params.name,
         blobNameSuffix: getBlobNameSuffix(params.name),
         size: Number(metadata.blob_size),
         encoding,
         expirationMicros: Number(metadata.expiration_micros),
         creationMicros: Number(metadata.creation_micros),
-        sliceAddress: AccountAddress.fromString(metadata.slice.inner),
+        sliceAddress: normalizeAddress(metadata.slice.inner),
         isWritten: metadata.is_written
       };
     } catch (error) {
@@ -204,7 +215,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return this.getBlobs({
       where: {
         ...where,
-        owner: { _eq: AccountAddress.from(params.account).toString() }
+        owner: { _eq: normalizeAddress(params.account).toString() }
       },
       pagination: rest.pagination,
       orderBy: rest.orderBy
@@ -243,7 +254,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     });
     return blobs.map(
       (blob) => ({
-        owner: AccountAddress.from(blob.owner),
+        owner: normalizeAddress(blob.owner),
         name: blob.blob_name,
         blobNameSuffix: getBlobNameSuffix(blob.blob_name),
         blobMerkleRoot: Hex.fromHexInput(blob.blob_commitment).toUint8Array(),
@@ -256,7 +267,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         },
         expirationMicros: Number(blob.expires_at),
         creationMicros: Number(blob.created_at),
-        sliceAddress: AccountAddress.from(blob.slice_address),
+        sliceAddress: normalizeAddress(blob.slice_address),
         isWritten: Boolean(Number(blob.is_written)),
         isDeleted: Boolean(Number(blob.is_deleted))
       })
@@ -280,9 +291,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return blob_activities.map(
       (activity) => ({
         blobName: activity.blob_name,
-        accountAddress: AccountAddress.from(
-          activity.blob_name.substring(1, 65)
-        ),
+        accountAddress: normalizeAddress(activity.blob_name.substring(1, 65)),
         type: activityTypeMapping[activity.event_type] ?? "unknown",
         eventType: activity.event_type,
         eventIndex: Number(activity.event_index),
@@ -357,7 +366,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
   async registerBlob(params) {
     const options = this.mergeOptions(params.options);
     this.validateUsdSponsorConfig(options.usdSponsor, options.submit);
-    const chunksetSize = options.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
+    const config = params.config ?? defaultErasureCodingConfig();
+    const chunksetSize = config.chunkSizeBytes * config.erasure_k;
     const buildArgs = {
       ...options.build,
       data: _ShelbyBlobClient.createRegisterBlobPayload({
@@ -368,7 +378,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         blobMerkleRoot: params.blobMerkleRoot,
         numChunksets: expectedTotalChunksets(params.size, chunksetSize),
         expirationMicros: params.expirationMicros,
-        useSponsoredUsdVariant: options.usdSponsor !== void 0
+        useSponsoredUsdVariant: options.usdSponsor !== void 0,
+        encoding: config.enumIndex
       }),
       sender: params.account.accountAddress
     };
@@ -541,7 +552,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
   async batchRegisterBlobs(params) {
     const options = this.mergeOptions(params.options);
     this.validateUsdSponsorConfig(options.usdSponsor, options.submit);
-    const chunksetSize = options.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
+    const config = params.config ?? defaultErasureCodingConfig();
+    const chunksetSize = config.chunkSizeBytes * config.erasure_k;
     const buildArgs = {
       ...options.build,
       sender: params.account.accountAddress,
@@ -555,7 +567,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
           blobMerkleRoot: blob.blobMerkleRoot,
           numChunksets: expectedTotalChunksets(blob.blobSize, chunksetSize)
         })),
-        useSponsoredUsdVariant: options.usdSponsor !== void 0
+        useSponsoredUsdVariant: options.usdSponsor !== void 0,
+        encoding: config.enumIndex
       })
     };
     const transaction = options.usdSponsor ? await this.aptos.transaction.build.multiAgent({
@@ -599,8 +612,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         // TODO
         0,
         // payment tier
-        0
-        // encoding
+        params.encoding
       ]
     };
   }
@@ -645,7 +657,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         blobSizes,
         // TODO
         0,
-        0
+        // payment tier
+        params.encoding
       ]
     };
   }

package/dist/{chunk-67F5YZ25.mjs → chunk-JTXYKO3U.mjs}

@@ -1,6 +1,7 @@
 // src/core/chunk.ts
 var ChunkSizeScheme = /* @__PURE__ */ ((ChunkSizeScheme2) => {
   ChunkSizeScheme2["ChunkSet10MiB_Chunk1MiB"] = "ChunkSet10MiB_Chunk1MiB";
+  ChunkSizeScheme2["ChunkSet2MiB_Chunk1MiB"] = "ChunkSet2MiB_Chunk1MiB";
   return ChunkSizeScheme2;
 })(ChunkSizeScheme || {});
 var CHUNK_SIZE_PARAMS = {
@@ -9,6 +10,12 @@ var CHUNK_SIZE_PARAMS = {
     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;
@@ -16,6 +23,9 @@ var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /*
 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
   }
 };
 

package/dist/chunk-KTVNKLBT.mjs

@@ -0,0 +1,207 @@
+import {
+  MICROPAYMENTS_DEPLOYER
+} from "./chunk-4ZOFT75Q.mjs";
+
+// src/core/types/payments.ts
+import {
+  AccountAddress,
+  Deserializer,
+  Hex,
+  Serializer
+} from "@aptos-labs/ts-sdk";
+var MICROPAYMENTS_MODULE_NAME = "micropayments";
+var WITHDRAW_APPROVAL_STRUCT_NAME = "WithdrawApproval";
+function serializeTypeInfo(serializer, moduleAddress, moduleName, structName) {
+  moduleAddress.serialize(serializer);
+  const moduleNameBytes = new TextEncoder().encode(moduleName);
+  serializer.serializeBytes(moduleNameBytes);
+  const structNameBytes = new TextEncoder().encode(structName);
+  serializer.serializeBytes(structNameBytes);
+}
+var StaleChannelStateError = class _StaleChannelStateError extends Error {
+  /**
+   * The last valid micropayment stored by the server.
+   * Clients can use this to reset their local channel state.
+   */
+  storedMicropayment;
+  constructor(storedMicropayment, message) {
+    super(
+      message ?? "Client has stale channel state. Use the returned micropayment to reset local state."
+    );
+    this.name = "StaleChannelStateError";
+    this.storedMicropayment = storedMicropayment;
+  }
+  /**
+   * Returns the stored micropayment as a base64-encoded string.
+   */
+  toBase64() {
+    const bytes = this.storedMicropayment.bcsToBytes();
+    const binaryString = Array.from(
+      bytes,
+      (byte) => String.fromCharCode(byte)
+    ).join("");
+    return btoa(binaryString);
+  }
+  /**
+   * Creates a StaleChannelStateError from a base64-encoded micropayment string.
+   */
+  static fromBase64(base64, message) {
+    const binaryString = atob(base64);
+    const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    const micropayment = SenderBuiltMicropayment.deserialize(bytes);
+    return new _StaleChannelStateError(micropayment, message);
+  }
+};
+var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
+  /**
+   * The sender's address (owner of the payment channel).
+   */
+  sender;
+  /**
+   * The receiver's address (beneficiary of the withdrawal).
+   */
+  receiver;
+  /**
+   * The unique ID of the payment channel.
+   */
+  paymentChannelId;
+  /**
+   * The cumulative amount the receiver is authorized to withdraw.
+   */
+  amount;
+  /**
+   * The fungible asset metadata address.
+   */
+  fungibleAssetAddress;
+  /**
+   * Monotonically increasing sequence number for replay protection.
+   */
+  sequenceNumber;
+  /**
+   * The sender's Ed25519 public key (32 bytes).
+   * Used by the receiver to verify the signature before submitting.
+   */
+  publicKey;
+  /**
+   * The Ed25519 signature of the SignedMessage<WithdrawApproval> struct.
+   * The SignedMessage includes TypeInfo for domain separation.
+   */
+  signature;
+  /**
+   * The deployer address of the micropayments module.
+   * This is needed to reconstruct the TypeInfo for signature verification.
+   */
+  deployer;
+  constructor(sender, receiver, paymentChannelId, amount, fungibleAssetAddress, sequenceNumber, publicKey, signature, deployer) {
+    this.sender = sender;
+    this.receiver = receiver;
+    this.paymentChannelId = paymentChannelId;
+    this.amount = amount;
+    this.fungibleAssetAddress = fungibleAssetAddress;
+    this.sequenceNumber = sequenceNumber;
+    this.publicKey = publicKey;
+    this.signature = signature;
+    this.deployer = deployer ?? AccountAddress.fromString(MICROPAYMENTS_DEPLOYER);
+  }
+  /**
+   * Creates the BCS-serialized message that was signed.
+   * This is a SignedMessage<WithdrawApproval> which includes:
+   * 1. TypeInfo (module_address, module_name, struct_name)
+   * 2. WithdrawApproval struct fields
+   *
+   * This format is used with signature_verify_strict_t for domain separation.
+   */
+  getSignedMessage() {
+    return _SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
+      sender: this.sender,
+      receiver: this.receiver,
+      fungibleAssetAddress: this.fungibleAssetAddress,
+      amount: this.amount,
+      paymentChannelId: this.paymentChannelId,
+      sequenceNumber: this.sequenceNumber
+    });
+  }
+  /**
+   * Static helper to build the SignedMessage<WithdrawApproval> bytes from raw parameters.
+   * This can be used to create the message for signing without constructing the full object.
+   *
+   * @param params - The withdrawal approval parameters.
+   * @returns The BCS-serialized SignedMessage<WithdrawApproval> bytes.
+   */
+  static buildSignedMessage(params) {
+    const serializer = new Serializer();
+    serializeTypeInfo(
+      serializer,
+      params.deployer,
+      MICROPAYMENTS_MODULE_NAME,
+      WITHDRAW_APPROVAL_STRUCT_NAME
+    );
+    params.sender.serialize(serializer);
+    params.receiver.serialize(serializer);
+    params.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(params.amount);
+    serializer.serializeU64(params.paymentChannelId);
+    serializer.serializeU64(params.sequenceNumber);
+    return serializer.toUint8Array();
+  }
+  serialize(serializer) {
+    this.sender.serialize(serializer);
+    this.receiver.serialize(serializer);
+    this.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(this.amount);
+    serializer.serializeU64(this.paymentChannelId);
+    serializer.serializeU64(this.sequenceNumber);
+    serializer.serializeBytes(this.publicKey);
+    serializer.serializeBytes(this.signature);
+    this.deployer.serialize(serializer);
+  }
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  bcsToHex() {
+    return Hex.fromHexInput(this.bcsToBytes());
+  }
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  toString() {
+    return this.bcsToHex().toString();
+  }
+  /**
+   * Deserializes a SenderBuiltMicropayment from BCS bytes.
+   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
+   * @returns A new SenderBuiltMicropayment instance.
+   */
+  static deserialize(bytes) {
+    const bytesArray = typeof bytes === "string" ? Hex.fromHexInput(bytes).toUint8Array() : bytes;
+    const deserializer = new Deserializer(bytesArray);
+    const sender = AccountAddress.deserialize(deserializer);
+    const receiver = AccountAddress.deserialize(deserializer);
+    const fungibleAssetAddress = AccountAddress.deserialize(deserializer);
+    const amount = deserializer.deserializeU64();
+    const paymentChannelId = deserializer.deserializeU64();
+    const sequenceNumber = deserializer.deserializeU64();
+    const publicKey = deserializer.deserializeBytes();
+    const signature = deserializer.deserializeBytes();
+    const deployer = AccountAddress.deserialize(deserializer);
+    return new _SenderBuiltMicropayment(
+      sender,
+      receiver,
+      paymentChannelId,
+      amount,
+      fungibleAssetAddress,
+      sequenceNumber,
+      publicKey,
+      signature,
+      deployer
+    );
+  }
+};
+
+export {
+  StaleChannelStateError,
+  SenderBuiltMicropayment
+};

package/dist/{chunk-PZF2VTGP.mjs → chunk-NHWWORCH.mjs}

@@ -9,6 +9,7 @@ var ReedSolomonErasureCodingProvider = class {
     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)
@@ -19,7 +20,8 @@ var ReedSolomonErasureCodingProvider = class {
     this.config = {
       erasure_n,
       erasure_k,
-      chunkSizeBytes
+      chunkSizeBytes,
+      enumIndex
     };
   }
   encode(data) {

package/dist/{chunk-UCDAABAS.mjs → chunk-OGKZ575S.mjs}

@@ -1,12 +1,3 @@
-import {
-  DEFAULT_CHUNK_SIZE_BYTES
-} from "./chunk-67F5YZ25.mjs";
-import {
-  DEFAULT_ERASURE_D,
-  DEFAULT_ERASURE_K,
-  DEFAULT_ERASURE_N
-} from "./chunk-LZSIZJYR.mjs";
-
 // src/core/erasure/clay-codes.ts
 import {
   createDecoder,
@@ -27,13 +18,7 @@ var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
   /**
    * Static factory method to create an initialized ClayErasureCodingProvider
    */
-  static async create(options) {
-    const config = buildClayConfig({
-      erasure_n: options?.erasure_n ?? DEFAULT_ERASURE_N,
-      erasure_k: options?.erasure_k ?? DEFAULT_ERASURE_K,
-      erasure_d: options?.erasure_d ?? DEFAULT_ERASURE_D,
-      chunkSizeBytes: options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES
-    });
+  static async create(config) {
     const provider = new _ClayErasureCodingProvider(config);
     [provider.encoderCache, provider.decoderCache] = await Promise.all([
       createEncoder({
@@ -118,7 +103,7 @@ var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
   }
 };
 function buildClayConfig(input) {
-  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes } = input;
+  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes, enumIndex } = input;
   if (erasure_n <= 0)
     throw new Error("erasure_n (total number of chunks) must be > 0");
   if (erasure_k <= 0)
@@ -140,10 +125,12 @@ function buildClayConfig(input) {
     erasure_n,
     erasure_k,
     erasure_d,
-    chunkSizeBytes
+    chunkSizeBytes,
+    enumIndex
   };
 }
 
 export {
-  ClayErasureCodingProvider
+  ClayErasureCodingProvider,
+  buildClayConfig
 };