@shelby-protocol/sdk 0.0.1-experimental.4 → 0.0.1

package/dist/node/index.mjs

@@ -1,88 +1,141 @@
-import "../chunk-7S6RVKYB.mjs";
+import "../chunk-MB7C7VQF.mjs";
+import {
+  ShelbyMetadataClient
+} from "../chunk-NTJSNNA7.mjs";
 import {
   ShelbyNodeClient
-} from "../chunk-C33H3C3N.mjs";
+} from "../chunk-EAPAG4L7.mjs";
 import {
   testUtil_exports
 } from "../chunk-A4IG6GSE.mjs";
-import "../chunk-PLUDE5C3.mjs";
+import "../chunk-TUANYVZQ.mjs";
+import "../chunk-RNXGC54D.mjs";
 import "../chunk-MWDW4ROU.mjs";
 import "../chunk-ZHXCVRZX.mjs";
-import "../chunk-IHTPXUYI.mjs";
-import "../chunk-QKT5R735.mjs";
+import "../chunk-MQUVYMNQ.mjs";
 import {
   ShelbyClient
-} from "../chunk-QM5BVKLD.mjs";
+} from "../chunk-6MDQI7PW.mjs";
 import {
   ShelbyBlobClient
-} from "../chunk-B3CB2YEO.mjs";
+} from "../chunk-XGMJ4CG4.mjs";
+import "../chunk-Z7RFCADT.mjs";
 import {
   ShelbyRPCClient
-} from "../chunk-2FF5FICZ.mjs";
+} from "../chunk-JSR44EDC.mjs";
+import {
+  createShelbyIndexerClient,
+  getShelbyIndexerClient
+} from "../chunk-75VHXY5P.mjs";
+import "../chunk-DLMDDEWF.mjs";
+import "../chunk-RBFWGDMY.mjs";
+import "../chunk-I6NG5GNL.mjs";
 import {
   createBlobKey
-} from "../chunk-QEMIORTL.mjs";
+} from "../chunk-OTBLZL2S.mjs";
 import {
   BlobCommitmentsSchema,
   ChunksetCommitmentSchema,
+  expectedTotalChunksets,
   generateCommitments
-} from "../chunk-G263DBCY.mjs";
+} from "../chunk-LTV26KU4.mjs";
 import {
+  buildRequestUrl,
   concatHashes,
   readInChunks,
-  zeroPadBuffer
-} from "../chunk-5Z3RVWU3.mjs";
+  zeroPadBytes
+} from "../chunk-KBUWZXFA.mjs";
 import {
-  erasureEncode
-} from "../chunk-P7BVGLTV.mjs";
+  DEFAULT_PROJECT_DESCRIPTION,
+  DEFAULT_PROJECT_NAME,
+  NetworkToShelbyBlobIndexerBaseUrl,
+  NetworkToShelbyRPCBaseUrl,
+  SHELBYUSD_TOKEN_ADDRESS,
+  SHELBYUSD_TOKEN_MODULE,
+  SHELBYUSD_TOKEN_NAME,
+  SHELBYUSD_TOKEN_TYPE,
+  SHELBY_DEPLOYER,
+  TOKEN_DEPLOYER,
+  TOKEN_OBJECT_ADDRESS
+} from "../chunk-HPVCKAN2.mjs";
 import {
   BlobNameSchema,
   ChunkKey,
   allChunksForBlob,
   roundSize
-} from "../chunk-GGYTHP5F.mjs";
+} from "../chunk-FIFKKWXV.mjs";
 import {
-  CHUNKSET_SIZE_BYTES,
-  DEFAULT_PROJECT_DESCRIPTION,
-  DEFAULT_PROJECT_NAME,
-  DEFAULT_SHELBY_BASE_URL,
-  ERASURE_K,
-  ERASURE_M,
-  SHELBY_DEPLOYER,
-  TOKEN_DEPLOYER,
-  TOKEN_OBJECT_ADDRESS,
-  getChunkSizeBytes,
-  getChunksetSizeBytes
-} from "../chunk-D2FERD4A.mjs";
-import "../chunk-I6NG5GNL.mjs";
+  CHUNK_SIZE_PARAMS,
+  ChunkSizeScheme,
+  ClayErasureCodingProvider,
+  DEFAULT_CHUNKSET_SIZE_BYTES,
+  DEFAULT_CHUNK_SIZE_BYTES,
+  ERASURE_CODE_AND_CHUNK_MAPPING,
+  createDefaultErasureCodingProvider
+} from "../chunk-APML3CGJ.mjs";
+import {
+  ReedSolomonErasureCodingProvider
+} from "../chunk-3ZDXWPYC.mjs";
+import {
+  DEFAULT_ERASURE_D,
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_M,
+  DEFAULT_ERASURE_N,
+  ERASURE_CODE_PARAMS,
+  ErasureCodingScheme
+} from "../chunk-ZPW742E7.mjs";
+import {
+  isShelbyNetwork,
+  shelbyNetworks
+} from "../chunk-VRLIOKWG.mjs";
 import "../chunk-7P6ASYW6.mjs";
 export {
   BlobCommitmentsSchema,
   BlobNameSchema,
-  CHUNKSET_SIZE_BYTES,
+  CHUNK_SIZE_PARAMS,
   ChunkKey,
+  ChunkSizeScheme,
   ChunksetCommitmentSchema,
+  ClayErasureCodingProvider,
+  DEFAULT_CHUNKSET_SIZE_BYTES,
+  DEFAULT_CHUNK_SIZE_BYTES,
+  DEFAULT_ERASURE_D,
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_M,
+  DEFAULT_ERASURE_N,
   DEFAULT_PROJECT_DESCRIPTION,
   DEFAULT_PROJECT_NAME,
-  DEFAULT_SHELBY_BASE_URL,
-  ERASURE_K,
-  ERASURE_M,
+  ERASURE_CODE_AND_CHUNK_MAPPING,
+  ERASURE_CODE_PARAMS,
+  ErasureCodingScheme,
+  NetworkToShelbyBlobIndexerBaseUrl,
+  NetworkToShelbyRPCBaseUrl,
+  ReedSolomonErasureCodingProvider,
+  SHELBYUSD_TOKEN_ADDRESS,
+  SHELBYUSD_TOKEN_MODULE,
+  SHELBYUSD_TOKEN_NAME,
+  SHELBYUSD_TOKEN_TYPE,
   SHELBY_DEPLOYER,
   ShelbyBlobClient,
   ShelbyClient,
+  ShelbyMetadataClient,
   ShelbyNodeClient,
   ShelbyRPCClient,
   TOKEN_DEPLOYER,
   TOKEN_OBJECT_ADDRESS,
   allChunksForBlob,
+  buildRequestUrl,
   concatHashes,
   createBlobKey,
-  erasureEncode,
+  createDefaultErasureCodingProvider,
+  createShelbyIndexerClient,
+  expectedTotalChunksets,
   generateCommitments,
-  getChunkSizeBytes,
-  getChunksetSizeBytes,
+  getShelbyIndexerClient,
+  isShelbyNetwork,
   readInChunks,
   roundSize,
+  shelbyNetworks,
   testUtil_exports as testUtil,
-  zeroPadBuffer
+  zeroPadBytes
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shelby-protocol/sdk",
-  "version": "0.0.1-experimental.4",
+  "version": "0.0.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -19,13 +19,33 @@
       "import": "./dist/browser/index.mjs"
     }
   },
