@shelby-protocol/sdk 0.0.1-experimental.0

package/dist/node/clients/ShelbyBlobClient.d.ts

@@ -0,0 +1,215 @@
+import { AptosConfig, AccountAddress, InputGenerateTransactionOptions, Aptos, AccountAddressInput, Account, PendingTransactionResponse, InputGenerateTransactionPayloadData } from '@aptos-labs/ts-sdk';
+import { BlobCommitments } from '../../core/commitments.js';
+import { BlobName } from '../../core/layout.js';
+import { BlobMetadata, BlobChunk, SignedChunkCommitment } from '../../core/types/blobs.js';
+import { EncodingOptions } from '../../core/types/encodings.js';
+import 'zod';
+
+interface ShelbyBlobClientConfig {
+    aptos: {
+        config: AptosConfig;
+    };
+    shelbyDeployer?: AccountAddress;
+}
+interface WriteBlobCommitmentsOptions {
+    build?: {
+        options?: InputGenerateTransactionOptions;
+    };
+    encoding?: EncodingOptions;
+}
+interface ConfirmBlobChunksOptions {
+    build?: {
+        options?: InputGenerateTransactionOptions;
+    };
+    encoding?: EncodingOptions;
+}
+declare class ShelbyBlobClient {
+    readonly aptos: Aptos;
+    readonly deployer: AccountAddress;
+    /**
+     * 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: ShelbyBlobClientConfig);
+    /**
+     * 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",
+     * });
+     * ```
+     */
+    getBlobMetadata(params: {
+        account: AccountAddressInput;
+        name: BlobName;
+    }): Promise<BlobMetadata | undefined>;
+    /**
+     * 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"),
+     * });
+     * ```
+     */
+    getAccountBlobs(params: {
+        account: AccountAddressInput;
+    }): Promise<BlobMetadata[]>;
+    /**
+     * 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");
+     * ```
+     */
+    getBlobChunks(params: {
+        account: AccountAddressInput;
+        name: BlobName;
+    }): Promise<BlobChunk[]>;
+    /**
+     * 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(Readable.from(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
+     * });
+     * ```
+     */
+    writeBlobCommitments(params: ({
+        blobCommitments: BlobCommitments;
+    } | {
+        blobData: Buffer;
+    }) & {
+        signer: Account;
+        blobName: BlobName;
+        expirationMicros: number;
+        options?: WriteBlobCommitmentsOptions;
+    }): Promise<{
+        blobCommitments: BlobCommitments;
+        transaction: PendingTransactionResponse;
+    }>;
+    /**
+     * 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,
+     * });
+     * ```
+     */
+    confirmBlobChunks(params: {
+        signer: Account;
+        account: AccountAddressInput;
+        blobName: BlobName;
+        signedChunksetChunkCommitments: SignedChunkCommitment[][];
+        options?: ConfirmBlobChunksOptions;
+    }): Promise<{
+        transaction: PendingTransactionResponse;
+    }>;
+    /**
+     * 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: {
+        deployer?: AccountAddress;
+        account: AccountAddress;
+        blobName: BlobName;
+        blobMerkleRoot: string;
+        chunksetChunkCommitments: string[][];
+        expirationMicros: number;
+        size: number;
+    }): InputGenerateTransactionPayloadData;
+    /**
+     * 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: {
+        deployer?: AccountAddress;
+        account: AccountAddressInput;
+        blobName: BlobName;
+        signedChunksetChunkCommitments: SignedChunkCommitment[][];
+    }): InputGenerateTransactionPayloadData;
+}
+
+export { type ConfirmBlobChunksOptions, ShelbyBlobClient, type ShelbyBlobClientConfig, type WriteBlobCommitmentsOptions };

package/dist/node/clients/ShelbyBlobClient.mjs

@@ -0,0 +1,19 @@
+import {
+  ShelbyBlobClient
+} from "../../chunk-EFE5Y7IE.mjs";
+import "../../chunk-VLLCOFH7.mjs";
+import "../../chunk-OWIIKLFI.mjs";
+import "../../chunk-E3QOKRQ4.mjs";
+import "../../chunk-PZPMURE4.mjs";
+import "../../chunk-MWDW4ROU.mjs";
+import "../../chunk-ZHXCVRZX.mjs";
+import "../../chunk-IHTPXUYI.mjs";
+import "../../chunk-YV67F5NY.mjs";
+import "../../chunk-QEMIORTL.mjs";
+import "../../chunk-NPM7WXK3.mjs";
+import "../../chunk-GGYTHP5F.mjs";
+import "../../chunk-D2FERD4A.mjs";
+import "../../chunk-7P6ASYW6.mjs";
+export {
+  ShelbyBlobClient
+};

package/dist/node/clients/ShelbyNodeClient.d.ts

@@ -0,0 +1,95 @@
+import { ShelbyBlobClient, WriteBlobCommitmentsOptions } from './ShelbyBlobClient.js';
+import { ShelbyRPCClient } from './ShelbyRPCClient.js';
+import * as _aptos_labs_ts_sdk from '@aptos-labs/ts-sdk';
+import { Account, AccountAddressInput } from '@aptos-labs/ts-sdk';
+import { BlobName } from '../../core/layout.js';
+import { ShelbyBlob } from '../../core/blobs.js';
+import { ShelbyClient, ShelbyClientConfig } from '../../core/ShelbyClient.js';
+import '../../core/commitments.js';
+import 'zod';
+import '../../core/types/blobs.js';
+import '../../core/types/encodings.js';
+import 'node:stream';
+
+declare class ShelbyNodeClient extends ShelbyClient {
+    /**
+     * The coordination client is used to interact with the Aptos blockchain which handles the commitments
+     * and metadata for blobs.
+     */
+    readonly coordination: ShelbyBlobClient;
+    /**
+     * The RPC client is used to interact with the Shelby RPC node which can be responsible for storing,
+     * confirming, and retrieving blobs from the storage layer.
+     */
+    readonly rpc: ShelbyRPCClient;
+    /**
+     * The ShelbyNodeClient is used to interact with the Shelby network.
+     *
+     * @param config.aptos.config - The Aptos config.
+     * @param config.shelby.baseUrl - The base URL of the Shelby RPC node. If not provided, the default base URL will be used.
+     * @param config.shelby.deployer - 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.DEVNET }));
+     * const client = new ShelbyNodeClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
+     * ```
+     */
+    constructor(config: ShelbyClientConfig);
+    /**
+     * Uploads a blob to the Shelby network.
+     *
+     * @param params.blobData - The data to upload.
+     * @param params.signer - The signer of the transaction.
+     * @param params.blobName - The name of the blob.
+     * @param params.expirationMicros - The expiration time of the blob in microseconds.
+     * @param params.options - The options for the upload.
+     *
+     * @returns The transaction and generated blob commitments.
+     */
+    upload(params: {
+        blobData: Buffer;
+        signer: Account;
+        blobName: BlobName;
+        expirationMicros: number;
+        options?: WriteBlobCommitmentsOptions;
+    }): Promise<{
+        transaction: _aptos_labs_ts_sdk.CommittedTransactionResponse;
+        blobCommitments: {
+            schema_version: string;
+            raw_data_size: number;
+            blob_merkle_root: string;
+            chunkset_commitments: {
+                chunkset_root: string | null;
+                chunk_commitments: string[];
+            }[];
+        };
+    }>;
+    /**
+     * Downloads a blob from the Shelby RPC node.
+     *
+     * @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.range - The range of the blob to download.
+     *
+     * @returns A `ShelbyBlob` object containing the blob data.
+     *
+     * @example
+     * ```typescript
+     * const blob = await client.download({
+     *   account,
+     *   blobName: "foo/bar.txt",
+     * });
+     * ```
+     */
+    download(params: {
+        account: AccountAddressInput;
+        blobName: string;
+        range?: {
+            start: number;
+            end?: number;
+        };
+    }): Promise<ShelbyBlob>;
+}
+
+export { ShelbyNodeClient };

