@shelby-protocol/sdk 0.2.4 → 0.3.1

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

@@ -49,6 +49,14 @@ interface ShelbyClientConfig {
         /** Auth token for the faucet endpoint. */
         authToken?: string;
     };
+    /**
+     * When true, all on-chain transactions submitted by this client will use Aptos orderless
+     * transactions (replay protection via a random nonce) instead of the default sequence-number
+     * based transactions. This allows concurrent transaction submission from a single account
+     * without serialization on sequence numbers. A cryptographically random 64-bit nonce is
+     * generated automatically for each transaction.
+     */
+    orderless?: boolean;
 }
 
 export type { ShelbyClientConfig, ShelbyIndexerConfig, ShelbyRPCConfig };

package/dist/core/clients/ShelbyClientConfig.mjs

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

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

@@ -80,24 +80,6 @@ declare class ShelbyMetadataClient {
     getDesignatedStorageProvidersForSlice(params: {
         account: AccountAddressInput;
     }): Promise<(AccountAddress | null)[]>;
-    /**
-     * Retrieves the active storage providers for a slice.
-     *
-     * Active SPs have a complete copy of the data for the slot, and are not in any data transfer/repair/reconstruction phase.
-     * Active SP can be audited for the data it contains.
-     * Each slot has at most one active SP.
-     *
-     * @param params.account - The address of the slice account.
-     * @returns An array where result[i] is the active SP for slot i, or null if no SP is active.
-     *
-     * @example
-     * ```typescript
-     * const providers = await client.getActiveStorageProvidersForSlice({ account: sliceAddress });
-     * ```
-     */
-    getActiveStorageProvidersForSlice(params: {
-        account: AccountAddressInput;
-    }): Promise<(AccountAddress | null)[]>;
     /**
      * Retrieves the serving storage providers for a slice.
      *

package/dist/core/clients/ShelbyMetadataClient.mjs

@@ -1,10 +1,310 @@
+// src/core/clients/ShelbyMetadataClient.ts
 import {
-  ShelbyMetadataClient
-} from "../../chunk-SSE4MFNN.mjs";
-import "../../chunk-IKRWBDG5.mjs";
-import "../../chunk-UEZNZBJO.mjs";
-import "../../chunk-7OV5ZYW6.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  AccountAddress as AccountAddress2,
+  Aptos,
+  Hex as Hex2
+} from "@aptos-labs/ts-sdk";
+
+// src/core/constants.ts
+import { Network } from "@aptos-labs/ts-sdk";
+var NetworkToShelbyRPCBaseUrl = {
+  [Network.SHELBYNET]: "https://api.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 SHELBY_DEPLOYER = "0x85fdb9a176ab8ef1d9d9c1b60d60b3924f0800ac1de1cc2085fb0b8bb4988e6a";
+
+// src/core/utils.ts
+import {
+  AccountAddress,
+  Hex
+} from "@aptos-labs/ts-sdk";
+function normalizeAddress(address) {
+  return AccountAddress.from(address, { maxMissingChars: 63 });
+}
+
+// src/core/clients/utils.ts
+import { AptosConfig } from "@aptos-labs/ts-sdk";
+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
+  });
+};
+
+// src/core/clients/ShelbyMetadataClient.ts
+function parseStorageProviderState(raw) {
+  switch (raw.__variant__) {
+    case "Active":
+      return {
+        variant: "Active",
+        quota: raw.quota.value,
+        stakeAtStartOfStakingEpoch: raw.stake_at_start_of_staking_epoch,
+        faulty: raw.faulty,
+        leaving: raw.leaving
+      };
+    case "Waitlisted":
+      return {
+        variant: "Waitlisted"
+      };
+    case "Frozen":
+      return {
+        variant: "Frozen",
+        frozenReason: raw.frozen_reason,
+        frozenFrom: raw.frozen_from,
+        frozenTill: raw.frozen_till
+      };
+  }
+}
+var ShelbyMetadataClient = class {
+  aptos;
+  deployer;
+  /**
+   * The ShelbyMetadataClient is used to interact with the Shelby contract on the Aptos blockchain. This
+   * includes functions like gathering basic details about the Shelby system, including storage provider information.
+   *
+   * @param config.aptos.config - The Aptos config.
+   * @param config.shelbyDeployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
+   *
+   * @example
+   * ```typescript
+   * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
+   * const metadataClient = new ShelbyMetadataClient({ aptos });
+   * ```
+   */
+  constructor(config) {
+    this.aptos = new Aptos(getAptosConfig(config));
+    this.deployer = config.deployer ?? AccountAddress2.fromString(SHELBY_DEPLOYER);
+  }
+  /**
+   * Retrieves storage provider list from the blockchain.
+   *
+   * @returns A list of storage providers, or empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const spList = await client.getStorageProviders();
+   * ```
+   */
+  async getStorageProviders() {
+    try {
+      const rawMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::storage_provider_registry::get_all_storage_providers`,
+          functionArguments: []
+        }
+      });
+      const metadata = rawMetadata[0];
+      return metadata.map((provider) => ({
+        address: normalizeAddress(provider.address),
+        ipAddress: provider.ip_address,
+        port: provider.port,
+        blsPublicKey: Hex2.fromHexInput(provider.bls_public_key).toUint8Array(),
+        availabilityZone: provider.availability_zone,
+        state: parseStorageProviderState(provider.state)
+      }));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      error.message?.includes("sub_status: Some(404)")) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves the list of placement group addresses.
+   *
+   * @returns The placement group address list, or an empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const pgList = await client.getPlacementGroupAddresses();
+   * ```
+   */
+  async getPlacementGroupAddresses() {
+    try {
+      const pgSizeMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::placement_group_registry::get_number_of_placement_groups`,
+          functionArguments: []
+        }
+      });
+      const finalPlacementGroupIndex = pgSizeMetadata[0] - 1;
+      const addressMetadataArray = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::placement_group_registry::get_placement_group_addresses`,
+          functionArguments: [0, finalPlacementGroupIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((pg) => normalizeAddress(pg));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("E_PLACEMENT_GROUP_NOT_FOUND"))) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves the list of slice addresses.
+   *
+   * @returns The slice group list, or an empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const pgList = await client.getSliceAddresses();
+   * ```
+   */
+  async getSliceAddresses() {
+    try {
+      const sliceSizeMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::slice_registry::get_number_of_slices`,
+          functionArguments: []
+        }
+      });
+      const finalSliceIndex = sliceSizeMetadata[0] - 1;
+      const addressMetadataArray = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::slice_registry::get_slice_addresses`,
+          functionArguments: [0, finalSliceIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((slice) => normalizeAddress(slice));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("E_SLICE_NOT_FOUND"))) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets the placement group address for a slice.
+   *
+   * @param sliceAddress - The address of the slice account.
+   * @returns The placement group address as a string.
+   */
+  async getPlacementGroupAddressForSlice(sliceAddress) {
+    const sliceMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::slice::get_slice_info`,
+        functionArguments: [sliceAddress.toString()]
+      }
+    });
+    return sliceMetadata[0].placement_group_assignments[0].placement_group_address;
+  }
+  /**
+   * Retrieves the designated storage providers for a slice.
+   *
+   * Designated SPs are those appointed to store data for their slots:
+   * - Active: Currently serving data
+   * - Receiving: Receiving data during slot transfer
+   * - Repairing: Repairing data after crash or failed transfer
+   * - Reconstructing: Reconstructing data if the repair fails
+   *
+   * @param params.account - The address of the slice account.
+   * @returns An array where result[i] is the designated SP for slot i, or null if no SP is designated.
+   *
+   * @example
+   * ```typescript
+   * const providers = await client.getDesignatedStorageProvidersForSlice({ account: sliceAddress });
+   * ```
+   */
+  async getDesignatedStorageProvidersForSlice(params) {
+    const placementGroupAddress = await this.getPlacementGroupAddressForSlice(
+      params.account
+    );
+    const rawMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::placement_group::get_designated_storage_providers`,
+        functionArguments: [placementGroupAddress]
+      }
+    });
+    const providers = rawMetadata[0];
+    return providers.map(
+      (opt) => opt.vec.length > 0 ? normalizeAddress(opt.vec[0]) : null
+    );
+  }
+  /**
+   * Retrieves the serving storage providers for a slice.
+   *
+   * Serving SPs are those that can respond to read requests. The serving logic is:
+   * - If an Active SP exists for a slot: Only the Active SP is serving
+   * - If no Active SP (transition in progress): Both Designated and Vacating SPs serve
+   *
+   * Each slot may have multiple serving SPs during transitions.
+   *
+   * @param params.account - The address of the slice account.
+   * @returns An array where result[i] contains the serving SPs for slot i.
+   *
+   * @example
+   * ```typescript
+   * const providers = await client.getServingStorageProvidersForSlice({ account: sliceAddress });
+   * ```
+   */
+  async getServingStorageProvidersForSlice(params) {
+    const placementGroupAddress = await this.getPlacementGroupAddressForSlice(
+      params.account
+    );
+    const rawMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::placement_group::get_serving_storage_providers`,
+        functionArguments: [placementGroupAddress]
+      }
+    });
+    const providers = rawMetadata[0];
+    return providers.map(
+      (slotProviders) => slotProviders.map((addr) => normalizeAddress(addr))
+    );
+  }
+};
 export {
   ShelbyMetadataClient
 };

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

