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

package/README.md

@@ -29,6 +29,47 @@ import { ShelbyBlob } from '@shelby-protocol/sdk/browser';
 // Your code here...
 ```
 
+### Working with Erasure Coding Providers
+
+The SDK supports two patterns for managing erasure coding providers:
+
+#### Default Pattern (Recommended for most users)
+
+```ts
+import { ShelbyClient } from '@shelby-protocol/sdk';
+
+// Provider is created internally on first use
+const client = new ShelbyClient(config);
+
+// The client will automatically create and manage the provider
+await client.upload({
+  blobData: data,
+  signer: account,
+  blobName: "example.txt",
+  expirationMicros: Date.now() * 1000 + 3600_000_000,
+});
+```
+
+#### Shared Provider Pattern (For advanced use cases)
+
+When working with multiple clients (e.g., different networks), you can share a single provider instance:
+
+```ts
+import { ShelbyClient, ClayErasureCodingProvider } from '@shelby-protocol/sdk';
+
+// Create a single provider instance
+const provider = await ClayErasureCodingProvider.create();
+
+// Share it across multiple clients
+const mainnetClient = new ShelbyClient(mainnetConfig, provider);
+const devnetClient = new ShelbyClient(devnetConfig, provider);
+const testnetClient = new ShelbyClient(testnetConfig, provider);
+
+// All clients use the same provider instance
+await mainnetClient.upload({ /* ... */ });
+await devnetClient.upload({ /* ... */ });
+```
+
 ## Peer Dependencies
 
 - `@aptos-labs/ts-sdk`

package/dist/browser/index.d.ts

@@ -1,14 +1,23 @@
 export { ShelbyBlob, createBlobKey } from '../core/blobs.js';
+export { CHUNK_SIZE_PARAMS, ChunkSizeScheme, DEFAULT_CHUNKSET_SIZE_BYTES, DEFAULT_CHUNK_SIZE_BYTES, ERASURE_CODE_AND_CHUNK_MAPPING } from '../core/chunk.js';
 export { ShelbyBlobClient } from '../core/clients/ShelbyBlobClient.js';
-export { ShelbyClient } from '../core/clients/ShelbyClient.js';
-export { ShelbyClientConfig } from '../core/clients/ShelbyClientConfig.js';
+export { ShelbyClient, UploadOptions } from '../core/clients/ShelbyClient.js';
+export { ShelbyClientConfig, ShelbyIndexerConfig, ShelbyRPCConfig } from '../core/clients/ShelbyClientConfig.js';
 export { ShelbyRPCClient } from '../core/clients/ShelbyRPCClient.js';
-export { BlobCommitments, BlobCommitmentsSchema, ChunksetCommitment, ChunksetCommitmentSchema, generateCommitments } from '../core/commitments.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 { erasureEncode } from '../core/erasure.js';
+export { BlobCommitments, BlobCommitmentsSchema, ChunksetCommitment, ChunksetCommitmentSchema, GenerateCommitmentsOptions, expectedTotalChunksets, generateCommitments } from '../core/commitments.js';
+export { 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 '../core/constants.js';
+export { C as ClayErasureCodingProvider, D as DecodeConfig, E as ErasureCodingConfig, a as ErasureCodingProvider, R as ReedSolomonErasureCodingProvider } from '../clay-codes-Ce9EmXfa.js';
+export { DEFAULT_ERASURE_D, DEFAULT_ERASURE_K, DEFAULT_ERASURE_M, DEFAULT_ERASURE_N, ERASURE_CODE_PARAMS, ErasureCodeParams, ErasureCodingScheme, ErasureSchemeParams } from '../core/erasure/constants.js';
+export { createDefaultErasureCodingProvider } from '../core/erasure/default.js';
 export { BlobName, BlobNameSchema, ChunkKey, allChunksForBlob, roundSize } from '../core/layout.js';
-export { BlobChunk, BlobEncoding, BlobMetadata, ChunkLocation, ClayEncoding, PendingChunkLocation, SignedChunkCommitment, StoredChunkLocation } from '../core/types/blobs.js';
-export { EncodingOptions } from '../core/types/encodings.js';
-export { concatHashes, readInChunks, zeroPadBuffer } from '../core/utils.js';
+export { ShelbyNetwork, isShelbyNetwork, shelbyNetworks } from '../core/networks.js';
+export { ShelbyIndexerClient, createShelbyIndexerClient, getShelbyIndexerClient } from '../core/operations/index.js';
+export { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding } from '../core/types/blobs.js';
+export { StorageProviderInfo } from '../core/types/storage_providers.js';
+export { buildRequestUrl, concatHashes, readInChunks, zeroPadBytes } from '../core/utils.js';
 import '@aptos-labs/ts-sdk';
 import 'zod';
+import '../core/operations/generated/sdk.js';
+import 'graphql';
+import 'graphql-request';
+import '@shelby-protocol/clay-codes';

package/dist/browser/index.mjs

@@ -1,65 +1,110 @@
-import "../chunk-PLUDE5C3.mjs";
+import "../chunk-TUANYVZQ.mjs";
 import "../chunk-MWDW4ROU.mjs";
+import "../chunk-MQUVYMNQ.mjs";
 import "../chunk-ZHXCVRZX.mjs";
-import "../chunk-IHTPXUYI.mjs";
-import "../chunk-QKT5R735.mjs";
+import "../chunk-RNXGC54D.mjs";
 import {
   ShelbyClient
-} from "../chunk-QM5BVKLD.mjs";
+} from "../chunk-QP2C6ORP.mjs";
+import {
+  ShelbyRPCClient
+} from "../chunk-NRNVAY72.mjs";
+import "../chunk-I6NG5GNL.mjs";
 import {
   ShelbyBlobClient
-} from "../chunk-B3CB2YEO.mjs";
+} from "../chunk-XGMJ4CG4.mjs";
 import {
-  ShelbyRPCClient
-} from "../chunk-2FF5FICZ.mjs";
+  createShelbyIndexerClient,
+  getShelbyIndexerClient
+} from "../chunk-75VHXY5P.mjs";
+import "../chunk-DLMDDEWF.mjs";
+import "../chunk-RBFWGDMY.mjs";
+import "../chunk-Z7RFCADT.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,
@@ -67,13 +112,17 @@ export {
   TOKEN_DEPLOYER,
   TOKEN_OBJECT_ADDRESS,
   allChunksForBlob,
+  buildRequestUrl,
   concatHashes,
   createBlobKey,
-  erasureEncode,
+  createDefaultErasureCodingProvider,
+  createShelbyIndexerClient,
+  expectedTotalChunksets,
   generateCommitments,
-  getChunkSizeBytes,
-  getChunksetSizeBytes,
+  getShelbyIndexerClient,
+  isShelbyNetwork,
   readInChunks,
   roundSize,
-  zeroPadBuffer
+  shelbyNetworks,
+  zeroPadBytes
 };

package/dist/chunk-3ZDXWPYC.mjs

@@ -0,0 +1,65 @@
+// src/core/erasure/reed-solomon.ts
+import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
+var DEFAULT_ERASURE_K = 10;
+var DEFAULT_ERASURE_N = 16;
+var DEFAULT_CHUNK_SIZE_BYTES = 2 * 1024 * 1024;
+var ReedSolomonErasureCodingProvider = class {
+  config;
+  constructor(options) {
+    const erasure_k = options?.erasure_k ?? DEFAULT_ERASURE_K;
+    const erasure_n = options?.erasure_n ?? DEFAULT_ERASURE_N;
+    const chunkSizeBytes = options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES;
+    if (erasure_k <= 0)
+      throw new Error("erasure_k (number of data chunks) must be > 0");
+    if (erasure_n <= erasure_k)
+      throw new Error(
+        `erasure_n (${erasure_n}) must be > erasure_k (${erasure_k})`
+      );
+    if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
+    this.config = {
+      erasure_n,
+      erasure_k,
+      chunkSizeBytes
+    };
+  }
+  encode(data) {
+    const { erasure_k, erasure_n, chunkSizeBytes } = this.config;
+    const erasure_m = erasure_n - erasure_k;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (data.byteLength !== systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    const reedSolomon = createWasmReedSolomonBinding();
+    const shards = new Uint8Array(
+      systematicCapacity + erasure_m * chunkSizeBytes
+    );
+    shards.set(data, 0);
+    reedSolomon.encode(shards, erasure_k, erasure_m);
+    const chunks = new Array(erasure_n);
+    for (let idx = 0; idx < erasure_n; idx++) {
+      const start = idx * chunkSizeBytes;
+      chunks[idx] = shards.slice(start, start + chunkSizeBytes);
+    }
+    return {
+      chunks,
+      systematic: chunks.slice(0, erasure_k),
+      parity: chunks.slice(erasure_k)
+    };
+  }
+  decode(_available, _config) {
+    throw new Error(
+      "ReedSolomonErasureCodingProvider does not implement decode"
+    );
+  }
+};
+
+export {
+  ReedSolomonErasureCodingProvider
+};

package/dist/chunk-75VHXY5P.mjs

@@ -0,0 +1,48 @@
+import {
+  getSdk
+} from "./chunk-DLMDDEWF.mjs";
+import {
+  getAptosConfig
+} from "./chunk-RBFWGDMY.mjs";
+import {
+  NetworkToShelbyBlobIndexerBaseUrl
+} from "./chunk-HPVCKAN2.mjs";
+
+// src/core/operations/index.ts
+import { Network } from "@aptos-labs/ts-sdk";
+import { GraphQLClient } from "graphql-request";
+function createShelbyIndexerClient(baseUrl, options) {
+  const graphqlClient = new GraphQLClient(baseUrl, options);
+  return getSdk(graphqlClient);
+}
+function getShelbyIndexerClient(config) {
+  const aptosConfig = config.aptos ?? getAptosConfig(config);
+  let { apiKey, baseUrl } = config.indexer ?? {};
+  if (!baseUrl) {
+    switch (aptosConfig?.network) {
+      // TODO: Add endpoints for core networks
+      case Network.MAINNET:
+      case Network.TESTNET:
+      case Network.DEVNET:
+      case Network.SHELBYNET:
+        baseUrl = NetworkToShelbyBlobIndexerBaseUrl[aptosConfig.network];
+        break;
+    }
+  }
+  if (baseUrl === void 0) {
+    throw new Error(
+      "The ShelbyClientConfig does not support the Shelby indexer. Please configure the endpoint in the ShelbyClientConfig.indexer.endpoint or provide a supported Aptos network."
+    );
+  }
+  return createShelbyIndexerClient(baseUrl, {
+    headers: {
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      "x-aptos-client": "shelby-ts-sdk"
+    }
+  });
+}
+
+export {
+  createShelbyIndexerClient,
+  getShelbyIndexerClient
+};

package/dist/chunk-APML3CGJ.mjs

@@ -0,0 +1,176 @@
+import {
+  DEFAULT_ERASURE_D,
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_N
+} from "./chunk-ZPW742E7.mjs";
+
+// src/core/erasure/clay-codes.ts
+import {
+  createDecoder,
+  createEncoder
+} from "@shelby-protocol/clay-codes";
+
+// src/core/erasure/default.ts
+var defaultProviderPromise;
+function createDefaultErasureCodingProvider() {
+  if (!defaultProviderPromise) {
+    defaultProviderPromise = ClayErasureCodingProvider.create({
+      erasure_n: DEFAULT_ERASURE_N,
+      erasure_k: DEFAULT_ERASURE_K,
+      erasure_d: DEFAULT_ERASURE_D,
+      chunkSizeBytes: DEFAULT_CHUNK_SIZE_BYTES
+    });
+  }
+  return defaultProviderPromise;
+}
+
+// src/core/chunk.ts
+var ChunkSizeScheme = /* @__PURE__ */ ((ChunkSizeScheme2) => {
+  ChunkSizeScheme2["ChunkSet10MiB_Chunk1MiB"] = "ChunkSet10MiB_Chunk1MiB";
+  return ChunkSizeScheme2;
+})(ChunkSizeScheme || {});
+var CHUNK_SIZE_PARAMS = {
+  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 10MiB
+    chunksetSizeBytes: 10 * 1024 * 1024
+  }
+};
+var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunkSizeBytes;
+var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunksetSizeBytes;
+var ERASURE_CODE_AND_CHUNK_MAPPING = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+  }
+};
+
+// src/core/erasure/clay-codes.ts
+function getTotalChunks(config) {
+  return config.erasure_n;
+}
+var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
+  config;
+  encoderCache;
+  decoderCache;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Static factory method to create an initialized ClayErasureCodingProvider
+   */
+  static async create(options) {
+    const config = buildClayConfig({
+      erasure_n: options?.erasure_n ?? DEFAULT_ERASURE_N,
+      erasure_k: options?.erasure_k ?? DEFAULT_ERASURE_K,
+      erasure_d: options?.erasure_d ?? DEFAULT_ERASURE_D,
+      chunkSizeBytes: options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES
+    });
+    const provider = new _ClayErasureCodingProvider(config);
+    [provider.encoderCache, provider.decoderCache] = await Promise.all([
+      createEncoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes
+      }),
+      createDecoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes,
+        erasedChunksMask: 0
+        // No chunks erased initially; will be reconfigured on decode
+      })
+    ]);
+    return provider;
+  }
+  encode(data) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (!this.encoderCache) {
+      throw new Error("Encoder cache is missing");
+    }
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (this.requiresPadding(data.length)) {
+      throw new Error(
+        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    return this.encoderCache.erasureCode(data);
+  }
+  decode(available, config) {
+    if (!this.decoderCache) {
+      throw new Error("Decoder cache is missing");
+    }
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (available.length < erasure_k) {
+      throw new Error(
+        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
+      );
+    }
+    for (let i = 0; i < available.length; i++) {
+      const chunk = available[i];
+      if (chunk.length !== chunkSizeBytes) {
+        throw new Error(
+          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
+        );
+      }
+    }
+    return this.decoderCache.decode(available, config);
+  }
+  /**
+   * Determines if data can be erasure coded as-is or requires padding.
+   *
+   * Data can be erasure coded without padding if its size exactly matches
+   * the total systematic data capacity (k * chunkSizeBytes).
+   *
+   * @param dataSize - Size of the data in bytes
+   * @returns true if data needs padding, false if it can be coded as-is
+   */
+  requiresPadding(dataSize) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    return dataSize !== systematicCapacity;
+  }
+};
+function buildClayConfig(input) {
+  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes } = input;
+  if (erasure_n <= 0)
+    throw new Error("erasure_n (total number of chunks) must be > 0");
+  if (erasure_k <= 0)
+    throw new Error("erasure_k (number of data chunks) must be > 0");
+  if (erasure_k >= erasure_n)
+    throw new Error(
+      `erasure_k (${erasure_k}) must be < erasure_n (${erasure_n})`
+    );
+  if (erasure_d <= erasure_k)
+    throw new Error(
+      `erasure_d (${erasure_d}) must be > erasure_k (${erasure_k})`
+    );
+  if (erasure_d >= erasure_n)
+    throw new Error(
+      `erasure_d (${erasure_d}) must be < erasure_n (${erasure_n})`
+    );
+  if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
+  return {
+    erasure_n,
+    erasure_k,
+    erasure_d,
+    chunkSizeBytes
+  };
+}
+
+export {
+  ClayErasureCodingProvider,
+  createDefaultErasureCodingProvider,
+  ChunkSizeScheme,
+  CHUNK_SIZE_PARAMS,
+  DEFAULT_CHUNK_SIZE_BYTES,
+  DEFAULT_CHUNKSET_SIZE_BYTES,
+  ERASURE_CODE_AND_CHUNK_MAPPING
+};

package/dist/chunk-DLMDDEWF.mjs

@@ -0,0 +1,112 @@
+// src/core/operations/generated/sdk.ts
+import gql from "graphql-tag";
+var Blob_Activities_Select_Column = /* @__PURE__ */ ((Blob_Activities_Select_Column2) => {
+  Blob_Activities_Select_Column2["BlobName"] = "blob_name";
+  Blob_Activities_Select_Column2["EventIndex"] = "event_index";
+  Blob_Activities_Select_Column2["EventType"] = "event_type";
+  Blob_Activities_Select_Column2["Timestamp"] = "timestamp";
+  Blob_Activities_Select_Column2["TransactionHash"] = "transaction_hash";
+  Blob_Activities_Select_Column2["TransactionVersion"] = "transaction_version";
+  return Blob_Activities_Select_Column2;
+})(Blob_Activities_Select_Column || {});
+var Blobs_Select_Column = /* @__PURE__ */ ((Blobs_Select_Column2) => {
+  Blobs_Select_Column2["BlobCommitment"] = "blob_commitment";
+  Blobs_Select_Column2["BlobName"] = "blob_name";
+  Blobs_Select_Column2["CreatedAt"] = "created_at";
+  Blobs_Select_Column2["ExpiresAt"] = "expires_at";
+  Blobs_Select_Column2["IsDeleted"] = "is_deleted";
+  Blobs_Select_Column2["IsWritten"] = "is_written";
+  Blobs_Select_Column2["NumChunksets"] = "num_chunksets";
+  Blobs_Select_Column2["Owner"] = "owner";
+  Blobs_Select_Column2["PlacementGroup"] = "placement_group";
+  Blobs_Select_Column2["Size"] = "size";
+  Blobs_Select_Column2["SliceAddress"] = "slice_address";
+  Blobs_Select_Column2["UpdatedAt"] = "updated_at";
+  return Blobs_Select_Column2;
+})(Blobs_Select_Column || {});
+var Cursor_Ordering = /* @__PURE__ */ ((Cursor_Ordering2) => {
+  Cursor_Ordering2["Asc"] = "ASC";
+  Cursor_Ordering2["Desc"] = "DESC";
+  return Cursor_Ordering2;
+})(Cursor_Ordering || {});
+var Order_By = /* @__PURE__ */ ((Order_By2) => {
+  Order_By2["Asc"] = "asc";
+  Order_By2["AscNullsFirst"] = "asc_nulls_first";
+  Order_By2["AscNullsLast"] = "asc_nulls_last";
+  Order_By2["Desc"] = "desc";
+  Order_By2["DescNullsFirst"] = "desc_nulls_first";
+  Order_By2["DescNullsLast"] = "desc_nulls_last";
+  return Order_By2;
+})(Order_By || {});
+var Placement_Group_Slots_Select_Column = /* @__PURE__ */ ((Placement_Group_Slots_Select_Column2) => {
+  Placement_Group_Slots_Select_Column2["PlacementGroup"] = "placement_group";
+  Placement_Group_Slots_Select_Column2["SlotIndex"] = "slot_index";
+  Placement_Group_Slots_Select_Column2["Status"] = "status";
+  Placement_Group_Slots_Select_Column2["StorageProvider"] = "storage_provider";
+  Placement_Group_Slots_Select_Column2["UpdatedAt"] = "updated_at";
+  return Placement_Group_Slots_Select_Column2;
+})(Placement_Group_Slots_Select_Column || {});
+var Processor_Status_Select_Column = /* @__PURE__ */ ((Processor_Status_Select_Column2) => {
+  Processor_Status_Select_Column2["LastSuccessVersion"] = "last_success_version";
+  Processor_Status_Select_Column2["LastTransactionTimestamp"] = "last_transaction_timestamp";
+  Processor_Status_Select_Column2["LastUpdated"] = "last_updated";
+  return Processor_Status_Select_Column2;
+})(Processor_Status_Select_Column || {});
+var GetBlobsDocument = gql`
+    query getBlobs($where: blobs_bool_exp, $orderBy: [blobs_order_by!], $limit: Int, $offset: Int) {
+  blobs(where: $where, order_by: $orderBy, limit: $limit, offset: $offset) {
+    owner
+    blob_commitment
+    blob_name
+    created_at
+    expires_at
+    num_chunksets
+    is_deleted
+    is_written
+    placement_group
+    size
+    updated_at
+    slice_address
+  }
+}
+    `;
+var GetBlobActivitiesDocument = gql`
+    query getBlobActivities($where: blob_activities_bool_exp, $orderBy: [blob_activities_order_by!], $limit: Int, $offset: Int) {
+  blob_activities(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    blob_name
+    event_index
+    event_type
+    transaction_hash
+    transaction_version
+    timestamp
+  }
+}
+    `;
+var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
+function getSdk(client, withWrapper = defaultWrapper) {
+  return {
+    getBlobs(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobs", "query", variables);
+    },
+    getBlobActivities(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivities", "query", variables);
+    }
+  };
+}
+
+export {
+  Blob_Activities_Select_Column,
+  Blobs_Select_Column,
+  Cursor_Ordering,
+  Order_By,
+  Placement_Group_Slots_Select_Column,
+  Processor_Status_Select_Column,
+  GetBlobsDocument,
+  GetBlobActivitiesDocument,
+  getSdk
+};