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

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

@@ -1,37 +1,43 @@
 import { Aptos, AccountAddress, AccountAddressInput, Account, InputGenerateTransactionOptions, PendingTransactionResponse, InputGenerateTransactionPayloadData } from '@aptos-labs/ts-sdk';
-import { BlobCommitments } from '../commitments.js';
 import { BlobName } from '../layout.js';
-import { BlobMetadata, BlobChunk, SignedChunkCommitment } from '../types/blobs.js';
-import { EncodingOptions } from '../types/encodings.js';
+import { BlobMetadata, BlobActivity } from '../types/blobs.js';
+import { ShelbyIndexerClient } from '../operations/index.js';
+import { Blobs_Order_By, Blobs_Bool_Exp, Blob_Activities_Bool_Exp, Blob_Activities_Order_By } from '../operations/generated/sdk.js';
 import { ShelbyClientConfig } from './ShelbyClientConfig.js';
 import 'zod';
+import '../../clay-codes-Ce9EmXfa.js';
+import '@shelby-protocol/clay-codes';
+import 'graphql-request';
+import 'graphql';
+import '../networks.js';
 
 interface WriteBlobCommitmentsOptions {
     build?: {
         options?: InputGenerateTransactionOptions;
     };
-    encoding?: EncodingOptions;
-}
-interface ConfirmBlobChunksOptions {
-    build?: {
-        options?: InputGenerateTransactionOptions;
-    };
-    encoding?: EncodingOptions;
+    chunksetSizeBytes?: number;
 }
 declare class ShelbyBlobClient {
     readonly aptos: Aptos;
     readonly deployer: AccountAddress;
+    readonly indexer: ShelbyIndexerClient;
     /**
      * 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.
+     * includes functions for registering blob commitments 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.
+     * @param config - The client configuration object.
+     * @param config.network - The Shelby network to use.
      *
      * @example
      * ```typescript
-     * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
-     * const blobClient = new ShelbyBlobClient({ aptos });
+     * const blobClient = new ShelbyBlobClient({
+     *   aptos: {
+     *     network: Network.SHELBYNET,
+     *     clientConfig: {
+     *       API_KEY: "AG-***",
+     *     },
+     *   },
+     * });
      * ```
      */
     constructor(config: ShelbyClientConfig);
@@ -60,6 +66,8 @@ declare class ShelbyBlobClient {
      * blockchain.
      *
      * @param params.account - The account namespace the blobs are stored in (e.g. "0x1")
+     * @param params.pagination (optional) - The pagination options.
+     * @param params.orderBy (optional) - The order by clause to sort the blobs by.
      * @returns The blob metadata for all the blobs for the account.
      *
      * @example
@@ -72,11 +80,50 @@ declare class ShelbyBlobClient {
      */
     getAccountBlobs(params: {
         account: AccountAddressInput;
+        pagination?: {
+            limit?: number;
+            offset?: number;
+        };
+        orderBy?: Blobs_Order_By;
+    }): Promise<BlobMetadata[]>;
+    /**
+     * Retrieves blobs and their metadata from the blockchain.
+     *
+     * @param params.where (optional) - The where clause to filter the blobs by.
+     * @param params.pagination (optional) - The pagination options.
+     * @param params.orderBy (optional) - The order by clause to sort the blobs by.
+     * @returns The blob metadata for all the blobs that match the where clause.
+     *
+     * @example
+     * ```typescript
+     * // BlobMetadata[]
+     * const blobs = await client.getBlobs({
+     *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
+     * });
+     * ```
+     */
+    getBlobs(params?: {
+        where?: Blobs_Bool_Exp;
+        pagination?: {
+            limit?: number;
+            offset?: number;
+        };
+        orderBy?: Blobs_Order_By;
     }): Promise<BlobMetadata[]>;
+    getBlobActivities(params: {
+        where?: Blob_Activities_Bool_Exp;
+        pagination?: {
+            limit?: number;
+            offset?: number;
+        };
+        orderBy?: Blob_Activities_Order_By;
+    }): Promise<BlobActivity[]>;
     /**
      * 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).
      *
+     * @deprecated Will need to get reworked when we are acking blobs from storage providers.
+     *
      * @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.
@@ -92,116 +139,101 @@ declare class ShelbyBlobClient {
      * const isStored = chunks.every((c) => c.location.variant === "stored");
      * ```
      */
-    getBlobChunks(params: {
+    getBlobChunks(_params: {
         account: AccountAddressInput;
         name: BlobName;
-    }): Promise<BlobChunk[]>;
+    }): Promise<string[]>;
     /**
-     * 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.
+     * Registers a blob on the blockchain by writing its merkle root and metadata.
      *
-     * @param params.signer - The account that is signing the transaction.
-     * @param params.blobName - The name of the blob (e.g. "foo/bar")
+     * @param params.account - The account that is signing and paying for the transaction.
+     * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+     * @param params.blobMerkleRoot - The merkle root of the blob commitments.
+     * @param params.size - The size of the blob in bytes.
      * @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).
+     * @param params.options - Optional transaction building options.
+     * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
+     * @param params.options.build - Additional Aptos transaction building options.
      *
-     * @returns The blob commitments and the pending transaction.
+     * @returns An object containing the pending transaction.
      *
      * @example
      * ```typescript
-     * const blobCommitments = await generateCommitments(data);
+     * const provider = await ClayErasureCodingProvider.create();
+     * const blobCommitments = await generateCommitments(provider, data);
      *
-     * const { blobCommitments, transaction } = await client.writeBlobCommitments({
-     *   signer,
+     * const { transaction } = await client.registerBlob({
+     *   account: signer,
      *   blobName: "foo/bar.txt",
-     *   blobCommitments,
+     *   blobMerkleRoot: blobCommitments.blob_merkle_root,
+     *   size: data.length,
      *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
      * });
      * ```
      */
-    writeBlobCommitments(params: {
-        blobCommitments: BlobCommitments;
-        signer: Account;
+    registerBlob(params: {
+        account: Account;
         blobName: BlobName;
+        blobMerkleRoot: string;
+        size: number;
         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.
+     * Creates a transaction payload to register a blob on the blockchain.
+     * This is a static helper method for constructing the Move function call payload.
+     *
+     * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+     * @param params.account - The account that will own the blob.
+     * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+     * @param params.blobSize - The size of the blob in bytes.
+     * @param params.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
      * @param params.expirationMicros - The expiration time of the blob in microseconds.
-     * @param params.size - The size of the blob in bytes.
+     * @param params.numChunksets - The total number of chunksets in the blob.
+     *
+     * @returns An Aptos transaction payload data object for the register_blob Move function.
      *
-     * @see https://github.com/JumpCrypto/shelby/blob/e009607aad330ccddb08d80bf9addfaadae7972b/move/prototype/move/sources/prototype_interface.move#L211-L220
+     * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
      */
-    static createWriteBlobCommitmentsPayload(params: {
+    static createRegisterBlobPayload(params: {
         deployer?: AccountAddress;
         account: AccountAddress;
         blobName: BlobName;
+        blobSize: number;
         blobMerkleRoot: string;
-        chunksetChunkCommitments: string[][];
         expirationMicros: number;
-        size: number;
+        numChunksets: number;
     }): InputGenerateTransactionPayloadData;
     /**
-     * Creates a transaction payload to confirm the chunks of a blob.
+     * Creates a transaction payload to register multiple blobs on the blockchain.
+     * This is a static helper method for constructing the Move function call payload.
      *
-     * @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.
+     * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+     * @param params.account - The account that will own the blobs.
+     * @param params.expirationMicros - The expiration time of the blobs in microseconds.
+     * @param params.blobs - The blobs to register.
+     * @param params.blobs.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+     * @param params.blobs.blobSize - The size of the blob in bytes.
+     * @param params.blobs.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
+     * @param params.blobs.numChunksets - The total number of chunksets in the blob.
+     *
+     * @returns An Aptos transaction payload data object for the register_multiple_blobs Move function.
      *
-     * @see https://github.com/JumpCrypto/shelby/blob/e009607aad330ccddb08d80bf9addfaadae7972b/move/prototype/move/sources/prototype_interface.move#L343-L349
+     * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
      */
-    static createConfirmBlobChunksPayload(params: {
+    static createBatchRegisterBlobsPayload(params: {
         deployer?: AccountAddress;
-        account: AccountAddressInput;
-        blobName: BlobName;
-        signedChunksetChunkCommitments: SignedChunkCommitment[][];
+        account: AccountAddress;
+        expirationMicros: number;
+        blobs: {
+            blobName: BlobName;
+            blobSize: number;
+            blobMerkleRoot: string;
+            numChunksets: number;
+        }[];
     }): InputGenerateTransactionPayloadData;
 }
 
-export { type ConfirmBlobChunksOptions, ShelbyBlobClient, type WriteBlobCommitmentsOptions };
+export { ShelbyBlobClient, type WriteBlobCommitmentsOptions };

package/dist/core/clients/ShelbyBlobClient.mjs

@@ -1,8 +1,16 @@
 import {
   ShelbyBlobClient
-} from "../../chunk-B3CB2YEO.mjs";
-import "../../chunk-QEMIORTL.mjs";
-import "../../chunk-D2FERD4A.mjs";
+} from "../../chunk-XGMJ4CG4.mjs";
+import "../../chunk-75VHXY5P.mjs";
+import "../../chunk-DLMDDEWF.mjs";
+import "../../chunk-RBFWGDMY.mjs";
+import "../../chunk-OTBLZL2S.mjs";
+import "../../chunk-LTV26KU4.mjs";
+import "../../chunk-KBUWZXFA.mjs";
+import "../../chunk-HPVCKAN2.mjs";
+import "../../chunk-APML3CGJ.mjs";
+import "../../chunk-3ZDXWPYC.mjs";
+import "../../chunk-ZPW742E7.mjs";
 import "../../chunk-7P6ASYW6.mjs";
 export {
   ShelbyBlobClient

package/dist/core/clients/ShelbyClient.d.ts

@@ -1,15 +1,20 @@
-import { ShelbyBlobClient, WriteBlobCommitmentsOptions } from './ShelbyBlobClient.js';
-import * as _aptos_labs_ts_sdk from '@aptos-labs/ts-sdk';
+import { WriteBlobCommitmentsOptions, ShelbyBlobClient } from './ShelbyBlobClient.js';
 import { Aptos, Account, AccountAddressInput } from '@aptos-labs/ts-sdk';
 import { ShelbyBlob } from '../blobs.js';
+import { a as ErasureCodingProvider } from '../../clay-codes-Ce9EmXfa.js';
 import { BlobName } from '../layout.js';
 import { ShelbyClientConfig } from './ShelbyClientConfig.js';
 import { ShelbyRPCClient } from './ShelbyRPCClient.js';
-import '../commitments.js';
-import 'zod';
-import '../types/encodings.js';
 import '../types/blobs.js';
+import '@shelby-protocol/clay-codes';
+import 'zod';
+import '../operations/index.js';
+import '../operations/generated/sdk.js';
+import 'graphql';
+import 'graphql-request';
+import '../networks.js';
 
+type UploadOptions = WriteBlobCommitmentsOptions;
 declare class ShelbyClient {
     /**
      * The coordination client is used to interact with the Aptos blockchain which handles the commitments
@@ -19,6 +24,8 @@ declare class ShelbyClient {
     /**
      * 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.
+     *
+     * If not provided, the default RPC client will be created.
      */
     readonly rpc: ShelbyRPCClient;
     /**
@@ -27,48 +34,82 @@ declare class ShelbyClient {
     readonly config: ShelbyClientConfig;
     /**
      * The Aptos client.
+     *
+     * If not provided, a default Aptos client will be created.
      */
     readonly aptos: Aptos;
     /**
-     * The base class for Shelby clients
+     * The erasure coding provider used for encoding/decoding operations.
+     * Lazily initialized on first use if not provided.
+     */
+    private _provider?;
+    /**
+     * Creates a new ShelbyClient instance for interacting with the Shelby Protocol.
+     * This client combines blockchain operations (via coordination) and storage operations (via RPC).
+     *
+     * @param config - The client configuration object.
+     * @param config.aptos.config - The Aptos network configuration.
+     * @param config.shelby.rpc.baseUrl - The base URL of the Shelby RPC node (optional, defaults to devnet).
+     * @param config.shelby.indexer - The indexer configuration for GraphQL queries.
+     * @param provider - Optional erasure coding provider for encoding/decoding operations.
+     *                   If not provided, a ClayErasureCodingProvider will be created on first use.
+     *                   Pass a shared provider to reuse across multiple clients.
+     *
+     * @example
+     * ```typescript
+     * // Basic usage (provider created automatically)
+     * const client = new ShelbyClient({
+     *   network: Network.SHELBYNET,
+     * });
      *
-     * @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.
+     * // Advanced: Share provider across multiple clients
+     * const provider = await ClayErasureCodingProvider.create();
+     * const mainnetClient = new ShelbyClient(mainnetConfig, provider);
+     * const devnetClient = new ShelbyClient(devnetConfig, provider);
+     * ```
      */
-    constructor(config: ShelbyClientConfig);
+    constructor(config: ShelbyClientConfig, provider?: ErasureCodingProvider);
+    /**
+     * Get the erasure coding provider, creating it if necessary.
+     * This allows lazy initialization for users who don't provide a provider.
+     */
+    private getProvider;
     /**
      * The base URL for the Shelby RPC node.
      */
     get baseUrl(): string;
     /**
      * Uploads a blob to the Shelby network.
+     * This method handles the complete upload flow including commitment generation,
+     * blockchain registration, and storage upload.
+     *
+     * @param params.blobData - The raw data to upload as a Uint8Array.
+     * @param params.signer - The account that signs and pays for the transaction.
+     * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
+     * @param params.expirationMicros - The expiration time in microseconds since Unix epoch.
+     * @param params.options - Optional upload configuration.
+     * @param params.options.chunksetSizeBytes - Custom chunkset size.
+     * @param params.options.build - Additional Aptos transaction options.
      *
-     * @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 (when implemented).
      *
-     * @returns The transaction and generated blob commitments.
+     * @example
+     * ```typescript
+     * await client.upload({
+     *   blobData: Buffer.from("Hello, World!"),
+     *   signer: account,
+     *   blobName: "hello.txt",
+     *   expirationMicros: Date.now() * 1000 + 86400_000_000 // 24 hours from now
+     * });
+     * ```
      */
     upload(params: {
-        blobData: Buffer;
+        blobData: Uint8Array;
         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[];
-            }[];
-        };
-    }>;
+        options?: UploadOptions;
+    }): Promise<void>;
     /**
      * Downloads a blob from the Shelby RPC node.
      *
@@ -96,4 +137,4 @@ declare class ShelbyClient {
     }): Promise<ShelbyBlob>;
 }
 
-export { ShelbyClient };
+export { ShelbyClient, type UploadOptions };

package/dist/core/clients/ShelbyClient.mjs

@@ -1,15 +1,20 @@
 import {
   ShelbyClient
-} from "../../chunk-QM5BVKLD.mjs";
-import "../../chunk-B3CB2YEO.mjs";
-import "../../chunk-2FF5FICZ.mjs";
-import "../../chunk-QEMIORTL.mjs";
-import "../../chunk-G263DBCY.mjs";
-import "../../chunk-5Z3RVWU3.mjs";
-import "../../chunk-P7BVGLTV.mjs";
-import "../../chunk-GGYTHP5F.mjs";
-import "../../chunk-D2FERD4A.mjs";
+} from "../../chunk-6MDQI7PW.mjs";
+import "../../chunk-XGMJ4CG4.mjs";
+import "../../chunk-JSR44EDC.mjs";
+import "../../chunk-75VHXY5P.mjs";
+import "../../chunk-DLMDDEWF.mjs";
+import "../../chunk-RBFWGDMY.mjs";
 import "../../chunk-I6NG5GNL.mjs";
+import "../../chunk-OTBLZL2S.mjs";
+import "../../chunk-LTV26KU4.mjs";
+import "../../chunk-KBUWZXFA.mjs";
+import "../../chunk-HPVCKAN2.mjs";
+import "../../chunk-FIFKKWXV.mjs";
+import "../../chunk-APML3CGJ.mjs";
+import "../../chunk-3ZDXWPYC.mjs";
+import "../../chunk-ZPW742E7.mjs";
 import "../../chunk-7P6ASYW6.mjs";
 export {
   ShelbyClient

package/dist/core/clients/ShelbyClientConfig.d.ts

@@ -1,13 +1,47 @@
-import { AptosConfig, AccountAddress } from '@aptos-labs/ts-sdk';
+import { AptosSettings, AccountAddress } from '@aptos-labs/ts-sdk';
+import { ShelbyNetwork } from '../networks.js';
 
+/**
+ * Configuration for the Shelby RPC connection.
+ */
+type ShelbyRPCConfig = {
+    /** Base URL of the Shelby RPC node (e.g., "https://api.shelbynet.shelby.xyz/shelby"). */
+    baseUrl?: string;
+    /** API key for authenticating with the RPC node. */
+    apiKey?: string;
+};
+/**
+ * Configuration for the Shelby indexer (GraphQL) connection.
+ */
+interface ShelbyIndexerConfig {
+    /** Base URL of the indexer GraphQL endpoint. */
+    baseUrl?: string;
+    /** API key for authenticating with the indexer. */
+    apiKey?: string;
+}
+/**
+ * Complete configuration object for Shelby SDK clients.
+ *
+ * @example
+ * ```typescript
+ * const config: ShelbyClientConfig = {
+ *   network: Network.SHELBYNET
+ * };
+ * ```
+ */
 interface ShelbyClientConfig {
-    aptos: {
-        config: AptosConfig;
-    };
-    shelby?: {
-        baseUrl?: string;
-        deployer?: AccountAddress;
-    };
+    /** The Shelby network to use. */
+    network: ShelbyNetwork;
+    /** API key for authenticating with the Shelby services. */
+    apiKey?: string;
+    /** An optional Aptos blockchain configuration. If not provided, the default Aptos client will be used. */
+    aptos?: AptosSettings;
+    /** Custom deployer address for the Shelby smart contract (optional, defaults to SHELBY_DEPLOYER). */
+    deployer?: AccountAddress;
+    /** An optional RPC node configuration for blob storage operations. If not provided, the default RPC node will be used. */
+    rpc?: ShelbyRPCConfig;
+    /** An optional indexer configuration for GraphQL queries. If not provided, the default indexer will be used. */
+    indexer?: ShelbyIndexerConfig;
 }
 
-export type { ShelbyClientConfig };
+export type { ShelbyClientConfig, ShelbyIndexerConfig, ShelbyRPCConfig };

package/dist/core/clients/ShelbyClientConfig.mjs

@@ -0,0 +1 @@
+import "../../chunk-Z7RFCADT.mjs";

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

@@ -1,40 +1,54 @@
 import { AccountAddressInput } from '@aptos-labs/ts-sdk';
 import { ShelbyBlob } from '../blobs.js';
 import { BlobName } from '../layout.js';
-import { ShelbyClientConfig } from './ShelbyClientConfig.js';
+import { ShelbyIndexerClient } from '../operations/index.js';
+import { ShelbyRPCConfig, ShelbyClientConfig } from './ShelbyClientConfig.js';
 import 'zod';
+import '../operations/generated/sdk.js';
+import 'graphql';
+import 'graphql-request';
+import '../networks.js';
 
 declare class ShelbyRPCClient {
     #private;
     readonly baseUrl: string;
+    readonly apiKey: string | undefined;
+    readonly rpcConfig: ShelbyRPCConfig;
+    readonly indexer: ShelbyIndexerClient;
     /**
-     * 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.
+     * Creates a new ShelbyRPCClient for interacting with Shelby RPC nodes.
+     * This client handles blob storage operations including upload and download.
      *
-     * @param config.aptos.config - The Aptos config.
-     * @param config.shelby.baseUrl - The base URL of the Shelby RPC node.
+     * @param config - The client configuration object.
+     * @param config.network - The Shelby network to use.
      *
      * @example
      * ```typescript
-     * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
-     * const client = new ShelbyRPCClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
+     * const client = new ShelbyRPCClient({
+     *   network: Network.SHELBYNET,
+     *   apiKey: "AG-***",
+     * });
      * ```
      */
     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.
+     * Uploads blob data to the Shelby RPC node for storage by storage providers.
+     * This method should be called after blob commitments have been registered on the blockchain.
+     * Uses multipart upload for efficient handling of large files.
      *
-     * @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.
+     * @param params.account - The account that owns the blob.
+     * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
+     * @param params.blobData - The raw blob data as a Uint8Array.
      *
      * @example
      * ```typescript
      * const blobData = new TextEncoder().encode("Hello, world!");
      *
-     * await client.putBlob({ account, blobName: "foo/bar.txt", blobData });
+     * await client.putBlob({
+     *   account: AccountAddress.from("0x1"),
+     *   blobName: "greetings/hello.txt",
+     *   blobData
+     * });
      * ```
      */
     putBlob(params: {
@@ -44,18 +58,31 @@ declare class ShelbyRPCClient {
     }): Promise<void>;
     /**
      * Downloads a blob from the Shelby RPC node.
+     * Returns a streaming response with validation to ensure data integrity.
+     *
+     * @param params.account - The account that owns the blob.
+     * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
+     * @param params.range - Optional byte range for partial downloads.
+     * @param params.range.start - Starting byte position (inclusive).
+     * @param params.range.end - Ending byte position (inclusive, optional).
      *
-     * @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 account, name, readable stream, and content length.
      *
-     * @returns A `ShelbyBlob` object containing the blob data.
+     * @throws Error if the download fails or content length doesn't match.
      *
      * @example
      * ```typescript
+     * // Download entire blob
      * const blob = await client.getBlob({
-     *   account,
-     *   blobName: "foo/bar.txt",
+     *   account: AccountAddress.from("0x1"),
+     *   blobName: "documents/report.pdf"
+     * });
+     *
+     * // Download partial content (bytes 100-199)
+     * const partial = await client.getBlob({
+     *   account: AccountAddress.from("0x1"),
+     *   blobName: "large-file.bin",
+     *   range: { start: 100, end: 199 }
      * });
      * ```
      */