@shelby-protocol/sdk 0.3.0 → 0.4.0

package/dist/core/clients/ShelbyRPCClient.mjs

@@ -1,16 +1,1249 @@
+// src/core/clients/ShelbyRPCClient.ts
 import {
-  ShelbyRPCClient
-} from "../../chunk-WFWRBNTW.mjs";
-import "../../chunk-KG2TMLEV.mjs";
-import "../../chunk-NEO7Z3ZQ.mjs";
-import "../../chunk-TET3DJEO.mjs";
-import "../../chunk-V4B3GAMQ.mjs";
-import "../../chunk-Z4FZ7W6L.mjs";
-import "../../chunk-I6NG5GNL.mjs";
-import "../../chunk-M3CP5TFP.mjs";
-import "../../chunk-UEZNZBJO.mjs";
-import "../../chunk-MNCQBEMS.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  Hex as Hex3
+} from "@aptos-labs/ts-sdk";
+
+// src/core/erasure/constants.ts
+var ERASURE_CODE_PARAMS = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 16,
+    // data chunks
+    erasure_k: 10,
+    // helper nodes
+    erasure_d: 13,
+    // enum index
+    enumIndex: 0
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 4,
+    // data chunks
+    erasure_k: 2,
+    // helper nodes
+    erasure_d: 3,
+    // enum index
+    enumIndex: 1
+  }
+};
+function findErasureSchemeByErasureN(erasureN) {
+  return Object.entries(ERASURE_CODE_PARAMS).find(
+    ([, params]) => params.erasure_n === erasureN
+  );
+}
+var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_n;
+var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_k;
+var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_d;
+var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
+
+// src/core/chunk.ts
+var CHUNK_SIZE_PARAMS = {
+  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 10MiB
+    chunksetSizeBytes: 10 * 1024 * 1024
+  },
+  ["ChunkSet2MiB_Chunk1MiB" /* ChunkSet2MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 2MiB
+    chunksetSizeBytes: 2 * 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
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet2MiB_Chunk1MiB
+  }
+};
+
+// src/core/layout.ts
+import { z } from "zod";
+var BlobNameSchema = z.string().min(1, "Blob name path parameter cannot be empty.").max(
+  190,
+  "Blob name suffix cannot exceed 190 characters (on-chain full key limit is 256 bytes)."
+).refine((name) => !name.endsWith("/"), {
+  message: "Blob name cannot end with a slash"
+});
+
+// src/core/operations/index.ts
+import { Network as Network2 } from "@aptos-labs/ts-sdk";
+import { GraphQLClient } from "graphql-request";
+
+// src/core/clients/utils.ts
+import { AptosConfig } from "@aptos-labs/ts-sdk";
+
+// src/core/constants.ts
+import { Network } from "@aptos-labs/ts-sdk";
+var NetworkToShelbyRPCBaseUrl = {
+  [Network.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: "http://localhost:9090",
+  [Network.CUSTOM]: void 0
+};
+var NetworkToShelbyBlobIndexerBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.aptoslabs.com/nocode/v1/public/alias/shelby/shelbynet/v1/graphql",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.aptoslabs.com/nocode/v1/public/alias/shelby/testnet/v1/graphql",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: "http://localhost:8091/v1/graphql",
+  [Network.CUSTOM]: void 0
+};
+var NetworkToGasStationBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/gs/v1",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.shelby.xyz/gs/v1",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: void 0,
+  [Network.CUSTOM]: void 0
+};
+var MICROPAYMENTS_DEPLOYER = "0x1ae7275148bf6ef742b658fd9cbcc2e094201606f4a7bc707bab0201da8043ee";
+
+// src/core/clients/utils.ts
+var getAptosConfig = (config) => {
+  const baseFaucetConfig = config.faucet?.authToken ? { AUTH_TOKEN: config.faucet.authToken } : void 0;
+  if (config.aptos) {
+    return new AptosConfig({
+      // Spread user's aptos config first
+      ...config.aptos,
+      // Network from top-level is authoritative - cannot be overridden
+      network: config.network,
+      // Merge clientConfig with API_KEY default
+      clientConfig: {
+        API_KEY: config.apiKey,
+        ...config.aptos.clientConfig
+      },
+      // Merge faucetConfig: aptos config first, then base authToken (authoritative)
+      faucetConfig: {
+        ...config.aptos.faucetConfig,
+        ...baseFaucetConfig
+      }
+    });
+  }
+  return new AptosConfig({
+    network: config.network,
+    clientConfig: {
+      API_KEY: config.apiKey
+    },
+    faucetConfig: baseFaucetConfig
+  });
+};
+var getShelbyRPCBaseUrl = (config) => {
+  return config.rpc?.baseUrl ?? NetworkToShelbyRPCBaseUrl[config.network] ?? NetworkToShelbyRPCBaseUrl.testnet;
+};
+
+// src/core/operations/generated/sdk.ts
+import gql from "graphql-tag";
+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) {
+    uid
+    object_name
+    owner
+    blob_commitment
+    created_at
+    expires_at
+    updated_at
+    num_chunksets
+    size
+    slice_address
+    placement_group
+    is_persisted
+    is_committed
+    is_deleted
+  }
+}
+    `;
+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
+  ) {
+    uid
+    object_name
+    event_index
+    event_type
+    transaction_hash
+    transaction_version
+    timestamp
+    owner
+  }
+}
+    `;
+var GetBlobsCountDocument = gql`
+    query getBlobsCount($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetBlobActivitiesCountDocument = gql`
+    query getBlobActivitiesCount($where: blob_activities_bool_exp) {
+  blob_activities_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetTotalBlobsSizeDocument = gql`
+    query getTotalBlobsSize($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      sum {
+        size
+      }
+    }
+  }
+}
+    `;
+var GetPlacementGroupSlotsDocument = gql`
+    query getPlacementGroupSlots($where: placement_group_slots_bool_exp, $orderBy: [placement_group_slots_order_by!], $limit: Int, $offset: Int) {
+  placement_group_slots(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    placement_group
+    slot_index
+    storage_provider
+    status
+    updated_at
+  }
+}
+    `;
+var GetPlacementGroupSlotsCountDocument = gql`
+    query getPlacementGroupSlotsCount($where: placement_group_slots_bool_exp) {
+  placement_group_slots_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetProcessorStatusDocument = gql`
+    query getProcessorStatus {
+  processor_status {
+    last_success_version
+    last_transaction_timestamp
+    last_updated
+  }
+}
+    `;
+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);
+    },
+    getBlobsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobsCount", "query", variables);
+    },
+    getBlobActivitiesCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivitiesCount", "query", variables);
+    },
+    getTotalBlobsSize(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTotalBlobsSizeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getTotalBlobsSize", "query", variables);
+    },
+    getPlacementGroupSlots(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlots", "query", variables);
+    },
+    getPlacementGroupSlotsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlotsCount", "query", variables);
+    },
+    getProcessorStatus(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetProcessorStatusDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getProcessorStatus", "query", variables);
+    }
+  };
+}
+
+// src/core/operations/index.ts
+function createShelbyIndexerClient(baseUrl, options) {
+  const graphqlClient = new GraphQLClient(baseUrl, options);
+  return getSdk(graphqlClient);
+}
+function getShelbyIndexerClient(config) {
+  const aptosConfig = getAptosConfig(config);
+  let { apiKey: indexerApiKey, baseUrl } = config.indexer ?? {};
+  if (!baseUrl) {
+    switch (aptosConfig?.network) {
+      // TODO: Add endpoints for core networks
+      case Network2.MAINNET:
+      case Network2.TESTNET:
+      case Network2.DEVNET:
+      case Network2.SHELBYNET:
+      case Network2.LOCAL:
+        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."
+    );
+  }
+  const apiKey = indexerApiKey ?? config.apiKey;
+  return createShelbyIndexerClient(baseUrl, {
+    headers: {
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      "x-aptos-client": "shelby-ts-sdk"
+    }
+  });
+}
+
+// src/core/promises.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/rpc-responses.ts
+import { z as z2 } from "zod";
+var ChallengeResponseSchema = z2.object({
+  challenge: z2.string(),
+  expiresAt: z2.number()
+});
+var RPCErrorResponseSchema = z2.object({
+  error: z2.string()
+});
+var StaleMicropaymentErrorResponseSchema = z2.object({
+  error: z2.string().optional(),
+  storedMicropayment: z2.string().optional()
+});
+
+// src/core/types/payments.ts
+import {
+  AccountAddress,
+  Deserializer,
+  Hex,
+  Serializer
+} from "@aptos-labs/ts-sdk";
+var MICROPAYMENTS_MODULE_NAME = "micropayments";
+var WITHDRAW_APPROVAL_STRUCT_NAME = "WithdrawApproval";
+function serializeTypeInfo(serializer, moduleAddress, moduleName, structName) {
+  moduleAddress.serialize(serializer);
+  const moduleNameBytes = new TextEncoder().encode(moduleName);
+  serializer.serializeBytes(moduleNameBytes);
+  const structNameBytes = new TextEncoder().encode(structName);
+  serializer.serializeBytes(structNameBytes);
+}
+var StaleChannelStateError = class _StaleChannelStateError extends Error {
+  /**
+   * The last valid micropayment stored by the server.
+   * Clients can use this to reset their local channel state.
+   */
+  storedMicropayment;
+  constructor(storedMicropayment, message) {
+    super(
+      message ?? "Client has stale channel state. Use the returned micropayment to reset local state."
+    );
+    this.name = "StaleChannelStateError";
+    this.storedMicropayment = storedMicropayment;
+  }
+  /**
+   * Returns the stored micropayment as a base64-encoded string.
+   */
+  toBase64() {
+    const bytes = this.storedMicropayment.bcsToBytes();
+    const binaryString = Array.from(
+      bytes,
+      (byte) => String.fromCharCode(byte)
+    ).join("");
+    return btoa(binaryString);
+  }
+  /**
+   * Creates a StaleChannelStateError from a base64-encoded micropayment string.
+   */
+  static fromBase64(base64, message) {
+    const binaryString = atob(base64);
+    const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    const micropayment = SenderBuiltMicropayment.deserialize(bytes);
+    return new _StaleChannelStateError(micropayment, message);
+  }
+};
+var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
+  /**
+   * The sender's address (owner of the payment channel).
+   */
+  sender;
+  /**
+   * The receiver's address (beneficiary of the withdrawal).
+   */
+  receiver;
+  /**
+   * The unique ID of the payment channel.
+   */
+  paymentChannelId;
+  /**
+   * The cumulative amount the receiver is authorized to withdraw.
+   */
+  amount;
+  /**
+   * The fungible asset metadata address.
+   */
+  fungibleAssetAddress;
+  /**
+   * Monotonically increasing sequence number for replay protection.
+   */
+  sequenceNumber;
+  /**
+   * The sender's Ed25519 public key (32 bytes).
+   * Used by the receiver to verify the signature before submitting.
+   */
+  publicKey;
+  /**
+   * The Ed25519 signature of the SignedMessage<WithdrawApproval> struct.
+   * The SignedMessage includes TypeInfo for domain separation.
+   */
+  signature;
+  /**
+   * The deployer address of the micropayments module.
+   * This is needed to reconstruct the TypeInfo for signature verification.
+   */
+  deployer;
+  constructor(sender, receiver, paymentChannelId, amount, fungibleAssetAddress, sequenceNumber, publicKey, signature, deployer) {
+    this.sender = sender;
+    this.receiver = receiver;
+    this.paymentChannelId = paymentChannelId;
+    this.amount = amount;
+    this.fungibleAssetAddress = fungibleAssetAddress;
+    this.sequenceNumber = sequenceNumber;
+    this.publicKey = publicKey;
+    this.signature = signature;
+    this.deployer = deployer ?? AccountAddress.fromString(MICROPAYMENTS_DEPLOYER);
+  }
+  /**
+   * Creates the BCS-serialized message that was signed.
+   * This is a SignedMessage<WithdrawApproval> which includes:
+   * 1. TypeInfo (module_address, module_name, struct_name)
+   * 2. WithdrawApproval struct fields
+   *
+   * This format is used with signature_verify_strict_t for domain separation.
+   */
+  getSignedMessage() {
+    return _SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
+      sender: this.sender,
+      receiver: this.receiver,
+      fungibleAssetAddress: this.fungibleAssetAddress,
+      amount: this.amount,
+      paymentChannelId: this.paymentChannelId,
+      sequenceNumber: this.sequenceNumber
+    });
+  }
+  /**
+   * Static helper to build the SignedMessage<WithdrawApproval> bytes from raw parameters.
+   * This can be used to create the message for signing without constructing the full object.
+   *
+   * @param params - The withdrawal approval parameters.
+   * @returns The BCS-serialized SignedMessage<WithdrawApproval> bytes.
+   */
+  static buildSignedMessage(params) {
+    const serializer = new Serializer();
+    serializeTypeInfo(
+      serializer,
+      params.deployer,
+      MICROPAYMENTS_MODULE_NAME,
+      WITHDRAW_APPROVAL_STRUCT_NAME
+    );
+    params.sender.serialize(serializer);
+    params.receiver.serialize(serializer);
+    params.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(params.amount);
+    serializer.serializeU64(params.paymentChannelId);
+    serializer.serializeU64(params.sequenceNumber);
+    return serializer.toUint8Array();
+  }
+  serialize(serializer) {
+    this.sender.serialize(serializer);
+    this.receiver.serialize(serializer);
+    this.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(this.amount);
+    serializer.serializeU64(this.paymentChannelId);
+    serializer.serializeU64(this.sequenceNumber);
+    serializer.serializeBytes(this.publicKey);
+    serializer.serializeBytes(this.signature);
+    this.deployer.serialize(serializer);
+  }
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  bcsToHex() {
+    return Hex.fromHexInput(this.bcsToBytes());
+  }
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  toString() {
+    return this.bcsToHex().toString();
+  }
+  /**
+   * Deserializes a SenderBuiltMicropayment from BCS bytes.
+   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
+   * @returns A new SenderBuiltMicropayment instance.
+   */
+  static deserialize(bytes) {
+    const bytesArray = typeof bytes === "string" ? Hex.fromHexInput(bytes).toUint8Array() : bytes;
+    const deserializer = new Deserializer(bytesArray);
+    const sender = AccountAddress.deserialize(deserializer);
+    const receiver = AccountAddress.deserialize(deserializer);
+    const fungibleAssetAddress = AccountAddress.deserialize(deserializer);
+    const amount = deserializer.deserializeU64();
+    const paymentChannelId = deserializer.deserializeU64();
+    const sequenceNumber = deserializer.deserializeU64();
+    const publicKey = deserializer.deserializeBytes();
+    const signature = deserializer.deserializeBytes();
+    const deployer = AccountAddress.deserialize(deserializer);
+    return new _SenderBuiltMicropayment(
+      sender,
+      receiver,
+      paymentChannelId,
+      amount,
+      fungibleAssetAddress,
+      sequenceNumber,
+      publicKey,
+      signature,
+      deployer
+    );
+  }
+};
+
+// src/core/utils.ts
+import {
+  AccountAddress as AccountAddress2,
+  Hex as Hex2
+} from "@aptos-labs/ts-sdk";
+async function* readInChunks(input, chunkSize) {
+  let idx = 0;
+  if (isReadableStream(input)) {
+    const reader = input.getReader();
+    let buffer = new Uint8Array(chunkSize);
+    let bufferWriteOffset = 0;
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (value === void 0) continue;
+        let srcOffset = 0;
+        while (srcOffset < value.length) {
+          const remainingCapacity = chunkSize - bufferWriteOffset;
+          const bytesToCopy = Math.min(
+            remainingCapacity,
+            value.length - srcOffset
+          );
+          buffer.set(
+            value.subarray(srcOffset, srcOffset + bytesToCopy),
+            bufferWriteOffset
+          );
+          bufferWriteOffset += bytesToCopy;
+          srcOffset += bytesToCopy;
+          if (bufferWriteOffset >= chunkSize) {
+            yield [idx++, buffer];
+            buffer = new Uint8Array(chunkSize);
+            bufferWriteOffset = 0;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (bufferWriteOffset > 0) {
+      yield [idx++, buffer.subarray(0, bufferWriteOffset)];
+    }
+    return;
+  }
+  const view = toUint8Array(input);
+  for (let offset = 0; offset < view.byteLength; offset += chunkSize) {
+    yield [
+      idx++,
+      view.subarray(offset, Math.min(offset + chunkSize, view.byteLength))
+    ];
+  }
+}
+async function concatHashes(parts) {
+  const chunks = parts.map((part) => Hex2.fromHexInput(part).toUint8Array());
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return Hex2.fromHexInput(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
+  );
+}
+function isReadableStream(value) {
+  return typeof value === "object" && value !== null && "getReader" in value && typeof value.getReader === "function";
+}
+function toUint8Array(view) {
+  return view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function buildRequestUrl(path, baseUrl) {
+  const baseHasSlash = baseUrl.endsWith("/");
+  const safeBase = baseHasSlash ? baseUrl : `${baseUrl}/`;
+  const safePath = path.replace(/^\/+/, "");
+  return new URL(safePath, safeBase);
+}
+function normalizeAddress(address) {
+  return AccountAddress2.from(address, { maxMissingChars: 63 });
+}
+
+// src/core/clients/ShelbyRPCClient.ts
+var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
+var BLOB_OWNER_CHALLENGE_HEADER = "X-Shelby-Challenge";
+var BLOB_OWNER_SIGNATURE_HEADER = "X-Shelby-Signature";
+var BLOB_OWNER_PUBLIC_KEY_HEADER = "X-Shelby-Public-Key";
+var BLOB_OWNER_AUTH_SCHEME_HEADER = "X-Shelby-Auth-Scheme";
+var BLOB_OWNER_IDENTITY_HEADER = "X-Shelby-Identity";
+var BLOB_OWNER_DOMAIN_HEADER = "X-Shelby-Domain";
+var BLOB_OWNER_AUTH_FUNCTION_HEADER = "X-Shelby-Auth-Function";
+var INCLUSION_PROOF_HEADER = "X-Shelby-Inclusion-Proof";
+function buildAuthHeaders(auth) {
+  const signatureBase64 = btoa(
+    Array.from(auth.signature, (byte) => String.fromCharCode(byte)).join("")
+  );
+  const publicKeyHex = Hex3.fromHexInput(auth.publicKey).toString();
+  const headers = {
+    [BLOB_OWNER_CHALLENGE_HEADER]: auth.challenge,
+    [BLOB_OWNER_SIGNATURE_HEADER]: signatureBase64,
+    [BLOB_OWNER_PUBLIC_KEY_HEADER]: publicKeyHex
+  };
+  if (auth.authScheme === "derivable") {
+    headers[BLOB_OWNER_AUTH_SCHEME_HEADER] = auth.authScheme;
+    headers[BLOB_OWNER_IDENTITY_HEADER] = auth.identity;
+    headers[BLOB_OWNER_DOMAIN_HEADER] = auth.domain;
+    headers[BLOB_OWNER_AUTH_FUNCTION_HEADER] = auth.authFunction;
+  } else if (auth.authScheme) {
+    headers[BLOB_OWNER_AUTH_SCHEME_HEADER] = auth.authScheme;
+  }
+  return headers;
+}
+function encodeURIComponentKeepSlashes(str) {
+  return encodeURIComponent(str).replace(/%2F/g, "/");
+}
+async function generateChunksetInclusionProof(chunksetRoots, chunksetIndex) {
+  if (chunksetRoots.length === 0) {
+    throw new Error("Cannot generate inclusion proof for empty chunkset roots");
+  }
+  if (chunksetIndex < 0 || chunksetIndex >= chunksetRoots.length) {
+    throw new Error(
+      `Chunkset index ${chunksetIndex} out of range [0, ${chunksetRoots.length})`
+    );
+  }
+  if (chunksetRoots.length === 1) {
+    return [];
+  }
+  const zeroHash = new Uint8Array(32);
+  const siblings = [];
+  let currentLeaves = chunksetRoots.map((h) => h.toUint8Array());
+  let currentIdx = chunksetIndex;
+  while (currentLeaves.length > 1) {
+    if (currentLeaves.length % 2 !== 0) {
+      currentLeaves.push(zeroHash);
+    }
+    const siblingIdx = currentIdx % 2 === 0 ? currentIdx + 1 : currentIdx - 1;
+    siblings.push(currentLeaves[siblingIdx]);
+    const nextLeaves = [];
+    for (let i = 0; i < currentLeaves.length; i += 2) {
+      const combined = await concatHashes([
+        currentLeaves[i],
+        currentLeaves[i + 1]
+      ]);
+      nextLeaves.push(combined.toUint8Array());
+    }
+    currentLeaves = nextLeaves;
+    currentIdx = Math.floor(currentIdx / 2);
+  }
+  return siblings;
+}
+function encodeInclusionProof(siblings) {
+  if (siblings.length === 0) {
+    return "NONE";
+  }
+  const totalBytes = siblings.length * 32;
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const sibling of siblings) {
+    combined.set(sibling, offset);
+    offset += 32;
+  }
+  const binaryString = Array.from(
+    combined,
+    (byte) => String.fromCharCode(byte)
+  ).join("");
+  return btoa(binaryString);
+}
+function validateTotalBytes(totalBytes) {
+  if (!Number.isInteger(totalBytes) || totalBytes < 0) {
+    throw new Error("totalBytes must be a non-negative integer");
+  }
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  if (error instanceof Error) {
+    const match = error.message.match(/\bE[A-Z0-9_]+\b/);
+    return match?.[0];
+  }
+  return void 0;
+}
+var ShelbyRPCClient = class {
+  baseUrl;
+  apiKey;
+  rpcConfig;
+  indexer;
+  #signChallengeOverride;
+  /**
+   * Creates a new ShelbyRPCClient for interacting with Shelby RPC nodes.
+   * This client handles blob storage operations including upload and download.
+   *
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
+   * @param options.signChallengeHandler - Optional override for challenge
+   *   signing. When set, `putBlobChunksets` uses this instead of the built-in
+   *   `signChallenge`. Intended for kit-level overrides (e.g. Solana DAA).
+   *
+   * @example
+   * ```typescript
+   * const client = new ShelbyRPCClient({
+   *   network: Network.SHELBYNET,
+   *   apiKey: "AG-***",
+   * });
+   * ```
+   */
+  constructor(config, options) {
+    this.baseUrl = getShelbyRPCBaseUrl(config);
+    this.apiKey = config.apiKey ?? config.rpc?.apiKey;
+    this.rpcConfig = config.rpc ?? {};
+    this.indexer = getShelbyIndexerClient(config);
+    this.#signChallengeOverride = options?.signChallengeHandler;
+  }
+  /**
+   * Request an authentication challenge for the given account.
+   * The challenge must be signed and included in subsequent authenticated requests.
+   *
+   * @param account - The Aptos account address to authenticate as.
+   * @returns The challenge string and expiration timestamp.
+   *
+   * @example
+   * ```typescript
+   * const { challenge, expiresAt } = await client.getChallenge(account.accountAddress);
+   * const auth = client.signChallenge(account, challenge);
+   * ```
+   */
+  async getChallenge(account) {
+    const response = await fetch(
+      buildRequestUrl("/v1/auth/challenge", this.baseUrl),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({ account: account.toString() })
+      }
+    );
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(
+        `Failed to get challenge: status ${response.status}, body: ${errorBody}`
+      );
+    }
+    return ChallengeResponseSchema.parse(await response.json());
+  }
+  /**
+   * Sign a challenge using the given account and return auth credentials.
+   *
+   * @param account - The Aptos account to sign with.
+   * @param challenge - The hex-encoded challenge string from getChallenge().
+   * @returns BlobOwnerAuth credentials for authenticated requests.
+   */
+  signChallenge(account, challenge) {
+    const challengeBytes = Hex3.fromHexInput(challenge).toUint8Array();
+    const signature = account.sign(challengeBytes);
+    return {
+      challenge,
+      signature: signature.toUint8Array(),
+      publicKey: account.publicKey.toUint8Array()
+    };
+  }
+  /**
+   * Upload a single chunkset via the v2 chunkset API.
+   */
+  async #uploadChunkset(params) {
+    const maxNonBusyRetries = 5;
+    let lastResponse;
+    let lastError;
+    let attempts = 0;
+    let consecutive429s = 0;
+    let nonBusyRetries = 0;
+    const chunksetUrl = buildRequestUrl(
+      `/v2/chunksets/${params.account}/${params.chunksetIndex}/${params.uid}`,
+      this.baseUrl
+    );
+    const authHeaders = buildAuthHeaders(params.auth);
+    while (true) {
+      if (params.signal?.aborted) {
+        throw new DOMException("Upload aborted", "AbortError");
+      }
+      attempts++;
+      try {
+        lastResponse = await fetch(chunksetUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/octet-stream",
+            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
+            ...authHeaders,
+            [INCLUSION_PROOF_HEADER]: params.inclusionProof
+          },
+          body: params.chunksetData,
+          signal: params.signal
+        });
+        lastError = void 0;
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
+        lastError = error;
+        consecutive429s = 0;
+        nonBusyRetries++;
+        if (nonBusyRetries < maxNonBusyRetries) {
+          const delay2 = 2 ** nonBusyRetries * 100;
+          await sleep(delay2);
+          continue;
+        }
+        break;
+      }
+      if (lastResponse.ok) {
+        const json = await lastResponse.json();
+        const spAcks = json.spAcks?.map((ack) => ({
+          slot: ack.slot,
+          signature: Uint8Array.from(
+            atob(ack.signature),
+            (c) => c.charCodeAt(0)
+          )
+        }));
+        return {
+          success: json.success,
+          acksReceived: json.acksReceived,
+          spAcks
+        };
+      }
+      if (lastResponse.status === 429) {
+        consecutive429s++;
+        const baseDelay = 500;
+        const jitter = Math.random() * 200;
+        const delay2 = Math.min(
+          3e4,
+          2 ** consecutive429s * baseDelay + jitter
+        );
+        await sleep(delay2);
+        continue;
+      }
+      consecutive429s = 0;
+      if (!isRetryableStatus(lastResponse.status)) {
+        break;
+      }
+      nonBusyRetries++;
+      if (nonBusyRetries >= maxNonBusyRetries) {
+        break;
+      }
+      const delay = 2 ** nonBusyRetries * 100;
+      await sleep(delay);
+    }
+    if (lastError !== void 0) {
+      const errorCode = getErrorCode(lastError);
+      const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
+      throw new Error(
+        `Failed to upload chunkset ${params.chunksetIndex} after ${attempts} attempt${attempts === 1 ? "" : "s"}. ${errorCode ? `(${errorCode}) ` : ""}Last error: ${errorMessage}`,
+        { cause: lastError }
+      );
+    }
+    const errorBody = await lastResponse?.text().catch(() => "");
+    throw new Error(
+      `Failed to upload chunkset ${params.chunksetIndex} after ${attempts} attempt${attempts === 1 ? "" : "s"}. status: ${lastResponse?.status}, body: ${errorBody}`
+    );
+  }
+  /**
+   * Uploads blob data to the Shelby RPC node using the v2 chunkset API.
+   * This method authenticates using challenge-response and uploads chunksets
+   * directly to storage providers via the RPC's worker pool.
+   *
+   * This method:
+   * - Sends raw chunkset data directly to the RPC for erasure encoding
+   * - Requires pre-computed blob commitments to generate inclusion proofs
+   * - Does not support resume (each chunkset is idempotent on the SP side)
+   *
+   * @param params.account - The Aptos Account (with signing capability) that owns the blob.
+   * @param params.uid - The blob's on-chain UID (from `BlobRegisteredEvent` at registration).
+   * @param params.blobData - The raw blob data as a Uint8Array or ReadableStream.
+   * @param params.commitments - Pre-computed blob commitments (from generateCommitments).
+   * @param params.totalBytes - Total byte length. Required for streams; optional for Uint8Array.
+   * @param params.chunksetConcurrency - Number of chunksets to upload in parallel. Defaults to 4.
+   * @param params.onProgress - Optional callback for upload progress.
+   * @param params.signal - Optional AbortSignal for cancellation. When aborted, in-flight
+   *   HTTP requests are cancelled and an AbortError is thrown.
+   *
+   * @example
+   * ```typescript
+   * // First, generate commitments for the blob
+   * const commitments = await generateCommitments(provider, fileData);
+   *
+   * // Register the blob on chain, then read its UID from the register tx's
+   * // BlobRegisteredEvent (see ShelbyBlobClient.registeredBlobUids).
+   *
+   * // Upload using chunkset API
+   * await rpcClient.putBlobChunksets({
+   *   account: myAccount,
+   *   uid: blobUid,
+   *   blobData: fileData,
+   *   commitments,
+   *   chunksetConcurrency: 8,
+   * });
+   * ```
+   */
+  async putBlobChunksets(params) {
+    let totalBytes;
+    if (params.blobData instanceof Uint8Array) {
+      totalBytes = params.totalBytes ?? params.blobData.length;
+      if (totalBytes !== params.blobData.length) {
+        throw new Error(
+          "totalBytes must match blobData.length when blobData is a Uint8Array"
+        );
+      }
+    } else {
+      if (params.totalBytes === void 0) {
+        throw new Error(
+          "totalBytes is required when blobData is a ReadableStream"
+        );
+      }
+      totalBytes = params.totalBytes;
+    }
+    validateTotalBytes(totalBytes);
+    const chunksetConcurrency = params.chunksetConcurrency ?? 4;
+    const totalChunksets = params.commitments.chunkset_commitments.length;
+    const rawDataSizeFromCommitments = params.commitments.raw_data_size;
+    if (rawDataSizeFromCommitments !== totalBytes) {
+      throw new Error(
+        `Data size mismatch: commitments were generated for ${rawDataSizeFromCommitments} bytes, but totalBytes=${totalBytes}. This will cause inclusion proof verification to fail.`
+      );
+    }
+    const chunksetRoots = params.commitments.chunkset_commitments.map(
+      (c) => Hex3.fromHexString(c.chunkset_root)
+    );
+    const { challenge } = await this.getChallenge(
+      params.account.accountAddress
+    );
+    const signFn = this.#signChallengeOverride ?? this.signChallenge.bind(this);
+    const auth = signFn(params.account, challenge);
+    const firstChunkset = params.commitments.chunkset_commitments[0];
+    if (!firstChunkset) {
+      throw new Error("Commitments must have at least one chunkset");
+    }
+    const erasure_n = firstChunkset.chunk_commitments.length;
+    const matchingEntry = findErasureSchemeByErasureN(erasure_n);
+    if (!matchingEntry) {
+      throw new Error(
+        `Unknown erasure coding scheme with erasure_n=${erasure_n}`
+      );
+    }
+    const [schemeKey, matchingParams] = matchingEntry;
+    const erasure_k = matchingParams.erasure_k;
+    const { chunkSizeBytes } = ERASURE_CODE_AND_CHUNK_MAPPING[schemeKey];
+    const chunksetSize = erasure_k * chunkSizeBytes;
+    const expectedChunksetCount = totalBytes === 0 ? 1 : Math.ceil(totalBytes / chunksetSize);
+    if (expectedChunksetCount !== totalChunksets) {
+      throw new Error(
+        `Chunkset count mismatch: expected ${expectedChunksetCount} chunksets for ${totalBytes} bytes with chunksetSize=${chunksetSize}, but commitments have ${totalChunksets} chunksets. This suggests the commitments were generated with a different encoding scheme.`
+      );
+    }
+    let uploadedBytes = 0;
+    let bytesReadFromSource = 0;
+    const inFlight = /* @__PURE__ */ new Set();
+    async function* chunksetsFromBlob() {
+      if (totalBytes === 0) {
+        yield [0, new Uint8Array(chunksetSize)];
+        return;
+      }
+      yield* readInChunks(params.blobData, chunksetSize);
+    }
+    const chunksetIterator = chunksetsFromBlob();
+    const aggregatedAcks = /* @__PURE__ */ new Map();
+    const internalAbort = new AbortController();
+    if (params.signal?.aborted) {
+      internalAbort.abort();
+    } else if (params.signal) {
+      params.signal.addEventListener("abort", () => internalAbort.abort(), {
+        once: true
+      });
+    }
+    let iteratorDone = false;
+    let firstError = null;
+    while (!iteratorDone || inFlight.size > 0) {
+      if (internalAbort.signal.aborted) {
+        throw firstError ?? new DOMException("Upload aborted", "AbortError");
+      }
+      while (inFlight.size < chunksetConcurrency && !iteratorDone) {
+        const { value, done } = await chunksetIterator.next();
+        if (done) {
+          iteratorDone = true;
+          break;
+        }
+        const [chunksetIdx, chunksetData] = value;
+        bytesReadFromSource += totalBytes === 0 ? 0 : chunksetData.byteLength;
+        const expectedCommitment = params.commitments.chunkset_commitments[chunksetIdx];
+        if (!expectedCommitment) {
+          throw new Error(
+            `Chunkset index ${chunksetIdx} out of range. Commitments only have ${totalChunksets} chunksets. This suggests a chunkset size mismatch between commitment generation and upload.`
+          );
+        }
+        const proofSiblings = await generateChunksetInclusionProof(
+          chunksetRoots,
+          chunksetIdx
+        );
+        const inclusionProof = encodeInclusionProof(proofSiblings);
+        const chunksetDataCopy = new Uint8Array(chunksetData);
+        const chunksetBytes = chunksetDataCopy.length;
+        const uploadPromise = (async () => {
+          const result = await this.#uploadChunkset({
+            account: params.account.accountAddress.toString(),
+            uid: params.uid,
+            chunksetIndex: chunksetIdx,
+            inclusionProof,
+            chunksetData: chunksetDataCopy,
+            auth,
+            signal: internalAbort.signal
+          });
+          const chunksetSpAcks = result.spAcks?.map((ack) => ({
+            slot: ack.slot,
+            signature: ack.signature
+          }));
+          if (chunksetSpAcks) {
+            for (const ack of chunksetSpAcks) {
+              aggregatedAcks.set(ack.slot, ack.signature);
+            }
+          }
+          uploadedBytes += chunksetBytes;
+          params.onProgress?.({
+            phase: "uploading",
+            chunksetIdx,
+            totalChunksets,
+            chunksetBytes,
+            uploadedBytes,
+            totalBytes,
+            acksReceived: result.acksReceived,
+            spAcks: chunksetSpAcks
+          });
+        })().catch((err) => {
+          if (!firstError) {
+            firstError = err;
+            internalAbort.abort();
+          }
+        }).finally(() => {
+          inFlight.delete(uploadPromise);
+        });
+        inFlight.add(uploadPromise);
+      }
+      if (inFlight.size > 0) {
+        await Promise.race(inFlight);
+      }
+    }
+    if (firstError) {
+      throw firstError;
+    }
+    if (bytesReadFromSource !== totalBytes) {
+      throw new Error(
+        `Data source produced ${bytesReadFromSource} bytes, but expected ${totalBytes} bytes. The stream may have ended prematurely, resulting in an incomplete upload.`
+      );
+    }
+    const spAcks = Array.from(
+      aggregatedAcks.entries()
+    ).map(([slot, signature]) => ({ slot, signature }));
+    return { spAcks };
+  }
+  /**
+   * 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.micropayment - Optional micropayment to attach to the request.
+   *
+   * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
+   *
+   * @throws Error if the download fails or content length doesn't match.
+   * @throws StaleChannelStateError if the micropayment is stale (server has newer state).
+   *
+   * @example
+   * ```typescript
+   * // Download entire blob
+   * const blob = await client.getBlob({
+   *   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 }
+   * });
+   *
+   * // Download with micropayment
+   * const blob = await client.getBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "documents/report.pdf",
+   *   micropayment: senderBuiltMicropayment
+   * });
+   * ```
+   */
+  async getBlob(params) {
+    BlobNameSchema.parse(params.blobName);
+    const url = buildRequestUrl(
+      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
+        params.blobName
+      )}`,
+      this.baseUrl
+    );
+    const headers = new Headers();
+    if (params.range !== void 0) {
+      const { start, end } = params.range;
+      if (end === void 0) {
+        headers.set("Range", `bytes=${start}-`);
+      } else {
+        if (end < start) {
+          throw new Error("Range end cannot be less than start.");
+        }
+        headers.set("Range", `bytes=${start}-${end}`);
+      }
+    }
+    if (this.apiKey) {
+      headers.set("Authorization", `Bearer ${this.apiKey}`);
+    }
+    if (params.micropayment) {
+      const bytes = params.micropayment.bcsToBytes();
+      const binaryString = Array.from(
+        bytes,
+        (byte) => String.fromCharCode(byte)
+      ).join("");
+      headers.set(MICROPAYMENT_HEADER, btoa(binaryString));
+    }
+    const response = await fetch(url, { headers });
+    if (response.status === 409) {
+      let json;
+      try {
+        json = await response.json();
+      } catch {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
+      }
+      const parseResult = StaleMicropaymentErrorResponseSchema.safeParse(json);
+      if (!parseResult.success) {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
+      }
+      const errorBody = parseResult.data;
+      if (errorBody.storedMicropayment) {
+        throw StaleChannelStateError.fromBase64(
+          errorBody.storedMicropayment,
+          errorBody.error
+        );
+      }
+      throw new Error(
+        errorBody.error ?? `Failed to download blob: ${response.status} ${response.statusText}`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download blob: ${response.status} ${response.statusText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    if (contentLengthHeader === null) {
+      throw new Error(
+        "Response did not have content-length header, which is required"
+      );
+    }
+    const expectedContentLength = Number.parseInt(contentLengthHeader, 10);
+    if (Number.isNaN(expectedContentLength)) {
+      throw new Error(
+        `Invalid content-length header received: ${contentLengthHeader}`
+      );
+    }
+    const validatingStream = new ReadableStream({
+      start(controller) {
+        const maybeReader = response.body?.getReader();
+        if (!maybeReader) {
+          controller.error(new Error("Response body reader is unavailable"));
+          return;
+        }
+        const reader = maybeReader;
+        let bytesReceived = 0;
+        function pump() {
+          return reader.read().then(({ done, value }) => {
+            if (done) {
+              if (bytesReceived !== expectedContentLength) {
+                controller.error(
+                  new Error(
+                    `Downloaded data size (${bytesReceived} bytes) does not match content-length header (${expectedContentLength} bytes). This might indicate a partial or corrupted download.`
+                  )
+                );
+                return;
+              }
+              controller.close();
+              return;
+            }
+            bytesReceived += value.byteLength;
+            controller.enqueue(value);
+            return pump();
+          }).catch((error) => {
+            controller.error(error);
+          });
+        }
+        return pump();
+      }
+    });
+    return {
+      account: normalizeAddress(params.account),
+      name: params.blobName,
+      readable: validatingStream,
+      contentLength: expectedContentLength
+    };
+  }
+};
 export {
   ShelbyRPCClient
 };