package/dist/node/clients/ShelbyNodeClient.mjs

@@ -0,0 +1,22 @@
+import {
+  ShelbyNodeClient
+} from "../../chunk-XZMYTH4K.mjs";
+import "../../chunk-EFE5Y7IE.mjs";
+import "../../chunk-DBTBUKCW.mjs";
+import "../../chunk-VLLCOFH7.mjs";
+import "../../chunk-OWIIKLFI.mjs";
+import "../../chunk-E3QOKRQ4.mjs";
+import "../../chunk-PZPMURE4.mjs";
+import "../../chunk-MWDW4ROU.mjs";
+import "../../chunk-ZHXCVRZX.mjs";
+import "../../chunk-IHTPXUYI.mjs";
+import "../../chunk-YV67F5NY.mjs";
+import "../../chunk-QEMIORTL.mjs";
+import "../../chunk-NPM7WXK3.mjs";
+import "../../chunk-GGYTHP5F.mjs";
+import "../../chunk-D2FERD4A.mjs";
+import "../../chunk-I6NG5GNL.mjs";
+import "../../chunk-7P6ASYW6.mjs";
+export {
+  ShelbyNodeClient
+};

package/dist/node/clients/ShelbyRPCClient.d.ts

@@ -0,0 +1,72 @@
+import { AccountAddressInput } from '@aptos-labs/ts-sdk';
+import { BlobName } from '../../core/layout.js';
+import { ShelbyBlob } from '../../core/blobs.js';
+import { ShelbyClient, ShelbyClientConfig } from '../../core/ShelbyClient.js';
+import 'zod';
+import 'node:stream';
+
+declare class ShelbyRPCClient extends ShelbyClient {
+    #private;
+    /**
+     * The ShelbyRPCClient is used to interact with the Shelby RPC node. This
+     * includes functions like uploading blobs after they have been committed to the
+     * blockchain and downloading blobs.
+     *
+     * @param config.aptos.config - The Aptos config.
+     * @param config.shelby.baseUrl - The base URL of the Shelby RPC node.
+     *
+     * @example
+     * ```typescript
+     * const aptos = new Aptos(new AptosConfig({ network: Network.DEVNET }));
+     * const client = new ShelbyRPCClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
+     * ```
+     */
+    constructor(config: ShelbyClientConfig);
+    /**
+     * Uploads blob data to the Shelby RPC node to be stored and confirmed by storage providers. This should be performed after the blob
+     * commitments have been written to the blockchain.
+     *
+     * @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.blobData - The data to upload.
+     *
+     * @example
+     * ```typescript
+     * const blobData = Buffer.from("Hello, world!");
+     *
+     * await client.putBlob({ account, blobName: "foo/bar.txt", blobData });
+     * ```
+     */
+    putBlob(params: {
+        account: AccountAddressInput;
+        blobName: BlobName;
+        blobData: Buffer;
+    }): Promise<void>;
+    /**
+     * Downloads a blob from the Shelby RPC node.
+     *
+     * @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.range - The range of the blob to download.
+     *
+     * @returns A `ShelbyBlob` object containing the blob data.
+     *
+     * @example
+     * ```typescript
+     * const blob = await client.getBlob({
+     *   account,
+     *   blobName: "foo/bar.txt",
+     * });
+     * ```
+     */
+    getBlob(params: {
+        account: AccountAddressInput;
+        blobName: string;
+        range?: {
+            start: number;
+            end?: number;
+        };
+    }): Promise<ShelbyBlob>;
+}
+
+export { ShelbyRPCClient };