+  "scripts": {
+    "prepublishOnly": "pnpm run build",
+    "lint": "biome check .",
+    "fmt": "biome check . --write",
+    "generate": "graphql-codegen",
+    "generate:watch": "graphql-codegen --watch",
+    "verify:config": "tsx scripts/verify-config.ts",
+    "build": "tsc --noEmit && (rimraf dist; tsup) && pnpm run verify:config",
+    "test": "vitest dev",
+    "test:once": "vitest run",
+    "benchmark:erasure": "tsx benchmark/erasure.ts"
+  },
   "dependencies": {
-    "zod": "^3.24.3",
-    "@shelby-protocol/reed-solomon": "0.0.1-experimental.1"
+    "@shelby-protocol/reed-solomon": "workspace:*",
+    "graphql": "^16.11.0",
+    "graphql-request": "^7.2.0",
+    "graphql-tag": "^2.12.6",
+    "@shelby-protocol/clay-codes": "workspace:*",
+    "zod": "^3.24.3"
   },
   "devDependencies": {
-    "@aptos-labs/ts-sdk": "^5.0.0",
+    "@aptos-labs/ts-sdk": "^5.1.1",
+    "@graphql-codegen/cli": "^6.0.0",
+    "@graphql-codegen/typescript-graphql-request": "^6.3.0",
+    "@parcel/watcher": "^2.5.1",
     "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22",
     "dotenv": "^16.5.0",
     "fs-extra": "^11.3.1",
     "rimraf": "^6",
@@ -36,12 +56,5 @@
   },
   "peerDependencies": {
     "@aptos-labs/ts-sdk": "^2.0.1 || ^3.0.0 || ^4.0.0 || ^5.0.0"
-  },
-  "scripts": {
-    "lint": "biome check .",
-    "fmt": "biome check . --write",
-    "build": "tsc --noEmit && (rimraf dist; tsup)",
-    "test": "vitest dev",
-    "test:once": "vitest run"
   }
