@shelby-protocol/sdk 0.0.9 → 0.2.0

package/dist/{chunk-ZPW742E7.mjs → chunk-AUQDI5BS.mjs}

@@ -1,6 +1,7 @@
 // src/core/erasure/constants.ts
 var ErasureCodingScheme = /* @__PURE__ */ ((ErasureCodingScheme2) => {
   ErasureCodingScheme2["ClayCode_16Total_10Data_13Helper"] = "ClayCode_16Total_10Data_13Helper";
+  ErasureCodingScheme2["ClayCode_4Total_2Data_3Helper"] = "ClayCode_4Total_2Data_3Helper";
   return ErasureCodingScheme2;
 })(ErasureCodingScheme || {});
 var ERASURE_CODE_PARAMS = {
@@ -10,13 +11,26 @@ var ERASURE_CODE_PARAMS = {
     // data chunks
     erasure_k: 10,
     // helper nodes
-    erasure_d: 13
+    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
   }
 };
 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;
+var DEFAULT_SAMPLE_SIZE = 1024;
 
 export {
   ErasureCodingScheme,
@@ -24,5 +38,6 @@ export {
   DEFAULT_ERASURE_N,
   DEFAULT_ERASURE_K,
   DEFAULT_ERASURE_D,
-  DEFAULT_ERASURE_M
+  DEFAULT_ERASURE_M,
+  DEFAULT_SAMPLE_SIZE
 };

package/dist/{chunk-HFGEQP5N.mjs → chunk-CGYJLKBU.mjs}

@@ -1,12 +1,12 @@
 import {
   getSdk
-} from "./chunk-WJKSPJSS.mjs";
+} from "./chunk-KJ24NKPH.mjs";
 import {
   getAptosConfig
-} from "./chunk-RBFWGDMY.mjs";
+} from "./chunk-AABBONAF.mjs";
 import {
   NetworkToShelbyBlobIndexerBaseUrl
-} from "./chunk-SEXQTDX6.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
 
 // src/core/operations/index.ts
 import { Network } from "@aptos-labs/ts-sdk";
@@ -16,7 +16,7 @@ function createShelbyIndexerClient(baseUrl, options) {
   return getSdk(graphqlClient);
 }
 function getShelbyIndexerClient(config) {
-  const aptosConfig = config.aptos ?? getAptosConfig(config);
+  const aptosConfig = getAptosConfig(config);
   let { apiKey: indexerApiKey, baseUrl } = config.indexer ?? {};
   if (!baseUrl) {
     switch (aptosConfig?.network) {

package/dist/chunk-CQ6QPIZK.mjs

@@ -0,0 +1,37 @@
+// src/core/errors.ts
+var ShelbyErrorCodes = {
+  // blob_metadata.move errors
+  E_BLOB_NOT_FOUND: "E_BLOB_NOT_FOUND",
+  E_INVALID_EXPIRATION_TIME: "E_INVALID_EXPIRATION_TIME",
+  E_TEST_ENCODING_NOT_ALLOWED: "E_TEST_ENCODING_NOT_ALLOWED",
+  E_BLOB_NOT_EXPIRED: "E_BLOB_NOT_EXPIRED",
+  E_INVALID_CHUNKSET_COUNT: "E_INVALID_CHUNKSET_COUNT",
+  E_NOT_BLOB_OWNER: "E_NOT_BLOB_OWNER",
+  E_NOT_ADMIN: "E_NOT_ADMIN",
+  E_BLOB_EXPIRED: "E_BLOB_EXPIRED",
+  E_BLOB_NAME_TOO_LONG: "E_BLOB_NAME_TOO_LONG",
+  E_INVALID_PAYMENT_EPOCHS: "E_INVALID_PAYMENT_EPOCHS",
+  E_NO_SLICES_AVAILABLE: "E_NO_SLICES_AVAILABLE",
+  // Common Aptos/Move errors
+  EALREADY_EXISTS: "EALREADY_EXISTS"
+};
+function isBlobAlreadyExistsError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.EALREADY_EXISTS) || errorMessage.includes("already exists");
+}
+function isAccessDeniedError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_NOT_BLOB_OWNER) || errorMessage.includes(ShelbyErrorCodes.E_NOT_ADMIN) || errorMessage.includes("ENOT_AUTHORIZED") || errorMessage.includes("not authorized") || errorMessage.includes("permission denied");
+}
+function isBlobNotFoundError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_BLOB_NOT_FOUND);
+}
+function isBlobExpiredError(errorMessage) {
+  return errorMessage.includes(ShelbyErrorCodes.E_BLOB_EXPIRED);
+}
+
+export {
+  ShelbyErrorCodes,
+  isBlobAlreadyExistsError,
+  isAccessDeniedError,
+  isBlobNotFoundError,
+  isBlobExpiredError
+};