package/dist/node/clients/ShelbyRPCClient.mjs

@@ -0,0 +1,17 @@
+import {
+  ShelbyRPCClient
+} from "../../chunk-DBTBUKCW.mjs";
+import "../../chunk-PZPMURE4.mjs";
+import "../../chunk-MWDW4ROU.mjs";
+import "../../chunk-ZHXCVRZX.mjs";
+import "../../chunk-IHTPXUYI.mjs";
+import "../../chunk-YV67F5NY.mjs";
+import "../../chunk-QEMIORTL.mjs";
+import "../../chunk-NPM7WXK3.mjs";
+import "../../chunk-GGYTHP5F.mjs";
+import "../../chunk-D2FERD4A.mjs";
+import "../../chunk-I6NG5GNL.mjs";
+import "../../chunk-7P6ASYW6.mjs";
+export {
+  ShelbyRPCClient
+};

package/dist/node/clients/index.d.ts

@@ -0,0 +1,12 @@
+export { ConfirmBlobChunksOptions, ShelbyBlobClient, ShelbyBlobClientConfig, WriteBlobCommitmentsOptions } from './ShelbyBlobClient.js';
+export { ShelbyRPCClient } from './ShelbyRPCClient.js';
+export { ShelbyNodeClient } from './ShelbyNodeClient.js';
+import '@aptos-labs/ts-sdk';
+import '../../core/commitments.js';
+import 'zod';
+import '../../core/layout.js';
+import '../../core/types/blobs.js';
+import '../../core/types/encodings.js';
+import '../../core/blobs.js';
+import 'node:stream';
+import '../../core/ShelbyClient.js';

package/dist/node/clients/index.mjs