@@ -81,7 +81,7 @@ declare class ShelbyMicropaymentChannelClient {
     createChannel(params: {
         sender: Account;
         receiver: AccountAddress;
-        expirationMicros: number;
+        expirationMicros: number | bigint;
         depositAmount: number;
         fungibleAssetAddress: AccountAddress;
         publicKey?: Uint8Array;
@@ -106,53 +106,11 @@ declare class ShelbyMicropaymentChannelClient {
     static makeCreateMicropaymentChannelPayload(params: {
         deployer?: AccountAddress;
         receiver: AccountAddress;
-        expirationMicros: number;
+        expirationMicros: number | bigint;
         depositAmount: number;
         fungibleAssetAddress: AccountAddress;
         publicKey: Uint8Array;
     }): InputGenerateTransactionPayloadData;
-    /**
-     * 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,
-     * });
-     * ```
-     */
-    senderWithdraw(params: {
-        sender: Account;
-        receiver: AccountAddress;
-        fungibleAssetAddress: AccountAddress;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<{
-        transaction: PendingTransactionResponse;
-    }>;
-    /**
-     * 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: {
-        deployer?: AccountAddress;
-        receiver: AccountAddress;
-        fungibleAssetAddress: AccountAddress;
-    }): InputGenerateTransactionPayloadData;
     /**
      * Creates a micropayment that can be sent to a receiver.
      * The sender signs a WithdrawApproval message that authorizes the receiver
@@ -183,9 +141,9 @@ declare class ShelbyMicropaymentChannelClient {
         sender: Account;
         receiver: AccountAddress;
         fungibleAssetAddress: AccountAddress;
-        amount: number;
-        paymentChannelId: number;
-        sequenceNumber: number;
+        amount: number | bigint;
+        paymentChannelId: number | bigint;
+        sequenceNumber: number | bigint;
     }): SenderBuiltMicropayment;
     /**
      * Creates a static payload for the receiver_withdraw Move function.
@@ -260,7 +218,7 @@ declare class ShelbyMicropaymentChannelClient {
         sender: Account;
         receiver: AccountAddress;
         fungibleAssetAddress: AccountAddress;
-        newExpirationMicros: number;
+        newExpirationMicros: number | bigint;
         options?: InputGenerateTransactionOptions;
     }): Promise<{
         transaction: PendingTransactionResponse;
@@ -280,7 +238,7 @@ declare class ShelbyMicropaymentChannelClient {
         deployer?: AccountAddress;
         receiver: AccountAddress;
         fungibleAssetAddress: AccountAddress;
-        newExpirationMicros: number;
+        newExpirationMicros: number | bigint;
     }): InputGenerateTransactionPayloadData;
     /**
      * Increases the deposit amount locked in a micropayment channel.