package/dist/{chunk-VRLIOKWG.mjs → chunk-D6GQHO6G.mjs}

@@ -1,6 +1,10 @@
 // src/core/networks.ts
 import { Network } from "@aptos-labs/ts-sdk";
-var shelbyNetworks = [Network.LOCAL, Network.SHELBYNET];
+var shelbyNetworks = [
+  Network.LOCAL,
+  Network.TESTNET,
+  Network.SHELBYNET
+];
 var isShelbyNetwork = (network) => {
   return shelbyNetworks.includes(network.toLowerCase());
 };

package/dist/chunk-E5QCRTBU.mjs

@@ -0,0 +1,493 @@
+import {
+  SenderBuiltMicropayment
+} from "./chunk-4MG4XGY4.mjs";
+import {
+  getShelbyIndexerClient
+} from "./chunk-CGYJLKBU.mjs";
+import {
+  getAptosConfig
+} from "./chunk-AABBONAF.mjs";
+import {
+  MICROPAYMENTS_DEPLOYER
+} from "./chunk-4ZOFT75Q.mjs";
+
+// src/core/clients/ShelbyMicropaymentChannelClient.ts
+import {
+  AccountAddress,
+  Aptos
+} from "@aptos-labs/ts-sdk";
+var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
+  aptos;
+  deployer;
+  indexer;
+  /**
+   * The ShelbyMicropaymentChannelClient is used to interact with the Micropayment contract on the Aptos blockchain. This
+   * includes functions for the full lifecycle of micropayment channels: creation, withdrawals, expiration extensions, etc.
+   *
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
+   *
+   * @example
+   * ```typescript
+   * const client = new ShelbyMicropaymentChannelClient({
+   *   aptos: {
+   *     network: Network.SHELBYNET,
+   *     clientConfig: {
+   *       API_KEY: "AG-***",
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.aptos = new Aptos(getAptosConfig(config));
+    this.deployer = config.deployer ?? AccountAddress.fromString(MICROPAYMENTS_DEPLOYER);
+    this.indexer = getShelbyIndexerClient(config);
+  }
+  /**
+   * Calls initialize function so caller can thereafter create micropayment channels.
+   *
+   * @param params.sender - The account that will be sending funds to various receivers in micropayment channels.
+   * @param params.options - Optional transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   *
+   * const { transaction } = await client.initializePaymentChannels({
+   *   sender: sender,
+   * });
+   * ```
+   */
+  async initializePaymentChannels(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: {
+        function: `${(this.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::initialize_payment_channels`,
+        functionArguments: []
+      },
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a micropayment channel to start a channel bweteen a sender and a receiver for a specific asset.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.sender - The account that will be sending funds.
+   * @param params.receiver - The account that will be receiving funds.
+   * @param params.expirationMicros - The expiration of the micropayment channel.
+   * @param params.depositAmount - The amount of the asset locked to the channel.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.options - Optional transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   *
+   * const { transaction } = await client.createChannel({
+   *   sender: sender,
+   *   receiver: receiver,
+   *   expirationMicros: Date.now() * 1000 + 86400_000_000, // 1 day from now in microseconds
+   *   depositAmount: 0.001,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   * });
+   * ```
+   */
+  async createChannel(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.makeCreateMicropaymentChannelPayload(
+        {
+          deployer: this.deployer,
+          receiver: params.receiver,
+          expirationMicros: params.expirationMicros,
+          depositAmount: params.depositAmount,
+          fungibleAssetAddress: params.fungibleAssetAddress
+        }
+      ),
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a micropayment channel creation payload to start a channel between a sender and a receiver for a specific asset.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.sender - The account that will be sending funds.
+   * @param params.receiver - The account that will be receiving funds.
+   * @param params.expirationMicros - The expiration of the micropayment channel.
+   * @param params.depositAmount - The amount of the asset locked to the channel.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   *
+   * @returns An Aptos transaction payload data object for the create_channel Move function.
+   */
+  static makeCreateMicropaymentChannelPayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::create_channel`,
+      functionArguments: [
+        params.receiver,
+        params.expirationMicros,
+        params.depositAmount,
+        params.fungibleAssetAddress
+      ]
+    };
+  }
+  /**
+   * Withdraws funds from a micropayment channel as the sender.
+   *
+   * @param params.sender - The account that is withdrawing funds.
+   * @param params.receiver - The account the channel is configured to send funds to.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.senderWithdraw({
+   *   sender: sender,
+   *   receiver: receiver,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   * });
+   * ```
+   */
+  async senderWithdraw(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.createSenderWithdrawPayload({
+        deployer: this.deployer,
+        receiver: params.receiver,
+        fungibleAssetAddress: params.fungibleAssetAddress
+      }),
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a static payload for the sender_withdraw Move function.
+   * This is a helper method for constructing the transaction payload without signing.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.receiver - The account address of the receiver.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   *
+   * @returns An Aptos transaction payload data object for the sender_withdraw Move function.
+   */
+  static createSenderWithdrawPayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::sender_withdraw`,
+      functionArguments: [params.receiver, params.fungibleAssetAddress]
+    };
+  }
+  /**
+   * Creates a micropayment that can be sent to a receiver.
+   *
+   * @param params.sender - The account address of the sender.
+   * @param params.receiver - The account that is withdrawing funds.
+   * @param params.amount - The amount to withdraw into the receiver's account.
+   * @param params.paymentChannelId - The id of the payment channel.
+   * @param params.sequenceNumber - The sequence number of the micropayment. These must be increasing to be able to store on chain.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction and signature.
+   *
+   * @example
+   * ```typescript
+   * const senderBuiltMicropayment = await client.createMicropayment({
+   *   sender: senderAddress,
+   *   receiver: receiver,
+   *   amount: 1,
+   *   paymentChannelId: channelIdFromLookup,
+   *   sequenceNumber: localSequenceNumber,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   * });
+   * ```
+   */
+  async createMicropayment(params) {
+    const replayProtectionNonce = params.options?.replayProtectionNonce ?? Math.floor(Math.random() * 2 ** 24);
+    const {
+      accountSequenceNumber: _unusedSequenceNumber,
+      expireTimestamp: _unusedTimestamp,
+      ...restOptions
+    } = params.options ?? {};
+    const micropayment = await this.aptos.transaction.build.multiAgent({
+      options: {
+        ...restOptions,
+        replayProtectionNonce,
+        expireTimestamp: Math.floor(Date.now() / 1e3 + 60)
+        // 60 seconds from now
+      },
+      withFeePayer: true,
+      data: _ShelbyMicropaymentChannelClient.createMicropaymentTransactionPayload(
+        {
+          deployer: this.deployer,
+          amount: params.amount,
+          paymentChannelId: params.paymentChannelId,
+          sequenceNumber: params.sequenceNumber,
+          fungibleAssetAddress: params.fungibleAssetAddress
+        }
+      ),
+      sender: params.sender.accountAddress,
+      secondarySignerAddresses: [params.receiver]
+    });
+    return new SenderBuiltMicropayment(
+      micropayment,
+      this.aptos.sign({
+        signer: params.sender,
+        transaction: micropayment
+      })
+    );
+  }
+  /**
+   * Creates a static payload for the receiver_withdraw Move function. This is what
+   * constitutes a miropaymet.
+   * This is a helper method for constructing the transaction payload without signing.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.amount - The amount of the fungible asset's smallest increment to send.
+   * @param params.paymentChannelId - The payment channel id.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   *
+   * @returns An Aptos transaction payload data object for the sender_withdraw Move function.
+   */
+  static createMicropaymentTransactionPayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::receiver_withdraw`,
+      functionArguments: [
+        params.amount,
+        params.paymentChannelId,
+        params.sequenceNumber,
+        params.fungibleAssetAddress
+      ]
+    };
+  }
+  /**
+   * Withdraws funds from a micropayment channel as the receiver. The receiver
+   * does this by signing and submitting a signed transaction the sender sent it.
+   *
+   * @param params.receiver - The receiver withdrawing funds.
+   * @param params.receiverSignature - The fee-paying transaction signature.
+   * @param params.micropayment - The fee-paying transaction signature.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.receiverWithdraw({
+   *   receiver: receiver,
+   *   micropayment,
+   *   senderSignature,
+   * });
+   * ```
+   */
+  async receiverWithdraw(params) {
+    const mySignature = this.aptos.signAsFeePayer({
+      signer: params.receiver,
+      transaction: params.micropayment.micropayment
+    });
+    return {
+      transaction: await this.aptos.transaction.submit.multiAgent({
+        transaction: params.micropayment.micropayment,
+        senderAuthenticator: params.micropayment.senderSignature,
+        additionalSignersAuthenticators: [mySignature],
+        feePayerAuthenticator: mySignature
+      })
+    };
+  }
+  /**
+   * Extends the expiration time of a micropayment channel.
+   *
+   * @param params.sender - The owner of the account.
+   * @param params.receiver - The account address of the receiver.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.newExpirationMicros - The new expiration time in microseconds.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.extendExpirationTime({
+   *   sender: sender,
+   *   receiver: receiverAddress,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   *   newExpirationMicros: Date.now() * 1000 + 172800_000_000, // 2 days from now
+   * });
+   * ```
+   */
+  async extendExpirationTime(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.makeExtendExpirationTimePayload({
+        deployer: this.deployer,
+        receiver: params.receiver,
+        fungibleAssetAddress: params.fungibleAssetAddress,
+        newExpirationMicros: params.newExpirationMicros
+      }),
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a payload to extend the expiration time on a micropayment channel.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.receiver - The account that will be receiving funds.
+   * @param params.expirationMicros - The new expiration of the micropayment channel.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   *
+   * @returns An Aptos transaction payload data object for the extend_expiration_time Move function.
+   */
+  static makeExtendExpirationTimePayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::extend_expiration_time`,
+      functionArguments: [
+        params.receiver,
+        params.fungibleAssetAddress,
+        params.newExpirationMicros
+      ]
+    };
+  }
+  /**
+   * Increases the deposit amount locked in a micropayment channel.
+   *
+   * @param params.sender - The account that is increasing the deposit.
+   * @param params.receiver - The account address of the receiver.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.additionalAmount - The additional amount to deposit.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.increaseDepositAmount({
+   *   sender: sender,
+   *   receiver: receiverAddress,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   *   additionalAmount: 500,
+   * });
+   * ```
+   */
+  async increaseDepositAmount(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.makeIncreaseDepositAmountPayload({
+        deployer: this.deployer,
+        receiver: params.receiver,
+        fungibleAssetAddress: params.fungibleAssetAddress,
+        additionalAmount: params.additionalAmount
+      }),
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a payload to increase the deposit amount on a micropayment channel.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.receiver - The account that will be receiving funds.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.additionalAmount - The amount of the fungible asset to add to the channel's balance.
+   *
+   * @returns An Aptos transaction payload data object for the extend_expiration_time Move function.
+   */
+  static makeIncreaseDepositAmountPayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::increase_deposit_amount`,
+      functionArguments: [
+        params.receiver,
+        params.fungibleAssetAddress,
+        params.additionalAmount
+      ]
+    };
+  }
+  /**
+   * Retrieves the vector of channels owned by the sender, optionally
+   * filtered by the receiver.
+   *
+   * @param params.sender - The account namespace owning the micropayment channels.
+   * @param params.receiver? - An optional receiver account address.
+   * @returns A vector of ChannelInfo objects.
+   *
+   * @example
+   * ```typescript
+   * const channelInfoVec = await client.getChannelInfo({
+   *   sender: AccountAddress.fromString("0x1"),
+   *   receiver: AccountAddress.fromSTring("0x2"),
+   * });
+   * ```
+   */
+  async getChannelInfo(params) {
+    const functionName = params.receiver ? "get_all_channels_from_sender_to_receiver" : "get_all_channels_from_sender";
+    const functionArguments = [params.sender];
+    if (params.receiver) {
+      functionArguments.push(params.receiver);
+    }
+    const rawArray = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::micropayments::${functionName}`,
+        functionArguments
+      }
+    });
+    const channelInfoArray = rawArray[0];
+    return channelInfoArray.map(
+      (channelInfo) => {
+        return {
+          sender: params.sender,
+          receiver: params.receiver,
+          fungibleAssetAddress: AccountAddress.fromString(
+            channelInfo.asset_metadata.inner
+          ),
+          balance: Number(channelInfo.balance),
+          creationMicros: Number(channelInfo.creation_micros),
+          expirationMicros: Number(channelInfo.expiration_micros),
+          nextWithdrawnSequenceNumber: Number(
+            channelInfo.next_withdrawn_sequence_number
+          ),
+          paymentChannelId: Number(channelInfo.payment_channel_id),
+          receiverWithdrawnAmount: Number(
+            channelInfo.receiver_withdrawn_amount
+          )
+        };
+      }
+    );
+  }
+};
+
+export {
+  ShelbyMicropaymentChannelClient
+};

