@shelby-protocol/sdk 0.0.1-experimental.0

package/dist/chunk-EFE5Y7IE.mjs

@@ -0,0 +1,331 @@
+import {
+  generateCommitments
+} from "./chunk-VLLCOFH7.mjs";
+import {
+  createBlobKey
+} from "./chunk-QEMIORTL.mjs";
+import {
+  SHELBY_DEPLOYER
+} from "./chunk-D2FERD4A.mjs";
+
+// src/node/clients/ShelbyBlobClient.ts
+import { Readable } from "stream";
+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.shelbyDeployer ?? 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(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
+   * });
+   * ```
+   */
+  async writeBlobCommitments(params) {
+    let blobCommitments;
+    if ("blobCommitments" in params) {
+      blobCommitments = params.blobCommitments;
+    } else {
+      blobCommitments = await generateCommitments(
+        Readable.from(params.blobData),
+        void 0,
+        params.options?.encoding
+      );
+    }
+    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-GGYTHP5F.mjs

@@ -0,0 +1,84 @@
+import {
+  ERASURE_K,
+  ERASURE_M,
+  getChunkSizeBytes,
+  getChunksetSizeBytes
+} from "./chunk-D2FERD4A.mjs";
+
+// src/core/layout.ts
+import { AccountAddress } from "@aptos-labs/ts-sdk";
+import { z } from "zod";
+var BlobNameSchema = z.string().min(1, "Blob name path parameter cannot be empty.").max(1024, "Blob name cannot exceed 1024 characters.").refine((name) => !name.endsWith("/"), {
+  message: "Blob name cannot end with a slash"
+});
+var ChunkKey = class _ChunkKey {
+  constructor(account, blobName, chunksetIdx, chunkIdx) {
+    this.account = account;
+    this.blobName = blobName;
+    this.chunksetIdx = chunksetIdx;
+    this.chunkIdx = chunkIdx;
+    const N = ERASURE_K + ERASURE_M;
+    if (chunkIdx >= N) {
+      throw new Error(`Cannot create a chunk with idx ${chunkIdx}. M+K=${N}`);
+    }
+  }
+  key() {
+    return `${this.account.toString()}.${this.blobName}.${this.chunksetIdx}.${this.chunkIdx}`;
+  }
+  // Returns the range in the blob that this key represents, or "partity" if this is parity chunk.
+  range() {
+    if (this.chunkIdx >= ERASURE_K) {
+      return "parity";
+    }
+    const chunksetStart = this.chunksetIdx * getChunksetSizeBytes();
+    const chunkStart = chunksetStart + this.chunkIdx * getChunkSizeBytes();
+    return {
+      start: chunkStart,
+      end: chunkStart + getChunkSizeBytes()
+    };
+  }
+  static fromJSON(json) {
+    return new _ChunkKey(
+      AccountAddress.fromString(json.account),
+      json.blobName,
+      json.chunksetIdx,
+      json.chunkIdx
+    );
+  }
+  toJSON() {
+    return {
+      account: this.account.toString(),
+      blobName: this.blobName,
+      chunksetIdx: this.chunksetIdx,
+      chunkIdx: this.chunkIdx
+    };
+  }
+};
+function roundSize(size) {
+  let ret = 0;
+  let remain = size;
+  while (remain > 0) {
+    ret += getChunksetSizeBytes();
+    remain -= getChunksetSizeBytes();
+  }
+  return ret;
+}
+function allChunksForBlob(account, blobName, _size) {
+  const ret = [];
+  const size = roundSize(_size);
+  const nChunksets = size / getChunksetSizeBytes();
+  for (let chunksetIdx = 0; chunksetIdx < nChunksets; ++chunksetIdx) {
+    const n = ERASURE_K + ERASURE_M;
+    for (let chunkIdx = 0; chunkIdx < n; ++chunkIdx) {
+      ret.push(new ChunkKey(account, blobName, chunksetIdx, chunkIdx));
+    }
+  }
+  return ret;
+}
+
+export {
+  BlobNameSchema,
+  ChunkKey,
+  roundSize,
+  allChunksForBlob
+};

package/dist/chunk-I6NG5GNL.mjs

@@ -0,0 +1,8 @@
+// src/core/promises.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  sleep
+};

package/dist/chunk-NPM7WXK3.mjs

@@ -0,0 +1,49 @@
+import {
+  roundSize
+} from "./chunk-GGYTHP5F.mjs";
+import {
+  ERASURE_K,
+  ERASURE_M,
+  getChunksetSizeBytes
+} from "./chunk-D2FERD4A.mjs";
+
+// src/core/commitments.ts
+import { z } from "zod";
+var ChunksetCommitmentSchema = z.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z.string().nullable(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z.array(z.string())
+}).refine(
+  (data) => {
+    return data.chunk_commitments.length === ERASURE_K + ERASURE_M;
+  },
+  {
+    message: `Chunkset must have exactly ${ERASURE_K + ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${ERASURE_K} + ${ERASURE_M})`,
+    path: ["chunk_commitments"]
+  }
+);
+function expectedTotalChunksets(rawSize) {
+  return roundSize(rawSize) / getChunksetSizeBytes();
+}
+var BlobCommitmentsSchema = z.object({
+  schema_version: z.string(),
+  raw_data_size: z.number(),
+  // FIXME I am not sure about this being here, or if it should be somewhere else
+  blob_merkle_root: z.string(),
+  chunkset_commitments: z.array(ChunksetCommitmentSchema)
+}).refine(
+  (data) => {
+    return expectedTotalChunksets(data.raw_data_size) === data.chunkset_commitments.length;
+  },
+  {
+    message: "Total chunkset count mismatches with raw data size",
+    // FIXME put more details in here
+    path: ["chunkset_commitments"]
+  }
+);
+
+export {
+  ChunksetCommitmentSchema,
+  BlobCommitmentsSchema
+};

package/dist/chunk-OWIIKLFI.mjs

@@ -0,0 +1,43 @@
+// src/node/erasure.ts
+import { Buffer } from "buffer";
+import { RS } from "@shelby-protocol/reed-solomon";
+async function erasureEncode(data, k, m) {
+  const rawShardSize = Math.ceil(data.length / k);
+  const shardSize = Math.ceil(rawShardSize / 8) * 8;
+  const dataSize = shardSize * k;
+  const paritySize = shardSize * m;
+  const dataBuf = Buffer.alloc(dataSize);
+  data.copy(dataBuf, 0);
+  const parityBuf = Buffer.alloc(paritySize);
+  let sources = 0;
+  for (let i = 0; i < k; i++) sources |= 1 << i;
+  let targets = 0;
+  for (let i = k; i < k + m; i++) targets |= 1 << i;
+  const context = RS.create(k, m);
+  await new Promise((resolve, reject) => {
+    RS.encode(
+      context,
+      sources,
+      targets,
+      dataBuf,
+      0,
+      dataSize,
+      parityBuf,
+      0,
+      paritySize,
+      (err) => err ? reject(err) : resolve()
+    );
+  });
+  const shards = [];
+  for (let i = 0; i < k; i++) {
+    shards.push(dataBuf.slice(i * shardSize, i * shardSize + shardSize));
+  }
+  for (let j = 0; j < m; j++) {
+    shards.push(parityBuf.slice(j * shardSize, j * shardSize + shardSize));
+  }
+  return shards;
+}
+
+export {
+  erasureEncode
+};

package/dist/chunk-QEMIORTL.mjs

@@ -0,0 +1,9 @@
+// src/core/blobs.ts
+import { AccountAddress } from "@aptos-labs/ts-sdk";
+var createBlobKey = (params) => {
+  return `${AccountAddress.from(params.account).toString()}.${params.blobName}`;
+};
+
+export {
+  createBlobKey
+};

package/dist/chunk-VLLCOFH7.mjs

@@ -0,0 +1,73 @@
+import {
+  erasureEncode
+} from "./chunk-OWIIKLFI.mjs";
+import {
+  readInChunks,
+  zeroPadBuffer
+} from "./chunk-E3QOKRQ4.mjs";
+import {
+  ERASURE_K,
+  ERASURE_M,
+  getChunksetSizeBytes
+} from "./chunk-D2FERD4A.mjs";
+
+// src/node/commitments.ts
+import { createHash } from "crypto";
+import { Hex } from "@aptos-labs/ts-sdk";
+function concatHashes(parts) {
+  const combined = Buffer.concat(
+    parts.map((part) => Hex.fromHexInput(part).toUint8Array())
+  );
+  return Hex.fromHexInput(createHash("sha256").update(combined).digest());
+}
+async function generateCommitments(fullData, onChunk, options) {
+  const chunksetCommitments = [];
+  const chunksetCommitmentHashes = [];
+  let rawDataSize = 0;
+  const chunksetGen = readInChunks(
+    fullData,
+    options?.chunksetSize ?? getChunksetSizeBytes()
+  );
+  for await (let [chunksetIdx, chunksetData] of chunksetGen) {
+    const chunkCommitments = [];
+    rawDataSize += chunksetData.length;
+    chunksetData = zeroPadBuffer(
+      chunksetData,
+      options?.chunksetSize ?? getChunksetSizeBytes()
+    );
+    const chunks = await erasureEncode(
+      chunksetData,
+      options?.erasureK ?? ERASURE_K,
+      options?.erasureM ?? ERASURE_M
+    );
+    let chunkIdx = 0;
+    for (const chunkData of chunks) {
+      if (onChunk !== void 0) {
+        await onChunk(chunksetIdx, chunkIdx, chunkData);
+      }
+      const chunkHash = concatHashes([chunkData]);
+      chunkCommitments.push(chunkHash);
+      chunkIdx += 1;
+    }
+    const h = concatHashes(
+      chunkCommitments.map((chunk) => chunk.toUint8Array())
+    );
+    chunksetCommitments.push({
+      chunkset_root: h.toString(),
+      chunk_commitments: chunkCommitments.map((chunk) => chunk.toString())
+    });
+    chunksetCommitmentHashes.push(h);
+  }
+  return {
+    schema_version: "1.3",
+    raw_data_size: rawDataSize,
+    blob_merkle_root: concatHashes(
+      chunksetCommitmentHashes.map((chunk) => chunk.toUint8Array())
+    ).toString(),
+    chunkset_commitments: chunksetCommitments
+  };
+}
+
+export {
+  generateCommitments
+};

package/dist/chunk-XZMYTH4K.mjs

@@ -0,0 +1,90 @@
+import {
+  ShelbyBlobClient
+} from "./chunk-EFE5Y7IE.mjs";
+import {
+  ShelbyRPCClient
+} from "./chunk-DBTBUKCW.mjs";
+import {
+  ShelbyClient
+} from "./chunk-YV67F5NY.mjs";
+
+// src/node/clients/ShelbyNodeClient.ts
+var ShelbyNodeClient = class extends ShelbyClient {
+  /**
+   * The coordination client is used to interact with the Aptos blockchain which handles the commitments
+   * and metadata for blobs.
+   */
+  coordination;
+  /**
+   * 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.
+   */
+  rpc;
+  /**
+   * 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) {
+    super(config);
+    this.coordination = new ShelbyBlobClient({
+      aptos: this.aptos,
+      shelbyDeployer: config.shelby?.deployer
+    });
+    this.rpc = new ShelbyRPCClient({ aptos: this.aptos });
+  }
+  /**
+   * 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.
+   */
+  async upload(params) {
+    const { transaction, blobCommitments } = await this.coordination.writeBlobCommitments(params);
+    const confirmedTransaction = await this.aptos.waitForTransaction({
+      transactionHash: transaction.hash
+    });
+    await this.rpc.putBlob({
+      ...params,
+      account: params.signer.accountAddress
+    });
+    return { transaction: confirmedTransaction, blobCommitments };
+  }
+  /**
+   * 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",
+   * });
+   * ```
+   */
+  async download(params) {
+    return await this.rpc.getBlob(params);
+  }
+};
+
+export {
+  ShelbyNodeClient
+};