-}
+}

package/dist/chunk-5Z3RVWU3.mjs

@@ -1,67 +0,0 @@
-// src/core/utils.ts
-import { Hex } from "@aptos-labs/ts-sdk";
-async function* readInChunks(input, chunkSize) {
-  let idx = 0;
-  if (Buffer.isBuffer(input)) {
-    for (let offset = 0; offset < input.length; offset += chunkSize) {
-      yield [idx++, Buffer.from(input.subarray(offset, offset + chunkSize))];
-    }
-    return;
-  }
-  const reader = input.getReader();
-  let buffer = new Uint8Array(chunkSize);
-  let bufferWriteOffset = 0;
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      if (value === void 0) continue;
-      let srcOffset = 0;
-      while (srcOffset < value.length) {
-        const remainingCapacity = chunkSize - bufferWriteOffset;
-        const bytesToCopy = Math.min(
-          remainingCapacity,
-          value.length - srcOffset
-        );
-        buffer.set(
-          value.subarray(srcOffset, srcOffset + bytesToCopy),
-          bufferWriteOffset
-        );
-        bufferWriteOffset += bytesToCopy;
-        srcOffset += bytesToCopy;
-        if (bufferWriteOffset >= chunkSize) {
-          yield [idx++, Buffer.from(buffer)];
-          buffer = new Uint8Array(chunkSize);
-          bufferWriteOffset = 0;
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  if (bufferWriteOffset > 0) {
-    yield [idx++, Buffer.from(buffer.subarray(0, bufferWriteOffset))];
-  }
-}
-function zeroPadBuffer(buffer, desiredLength) {
-  if (buffer.length >= desiredLength) {
-    return buffer;
-  }
-  const paddedBuffer = Buffer.alloc(desiredLength);
-  buffer.copy(paddedBuffer);
-  return paddedBuffer;
-}
-async function concatHashes(parts) {
-  const combined = Buffer.concat(
-    parts.map((part) => Hex.fromHexInput(part).toUint8Array())
-  );
-  return Hex.fromHexInput(
-    new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
-  );
-}
-
-export {
-  readInChunks,
-  zeroPadBuffer,
-  concatHashes
-};

package/dist/chunk-B3CB2YEO.mjs

@@ -1,318 +0,0 @@
-import {
-  createBlobKey
-} from "./chunk-QEMIORTL.mjs";
-import {
-  SHELBY_DEPLOYER
-} from "./chunk-D2FERD4A.mjs";
-
-// src/core/clients/ShelbyBlobClient.ts
-import {
-  AccountAddress,
-  Aptos,
-  Hex,
-  MoveVector
-} from "@aptos-labs/ts-sdk";
-var ShelbyBlobClient = class _ShelbyBlobClient {
-  aptos;
-  deployer;
-  /**
-   * The ShelbyBlobClient is used to interact with the Shelby contract on the Aptos blockchain. This
-   * includes functions like writing blob commitments, confirming chunks, and retrieving blob metadata.
-   *
-   * @param config.aptos.config - The Aptos config.
-   * @param config.shelbyDeployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
-   *
-   * @example
-   * ```typescript
-   * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
-   * const blobClient = new ShelbyBlobClient({ aptos });
-   * ```
-   */
-  constructor(config) {
-    this.aptos = new Aptos(config.aptos.config);
-    this.deployer = config.shelby?.deployer ?? AccountAddress.fromString(SHELBY_DEPLOYER);
-  }
-  /**
-   * Retrieves the blob metadata from the blockchain. If it does not exist,
-   * returns `undefined`.
-   *
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.name - The name of the blob (e.g. "foo/bar")
-   * @returns The blob metadata.
-   *
-   * @example
-   * ```typescript
-   * const metadata = await client.getBlobMetadata({
-   *   account: AccountAddress.fromString("0x1"),
-   *   name: "foo/bar.txt",
-   * });
-   * ```
-   */
-  async getBlobMetadata(params) {
-    try {
-      const rawMetadata = await this.aptos.view({
-        payload: {
-          function: `${this.deployer.toString()}::prototype_interface::get_metadata`,
-          functionArguments: [
-            createBlobKey({
-              account: params.account,
-              blobName: params.name
-            })
-          ]
-        }
-      });
-      const metadata = rawMetadata[0];
-      return {
-        blobMerkleRoot: Hex.fromHexInput(
-          metadata.blob_merkle_root
-        ).toUint8Array(),
-        owner: AccountAddress.fromString(metadata.owner),
-        name: metadata.name,
-        size: metadata.size,
-        encoding: {
-          variant: "clay",
-          erasureK: metadata.encoding.num_data_chunks,
-          erasureM: metadata.encoding.num_parity_chunks,
-          chunksetSize: metadata.encoding.chunkset_size
-        },
-        expirationMicros: metadata.expiration_micros
-      };
-    } catch (error) {
-      if (error instanceof Error && // Depending on the network, the error message may show up differently.
-      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND"))) {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Retrieves all the blobs and their metadata for an account from the
-   * blockchain.
-   *
-   * @param params.account - The account namespace the blobs are stored in (e.g. "0x1")
-   * @returns The blob metadata for all the blobs for the account.
-   *
-   * @example
-   * ```typescript
-   * // BlobMetadata[]
-   * const blobs = await client.getAccountBlobs({
-   *   account: AccountAddress.fromString("0x1"),
-   * });
-   * ```
-   */
-  async getAccountBlobs(params) {
-    const rawBlobMetadatas = await this.aptos.view({
-      payload: {
-        function: `${this.deployer.toString()}::prototype_interface::get_blobs_for_owner`,
-        functionArguments: [params.account.toString()]
-      }
-    });
-    return rawBlobMetadatas[0].map((blob) => ({
-      blobMerkleRoot: Hex.fromHexInput(blob.blob_merkle_root).toUint8Array(),
-      owner: AccountAddress.fromString(blob.owner),
-      name: blob.name,
-      size: blob.size,
-      encoding: {
-        variant: "clay",
-        erasureK: blob.encoding.num_data_chunks,
-        erasureM: blob.encoding.num_parity_chunks,
-        chunksetSize: blob.encoding.chunkset_size
-      },
-      expirationMicros: blob.expiration_micros
-    }));
-  }
-  /**
-   * Retrieves the blob chunks for a given blob from the blockchain. The blob chunk will contain
-   * the commitment, the storage provider location, and the status of the chunk (stored or pending).
-   *
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.name - The name of the blob (e.g. "foo/bar")
-   * @returns The chunks that make up the blob.
-   *
-   * @example
-   * ```typescript
-   * // BlobChunk[]
-   * const chunks = await client.getBlobChunks({
-   *   account: AccountAddress.fromString("0x1"),
-   *   name: "foo/bar.txt",
-   * });
-   *
-   * const isStored = chunks.every((c) => c.location.variant === "stored");
-   * ```
-   */
-  async getBlobChunks(params) {
-    const chunks = await this.aptos.view({
-      payload: {
-        function: `${this.deployer.toString()}::prototype_interface::get_chunks`,
-        functionArguments: [
-          createBlobKey({
-            account: params.account,
-            blobName: params.name
-          })
-        ]
-      }
-    });
-    return chunks[0].map((c) => ({
-      commitment: Hex.fromHexInput(c.commitment).toUint8Array(),
-      location: {
-        variant: c.location.__variant__ === "Stored" ? "stored" : "pending",
-        provider: AccountAddress.fromString(c.location.provider)
-      }
-    }));
-  }
-  /**
-   * Writes the blob commitments to the blockchain.
-   *
-   * If `data` is provided instead of `blobCommitments`, the data will be encoded into commitments before being written
-   * to the blockchain.
-   *
-   * @param params.signer - The account that is signing the transaction.
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.expirationMicros - The expiration time of the blob in microseconds.
-   * @param params.options - Additional options for transaction building and encoding.
-   * @param params.blobCommitments - The blob commitments to write to the blockchain (required if `data` is not provided).
-   * @param params.data - The data to encode into commitments before writing to the blockchain (required if `blobCommitments` is not provided).
-   *
-   * @returns The blob commitments and the pending transaction.
-   *
-   * @example
-   * ```typescript
-   * const blobCommitments = await generateCommitments(data);
-   *
-   * const { blobCommitments, transaction } = await client.writeBlobCommitments({
-   *   signer,
-   *   blobName: "foo/bar.txt",
-   *   blobCommitments,
-   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
-   * });
-   * ```
-   */
-  async writeBlobCommitments(params) {
-    const blobCommitments = params.blobCommitments;
-    const transaction = await this.aptos.transaction.build.simple({
-      ...params.options?.build,
-      data: _ShelbyBlobClient.createWriteBlobCommitmentsPayload({
-        deployer: this.deployer,
-        account: params.signer.accountAddress,
-        blobName: params.blobName,
-        blobMerkleRoot: blobCommitments.blob_merkle_root,
-        chunksetChunkCommitments: blobCommitments.chunkset_commitments.map(
-          (chunkset) => chunkset.chunk_commitments
-        ),
-        size: blobCommitments.raw_data_size,
-        expirationMicros: params.expirationMicros
-      }),
-      sender: params.signer.accountAddress
-    });
-    return {
-      blobCommitments,
-      transaction: await this.aptos.signAndSubmitTransaction({
-        signer: params.signer,
-        transaction
-      })
-    };
-  }
-  /**
-   * Confirms an array of signed chunk commitments for a blob. Once all chunks for a blob are confirmed, the blob is
-   * considered "stored" and can be retrieved by RPC nodes.
-   *
-   * @param params.signer - The account that is signing the transaction.
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.signedChunksetChunkCommitments - The signed chunk commitments, signed by their storage provider.
-   * @param params.options - Additional options for transaction building and encoding.
-   *
-   * @returns The pending transaction response.
-   *
-   * @example
-   * ```typescript
-   * const { transaction } = await client.confirmBlobChunks({
-   *   signer,
-   *   account: AccountAddress.fromString("0x1"),
-   *   blobName: "foo/bar.txt",
-   *   signedChunksetChunkCommitments,
-   * });
-   * ```
-   */
-  async confirmBlobChunks(params) {
-    const transaction = await this.aptos.transaction.build.simple({
-      ...params.options?.build,
-      data: _ShelbyBlobClient.createConfirmBlobChunksPayload({
-        deployer: this.deployer,
-        account: params.account,
-        blobName: params.blobName,
-        signedChunksetChunkCommitments: params.signedChunksetChunkCommitments
-      }),
-      sender: params.signer.accountAddress
-    });
-    return {
-      transaction: await this.aptos.signAndSubmitTransaction({
-        signer: params.signer,
-        transaction
-      })
-    };
-  }
-  /**
-   * Creates a transaction payload to write blob commitments to the blockchain.
-   *
-   * @param params.deployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.blobMerkleRoot - The blob merkle root.
-   * @param params.chunksetChunkCommitments - The chunk commitments for each chunkset.
-   * @param params.expirationMicros - The expiration time of the blob in microseconds.
-   * @param params.size - The size of the blob in bytes.
-   *
-   * @see https://github.com/JumpCrypto/shelby/blob/e009607aad330ccddb08d80bf9addfaadae7972b/move/prototype/move/sources/prototype_interface.move#L211-L220
-   */
-  static createWriteBlobCommitmentsPayload(params) {
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::prototype_interface::write_commitments`,
-      functionArguments: [
-        createBlobKey({
-          account: params.account,
-          blobName: params.blobName
-        }),
-        params.size,
-        MoveVector.U8(params.blobMerkleRoot),
-        params.chunksetChunkCommitments.map(
-          (chunkset) => chunkset.map((chunkCommitment) => MoveVector.U8(chunkCommitment))
-        ),
-        params.expirationMicros,
-        true
-      ]
-    };
-  }
-  /**
-   * Creates a transaction payload to confirm the chunks of a blob.
-   *
-   * @param params.deployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.signedChunksetChunkCommitments - The signed chunk commitments, signed by their storage provider.
-   *
-   * @see https://github.com/JumpCrypto/shelby/blob/e009607aad330ccddb08d80bf9addfaadae7972b/move/prototype/move/sources/prototype_interface.move#L343-L349
-   */
-  static createConfirmBlobChunksPayload(params) {
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::prototype_interface::write_complete`,
-      functionArguments: [
-        createBlobKey({
-          account: params.account,
-          blobName: params.blobName
-        }),
-        params.signedChunksetChunkCommitments.map(
-          (chunkset) => chunkset.map((chunk) => AccountAddress.from(chunk.provider))
-        ),
-        params.signedChunksetChunkCommitments.map(
-          (chunkset) => chunkset.map((chunk) => MoveVector.U8(chunk.signedCommitment))
-        ),
-        true
-      ]
-    };
-  }
-};
-
-export {
-  ShelbyBlobClient
-};

package/dist/chunk-D2FERD4A.mjs

@@ -1,39 +0,0 @@
-// src/core/constants.ts
-var DEFAULT_PROJECT_NAME = "shelby";
-var DEFAULT_PROJECT_DESCRIPTION = "High performance, decentralized storage";
-var DEFAULT_SHELBY_BASE_URL = "https://api.shelby.dev";
-var SHELBY_DEPLOYER = "0xc63d6a5efb0080a6029403131715bd4971e1149f7cc099aac69bb0069b3ddbf5";
-var TOKEN_DEPLOYER = "0x33009e852be7f93762dd0bf303383c2cb2c5cab7a30d8238ca5f9f177ae75124";
-var TOKEN_OBJECT_ADDRESS = "0x249f5c642a63885ff88a5113b3ba0079840af5a1357706f8c7f3bfc5dd12511f";
-var ERASURE_K = 2;
-var ERASURE_M = 1;
-var CHUNKSET_SIZE_BYTES = 10 * 1024 * 1024;
-function computeChunkSizeBytes(k, chunksetSize) {
-  const ret = chunksetSize / k;
-  if (!Number.isInteger(ret)) {
-    throw new Error(
-      `ChunksetSize and erasure coding number of chunks are incompatible: ${chunksetSize}/${k} is not an integer`
-    );
-  }
-  return ret;
-}
-function getChunksetSizeBytes() {
-  return CHUNKSET_SIZE_BYTES;
-}
-function getChunkSizeBytes() {
-  return computeChunkSizeBytes(ERASURE_K, getChunksetSizeBytes());
-}
-
-export {
-  DEFAULT_PROJECT_NAME,
-  DEFAULT_PROJECT_DESCRIPTION,
-  DEFAULT_SHELBY_BASE_URL,
-  SHELBY_DEPLOYER,
-  TOKEN_DEPLOYER,
-  TOKEN_OBJECT_ADDRESS,
-  ERASURE_K,
-  ERASURE_M,
-  CHUNKSET_SIZE_BYTES,
-  getChunksetSizeBytes,
-  getChunkSizeBytes
-};