package/dist/chunk-HPPMI7DC.mjs

@@ -0,0 +1,56 @@
+import {
+  ClayErasureCodingProvider
+} from "./chunk-OGKZ575S.mjs";
+import {
+  DEFAULT_CHUNK_SIZE_BYTES
+} from "./chunk-JTXYKO3U.mjs";
+import {
+  ERASURE_CODE_PARAMS
+} from "./chunk-AUQDI5BS.mjs";
+
+// src/core/erasure/default.ts
+var defaultProviderPromise;
+function createDefaultErasureCodingProvider() {
+  if (!defaultProviderPromise) {
+    defaultProviderPromise = ClayErasureCodingProvider.create(
+      defaultErasureCodingConfig()
+    );
+  }
+  return defaultProviderPromise;
+}
+function defaultErasureCodingConfig() {
+  console.log(
+    `default erasure coding, with env: ${process.env.SHELBY_ENCODING}`
+  );
+  const encoding = Number(process.env.SHELBY_ENCODING) || 0;
+  if (encoding === 0) {
+    console.log("getting default erasure coding (16,10,13)");
+    return erasureCodingConfig16Total10Data13Helper();
+  }
+  console.log("getting default erasure coding (4,2,3)");
+  return erasureCodingConfig4Total2Data3Helper();
+}
+function erasureCodingConfig16Total10Data13Helper() {
+  return erasureCodingConfig(
+    "ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */
+  );
+}
+function erasureCodingConfig4Total2Data3Helper() {
+  return erasureCodingConfig("ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */);
+}
+function erasureCodingConfig(encodingScheme) {
+  return {
+    erasure_n: ERASURE_CODE_PARAMS[encodingScheme].erasure_n,
+    erasure_k: ERASURE_CODE_PARAMS[encodingScheme].erasure_k,
+    erasure_d: ERASURE_CODE_PARAMS[encodingScheme].erasure_d,
+    chunkSizeBytes: DEFAULT_CHUNK_SIZE_BYTES,
+    enumIndex: ERASURE_CODE_PARAMS[encodingScheme].enumIndex
+  };
+}
+
+export {
+  createDefaultErasureCodingProvider,
+  defaultErasureCodingConfig,
+  erasureCodingConfig16Total10Data13Helper,
+  erasureCodingConfig4Total2Data3Helper
+};

package/dist/chunk-IE6LYVIA.mjs

@@ -0,0 +1,26 @@
+// src/core/rpc-responses.ts
+import { z } from "zod";
+var StartMultipartUploadResponseSchema = z.object({
+  uploadId: z.string()
+});
+var UploadPartResponseSchema = z.object({
+  success: z.literal(true)
+});
+var CompleteMultipartUploadResponseSchema = z.object({
+  success: z.literal(true)
+});
+var RPCErrorResponseSchema = z.object({
+  error: z.string()
+});
+var StaleMicropaymentErrorResponseSchema = z.object({
+  error: z.string().optional(),
+  storedMicropayment: z.string().optional()
+});
+
+export {
+  StartMultipartUploadResponseSchema,
+  UploadPartResponseSchema,
+  CompleteMultipartUploadResponseSchema,
+  RPCErrorResponseSchema,
+  StaleMicropaymentErrorResponseSchema
+};