@@ -0,0 +1,29 @@
+import "../../chunk-WVWL2OPB.mjs";
+import {
+  ShelbyNodeClient
+} from "../../chunk-XZMYTH4K.mjs";
+import {
+  ShelbyBlobClient
+} from "../../chunk-EFE5Y7IE.mjs";
+import {
+  ShelbyRPCClient
+} from "../../chunk-DBTBUKCW.mjs";
+import "../../chunk-VLLCOFH7.mjs";
+import "../../chunk-OWIIKLFI.mjs";
+import "../../chunk-E3QOKRQ4.mjs";
+import "../../chunk-PZPMURE4.mjs";
+import "../../chunk-MWDW4ROU.mjs";
+import "../../chunk-ZHXCVRZX.mjs";
+import "../../chunk-IHTPXUYI.mjs";
+import "../../chunk-YV67F5NY.mjs";
+import "../../chunk-QEMIORTL.mjs";
+import "../../chunk-NPM7WXK3.mjs";
+import "../../chunk-GGYTHP5F.mjs";
+import "../../chunk-D2FERD4A.mjs";
+import "../../chunk-I6NG5GNL.mjs";
+import "../../chunk-7P6ASYW6.mjs";
+export {
+  ShelbyBlobClient,
+  ShelbyNodeClient,
+  ShelbyRPCClient
+};

package/dist/node/commitments.d.ts

@@ -0,0 +1,35 @@
+import { Readable } from 'node:stream';
+import { BlobCommitments } from '../core/commitments.js';
+import { EncodingOptions } from '../core/types/encodings.js';
+import 'zod';
+
+/**
+ * When full dataset is available (as a stream), stream over it, producing
+ * chunks of data as we go, and the full BlobCommitment once we've consumed the
+ * entire data.
+ *
+ * FIXME optimization needed around partial commitments, need to return them
+ * from the cb so the outer layers can check against what they already have?
+ *
+ * Callback is also a werid interface into this; I'm not entirely happy with it,
+ * but I want this logic to be centralized into a single helper then the rest of
+ * the code can be completely agnostic to coding scheme and layout of a chunkset.
+ */
+/**
+ * Generates the blob commitments for a given data stream.
+ *
+ * @param fullData - The data stream to generate commitments for.
+ * @param onChunk - A callback that is called for each chunk of data.
+ * @param options - The encoding options to use.
+ *
+ * @returns The blob commitments.
+ *
+ * @example
+ * ```typescript
+ * const buffer = Buffer.from("Hello, world!");
+ * const commitments = await generateCommitments(Readable.from(buffer));
+ * ```
+ */
+declare function generateCommitments(fullData: Readable, onChunk?: (chunksetIdx: number, chunkIdx: number, chunkData: Buffer) => Promise<void> | void, options?: EncodingOptions): Promise<BlobCommitments>;
+
+export { generateCommitments };

package/dist/node/commitments.mjs

@@ -0,0 +1,18 @@
+import {
+  generateCommitments
+} from "../chunk-VLLCOFH7.mjs";
+import "../chunk-OWIIKLFI.mjs";
+import "../chunk-E3QOKRQ4.mjs";
+import "../chunk-PZPMURE4.mjs";
+import "../chunk-MWDW4ROU.mjs";
+import "../chunk-ZHXCVRZX.mjs";
+import "../chunk-IHTPXUYI.mjs";
+import "../chunk-YV67F5NY.mjs";
+import "../chunk-QEMIORTL.mjs";
+import "../chunk-NPM7WXK3.mjs";
+import "../chunk-GGYTHP5F.mjs";
+import "../chunk-D2FERD4A.mjs";
+import "../chunk-7P6ASYW6.mjs";
+export {
+  generateCommitments
+};

package/dist/node/erasure.d.ts

@@ -0,0 +1,12 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * Split `data` into `k` data shards + `m` parity shards (Reed-Solomon).
+ *
+ * Note: This calls `@ronomon/reed-solomon` which has a node-gyp C to Node binding
+ * for reed-solomon implementation. It requires Node bindings for Buffer
+ * and unfortunately we cannot use Uint8Array here.
+ */
+declare function erasureEncode(data: Buffer, k: number, m: number): Promise<Buffer[]>;
+
+export { erasureEncode };

package/dist/node/erasure.mjs

@@ -0,0 +1,7 @@
+import {
+  erasureEncode
+} from "../chunk-OWIIKLFI.mjs";
+import "../chunk-7P6ASYW6.mjs";
+export {
+  erasureEncode
+};

package/dist/node/index.d.ts

@@ -0,0 +1,18 @@
+export { BlobCommitments, BlobCommitmentsSchema, ChunksetCommitment, ChunksetCommitmentSchema } from '../core/commitments.js';
+export { BlobName, BlobNameSchema, ChunkKey, allChunksForBlob, roundSize } from '../core/layout.js';
+export { 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 '../core/constants.js';
+export { BlobChunk, BlobEncoding, BlobMetadata, ChunkLocation, ClayEncoding, PendingChunkLocation, SignedChunkCommitment, StoredChunkLocation } from '../core/types/blobs.js';
+export { EncodingOptions } from '../core/types/encodings.js';
+export { ShelbyBlob, createBlobKey } from '../core/blobs.js';
+export { ShelbyClient, ShelbyClientConfig } from '../core/ShelbyClient.js';
+export { ConfirmBlobChunksOptions, ShelbyBlobClient, ShelbyBlobClientConfig, WriteBlobCommitmentsOptions } from './clients/ShelbyBlobClient.js';
+export { ShelbyRPCClient } from './clients/ShelbyRPCClient.js';
+export { ShelbyNodeClient } from './clients/ShelbyNodeClient.js';
+export { erasureEncode } from './erasure.js';
+export { generateCommitments } from './commitments.js';
+export { t as testUtil } from '../testUtil-BnxAchIN.js';
+export { r as readableUtil } from '../readableUtil-BW_7enT-.js';
+import 'zod';
+import '@aptos-labs/ts-sdk';
+import 'node:stream';
+import 'node:buffer';

package/dist/node/index.mjs

@@ -0,0 +1,85 @@
+import "../chunk-WVWL2OPB.mjs";
+import {
+  ShelbyNodeClient
+} from "../chunk-XZMYTH4K.mjs";
+import {
+  ShelbyBlobClient
+} from "../chunk-EFE5Y7IE.mjs";
+import {
+  ShelbyRPCClient
+} from "../chunk-DBTBUKCW.mjs";
+import {
+  generateCommitments
+} from "../chunk-VLLCOFH7.mjs";
+import {
+  erasureEncode
+} from "../chunk-OWIIKLFI.mjs";
+import {
+  readableUtil_exports
+} from "../chunk-E3QOKRQ4.mjs";
+import {
+  testUtil_exports
+} from "../chunk-A4IG6GSE.mjs";
+import "../chunk-PZPMURE4.mjs";
+import "../chunk-MWDW4ROU.mjs";
+import "../chunk-ZHXCVRZX.mjs";
+import "../chunk-IHTPXUYI.mjs";
+import {
+  ShelbyClient
+} from "../chunk-YV67F5NY.mjs";
+import {
+  createBlobKey
+} from "../chunk-QEMIORTL.mjs";
+import {
+  BlobCommitmentsSchema,
+  ChunksetCommitmentSchema
+} from "../chunk-NPM7WXK3.mjs";
+import {
+  BlobNameSchema,
+  ChunkKey,
+  allChunksForBlob,
+  roundSize
+} from "../chunk-GGYTHP5F.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";
+import "../chunk-7P6ASYW6.mjs";
+export {
+  BlobCommitmentsSchema,
+  BlobNameSchema,
+  CHUNKSET_SIZE_BYTES,
+  ChunkKey,
+  ChunksetCommitmentSchema,
+  DEFAULT_PROJECT_DESCRIPTION,
+  DEFAULT_PROJECT_NAME,
+  DEFAULT_SHELBY_BASE_URL,
+  ERASURE_K,
+  ERASURE_M,
+  SHELBY_DEPLOYER,
+  ShelbyBlobClient,
+  ShelbyClient,
+  ShelbyNodeClient,
+  ShelbyRPCClient,
+  TOKEN_DEPLOYER,
+  TOKEN_OBJECT_ADDRESS,
+  allChunksForBlob,
+  createBlobKey,
+  erasureEncode,
+  generateCommitments,
+  getChunkSizeBytes,
+  getChunksetSizeBytes,
+  readableUtil_exports as readableUtil,
+  roundSize,
+  testUtil_exports as testUtil
+};

package/dist/node/readableUtil.d.ts

@@ -0,0 +1,2 @@
+import 'node:stream';
+export { a as readInChunks, z as zeroPadBuffer } from '../readableUtil-BW_7enT-.js';