@shelby-protocol/sdk 0.3.0 → 0.4.0

package/dist/core/sp/sp_write_client.mjs

@@ -0,0 +1,302 @@
+// src/core/sp/sp_write_client.ts
+import * as net from "net";
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+
+// src/gen/rpc_server_pb.ts
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+var file_rpc_server = /* @__PURE__ */ fileDesc("ChBycGNfc2VydmVyLnByb3RvEgNjYXYiGgoHUGF5bWVudBIPCgdwYXltZW50GAEgASgMIhkKCVByb29mTm9kZRIMCgRoYXNoGAEgASgMIiwKBVByb29mEiMKC3Byb29mX25vZGVzGAEgAygLMg4uY2F2LlByb29mTm9kZSJFCghDaHVua0tleRIQCghibG9iX3VpZBgBIAEoBBIUCgxjaHVua3NldF9pZHgYAiABKA0SEQoJY2h1bmtfaWR4GAMgASgNIk8KC1JlYWRSZXF1ZXN0EiEKCmlkZW50aWZpZXIYASABKAsyDS5jYXYuQ2h1bmtLZXkSHQoHcGF5bWVudBgCIAEoCzIMLmNhdi5QYXltZW50InEKGUNsYXlIZWxwZXJEYXRhUmVhZFJlcXVlc3QSIQoKaWRlbnRpZmllchgBIAEoCzINLmNhdi5DaHVua0tleRIYChB0YXJnZXRfY2h1bmtfaWR4GAIgASgNEhcKD2hlbHBlcl9zZXRfbWFzaxgDIAEoBCJgCgxXcml0ZVJlcXVlc3QSIQoKaWRlbnRpZmllchgBIAEoCzINLmNhdi5DaHVua0tleRIMCgRib2R5GAIgASgMEhkKBXByb29mGAMgASgLMgouY2F2LlByb29mSgQIBBAFIsQBCgdSZXF1ZXN0EiQKCHJlYWRfcmVxGAEgASgLMhAuY2F2LlJlYWRSZXF1ZXN0SAASJgoJd3JpdGVfcmVxGAIgASgLMhEuY2F2LldyaXRlUmVxdWVzdEgAEjkKD2hlbHBlcl9yZWFkX3JlcRgFIAEoCzIeLmNhdi5DbGF5SGVscGVyRGF0YVJlYWRSZXF1ZXN0SAASEgoKcmVxdWVzdF9pZBgDIAEoBBIRCglzaWduYXR1cmUYBCABKAxCCQoHcmVxdWVzdCJXCgxSZWFkUmVzcG9uc2USDAoEYm9keRgBIAEoDBIZCgVwcm9vZhgCIAEoCzIKLmNhdi5Qcm9vZhIeChZoZWxwZXJfY2h1bmtfcm9vdF9oYXNoGAMgASgMIk0KDVdyaXRlUmVzcG9uc2USGgoSYmxvYl9hY2tfc2lnbmF0dXJlGAIgASgMEiAKGG1pc3NpbmdfY2h1bmtzZXRfaW5kaWNlcxgDIAMoDSKWAQoIUmVzcG9uc2USEgoKcmVxdWVzdF9pZBgBIAEoBBISCgplcnJvcl9jb2RlGAIgASgEEiYKCXJlYWRfcmVzcBgDIAEoCzIRLmNhdi5SZWFkUmVzcG9uc2VIABIoCgp3cml0ZV9yZXNwGAQgASgLMhIuY2F2LldyaXRlUmVzcG9uc2VIAEIKCghyZXNwb25zZUoECAUQBmIGcHJvdG8z");
+var ProofNodeSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 1);
+var ProofSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 2);
+var ChunkKeySchema = /* @__PURE__ */ messageDesc(file_rpc_server, 3);
+var ReadRequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 4);
+var WriteRequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 6);
+var RequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 7);
+var ResponseSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 10);
+
+// src/core/sp/chunk_proof.ts
+import { createHash } from "crypto";
+
+// src/core/utils.ts
+import {
+  AccountAddress,
+  Hex
+} from "@aptos-labs/ts-sdk";
+
+// src/core/sp/chunk_proof.ts
+var SP_WRITE_SUCCESS_ERROR_CODE = 1n;
+
+// src/core/sp/sp_write_client.ts
+var SP_CLIENT_LOG = process.env.SHELBY_SP_CLIENT_LOG === "1";
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_CONNECTIONS = 4;
+var SpWriteClient = class {
+  constructor(host, port, numConnections = DEFAULT_CONNECTIONS, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    this.host = host;
+    this.port = port;
+    this.numConnections = numConnections;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  connections = [];
+  nextConnectionIdx = 0;
+  nextRequestId = 1n;
+  connected = false;
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    const connectPromises = [];
+    for (let i = 0; i < this.numConnections; i++) {
+      connectPromises.push(this.createConnection());
+    }
+    await Promise.all(connectPromises);
+    this.connected = true;
+  }
+  createConnection() {
+    return new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      let settled = false;
+      const state = {
+        socket,
+        responseBuffer: Buffer.alloc(0),
+        expectedSize: null,
+        pending: /* @__PURE__ */ new Map(),
+        writeQueue: [],
+        draining: false,
+        closed: false
+      };
+      socket.on("connect", () => {
+        this.connections.push(state);
+        settled = true;
+        resolve();
+      });
+      socket.on("data", (data) => {
+        this.handleData(state, data);
+      });
+      socket.on("error", (err) => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket error ${this.host}:${this.port}: ${err.message}`
+          );
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
+        this.handleDisconnect(state, err);
+      });
+      socket.on("close", (hadError) => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket closed ${this.host}:${this.port} (hadError=${hadError})`
+          );
+        this.handleDisconnect(state, new Error("SP connection closed"));
+      });
+      socket.on("timeout", () => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket idle timeout ${this.host}:${this.port} after ${this.requestTimeoutMs}ms`
+          );
+        socket.destroy(new Error("SP connection timed out"));
+      });
+      socket.connect(this.port, this.host);
+    });
+  }
+  handleData(state, data) {
+    state.responseBuffer = Buffer.concat([state.responseBuffer, data]);
+    while (true) {
+      if (state.expectedSize === null) {
+        if (state.responseBuffer.length < 8) {
+          return;
+        }
+        state.expectedSize = Number(state.responseBuffer.readBigUInt64LE(0));
+      }
+      const totalNeeded = 8 + state.expectedSize;
+      if (state.responseBuffer.length < totalNeeded) {
+        return;
+      }
+      const responseBytes = state.responseBuffer.subarray(8, totalNeeded);
+      state.responseBuffer = state.responseBuffer.subarray(totalNeeded);
+      state.expectedSize = null;
+      try {
+        const response = fromBinary(ResponseSchema, responseBytes);
+        const pending = state.pending.get(response.requestId);
+        if (pending) {
+          clearTimeout(pending.timeoutId);
+          state.pending.delete(response.requestId);
+          const success = response.errorCode === SP_WRITE_SUCCESS_ERROR_CODE;
+          if (pending.resolver.kind === "write") {
+            const blobAckSignature = response.response.case === "writeResp" ? response.response.value.blobAckSignature : new Uint8Array(0);
+            pending.resolver.resolve({
+              success,
+              errorCode: response.errorCode,
+              blobAckSignature
+            });
+          } else {
+            const body = response.response.case === "readResp" ? response.response.value.body : new Uint8Array(0);
+            pending.resolver.resolve({
+              success,
+              errorCode: response.errorCode,
+              bytesRead: body.byteLength
+            });
+          }
+        }
+      } catch (error) {
+        for (const [, pending] of state.pending) {
+          clearTimeout(pending.timeoutId);
+          pending.reject(
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+        state.pending.clear();
+      }
+    }
+  }
+  handleDisconnect(state, error) {
+    if (state.closed) {
+      return;
+    }
+    state.closed = true;
+    for (const [, pending] of state.pending) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(error);
+    }
+    state.pending.clear();
+    const idx = this.connections.indexOf(state);
+    if (idx !== -1) {
+      this.connections.splice(idx, 1);
+    }
+  }
+  drainConnection(state) {
+    if (state.draining || state.writeQueue.length === 0 || state.closed) {
+      return;
+    }
+    state.draining = true;
+    const frame = state.writeQueue.shift();
+    const canContinue = state.socket.write(frame, () => {
+      state.draining = false;
+      this.drainConnection(state);
+    });
+    if (!canContinue) {
+      state.socket.once("drain", () => {
+        state.draining = false;
+        this.drainConnection(state);
+      });
+    } else {
+      state.draining = false;
+      this.drainConnection(state);
+    }
+  }
+  selectConnection() {
+    if (this.connections.length === 0) {
+      throw new Error("Not connected to SP");
+    }
+    for (let i = 0; i < this.connections.length; i++) {
+      const idx = (this.nextConnectionIdx + i) % this.connections.length;
+      const conn = this.connections[idx];
+      if (!conn.closed) {
+        this.nextConnectionIdx = (idx + 1) % this.connections.length;
+        return conn;
+      }
+    }
+    throw new Error("No available SP connections");
+  }
+  async writeChunk(params) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const conn = this.selectConnection();
+    const requestId = this.nextRequestId++;
+    const chunkKey = create(ChunkKeySchema, {
+      blobUid: params.blobUid,
+      chunksetIdx: params.chunksetIdx,
+      chunkIdx: params.chunkIdx
+    });
+    const proofNodes = [];
+    for (let i = 0; i < params.proof.length; i += 32) {
+      proofNodes.push(
+        create(ProofNodeSchema, {
+          hash: params.proof.slice(i, i + 32)
+        })
+      );
+    }
+    const request = create(RequestSchema, {
+      request: {
+        case: "writeReq",
+        value: create(WriteRequestSchema, {
+          identifier: chunkKey,
+          body: params.chunkData,
+          proof: create(ProofSchema, { proofNodes })
+        })
+      },
+      requestId,
+      signature: new Uint8Array(64)
+    });
+    const requestBytes = toBinary(RequestSchema, request);
+    const lengthBuffer = Buffer.alloc(8);
+    lengthBuffer.writeBigUInt64LE(BigInt(requestBytes.length), 0);
+    const frame = Buffer.concat([lengthBuffer, Buffer.from(requestBytes)]);
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`SP write request ${requestId} timed out`));
+      }, this.requestTimeoutMs);
+      conn.pending.set(requestId, {
+        resolver: { kind: "write", resolve },
+        reject,
+        timeoutId
+      });
+      conn.writeQueue.push(frame);
+      this.drainConnection(conn);
+    });
+  }
+  async readChunk(params) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const conn = this.selectConnection();
+    const requestId = this.nextRequestId++;
+    const chunkKey = create(ChunkKeySchema, {
+      blobUid: params.blobUid,
+      chunksetIdx: params.chunksetIdx,
+      chunkIdx: params.chunkIdx
+    });
+    const request = create(RequestSchema, {
+      request: {
+        case: "readReq",
+        value: create(ReadRequestSchema, {
+          identifier: chunkKey
+        })
+      },
+      requestId,
+      signature: new Uint8Array(64)
+    });
+    const requestBytes = toBinary(RequestSchema, request);
+    const lengthBuffer = Buffer.alloc(8);
+    lengthBuffer.writeBigUInt64LE(BigInt(requestBytes.length), 0);
+    const frame = Buffer.concat([lengthBuffer, Buffer.from(requestBytes)]);
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`SP read request ${requestId} timed out`));
+      }, this.requestTimeoutMs);
+      conn.pending.set(requestId, {
+        resolver: { kind: "read", resolve },
+        reject,
+        timeoutId
+      });
+      conn.writeQueue.push(frame);
+      this.drainConnection(conn);
+    });
+  }
+  // biome-ignore lint/suspicious/useAwait: callers rely on Promise return
+  async close() {
+    this.connected = false;
+    for (const conn of this.connections) {
+      conn.closed = true;
+      conn.socket.destroy();
+    }
+    this.connections = [];
+  }
+};
+export {
+  SpWriteClient
+};

package/dist/core/strings.mjs

@@ -1,5 +1,3 @@
-import "../chunk-7P6ASYW6.mjs";
-
 // src/core/strings.ts
 var ciEquals = (a, b) => {
   return a.toLowerCase() === b.toLowerCase();

package/dist/core/types/blobs.d.ts

@@ -21,12 +21,25 @@ type ClayEncoding = Required<ClayProviderOptions & {
  * @link https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/common_types.move#L32
  */
 type BlobEncoding = ClayEncoding;
+/**
+ * The encryption scheme a blob's contents were registered with. Mirrors the
+ * on-chain `blob_metadata::EncryptionScheme` variants.
+ */
+type BlobEncryption = "Unencrypted" | "AES_GCM_V1";
+type BlobEncryptionMoveEnumIndex = 0 | 1;
+declare function blobEncryptionToMoveEnumIndex(encryption: BlobEncryption): BlobEncryptionMoveEnumIndex;
+declare function blobEncryptionFromMoveVariant(variant: string): BlobEncryption;
 /**
  * The metadata of a blob that describes the blob and its properties.
- *
- * @link https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L185
  */
-interface BlobMetadata {
+interface FullObjectMetadata {
+    /**
+     * The on-chain UID the object name currently resolves to. Populated on both
+     * the view path (`get_full_object_metadata`) and the indexer path (the
+     * committed row's `uid`). Optional only for callers constructing metadata by
+     * hand.
+     */
+    uid?: bigint;
     /**
      * The owner of the blob.
      */
@@ -56,6 +69,12 @@ interface BlobMetadata {
      * The encoding of the blob.
      */
     encoding: BlobEncoding;
+    /**
+     * The encryption scheme the blob was registered with. Present from the
+     * on-chain view path; absent for indexer-sourced metadata, which does not
+     * yet surface it.
+     */
+    encryption?: BlobEncryption;
     /**
      * The expiration timestamp of the blob in microseconds.
      */
@@ -77,7 +96,7 @@ interface BlobMetadata {
      */
     isDeleted?: boolean;
 }
-type BlobActivityType = "register_blob" | "delete_blob" | "extend_blob_expiration" | "write_blob" | "unknown";
+type BlobActivityType = "register_blob" | "delete_blob" | "extend_blob_expiration" | "write_blob" | "commit_object" | "delete_object" | "reject_object_commit" | "unknown";
 /**
  * The activity of a blob.
  */
@@ -129,4 +148,4 @@ interface StorageProviderAck {
     signature: Uint8Array;
 }
 
-export type { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding, StorageProviderAck };
+export { type BlobActivity, type BlobActivityType, type BlobEncoding, type BlobEncryption, type BlobEncryptionMoveEnumIndex, type ClayEncoding, type FullObjectMetadata, type StorageProviderAck, blobEncryptionFromMoveVariant, blobEncryptionToMoveEnumIndex };

package/dist/core/types/blobs.mjs

@@ -1 +1,24 @@
-import "../../chunk-ZHXCVRZX.mjs";
+// src/core/types/blobs.ts
+var BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX = {
+  Unencrypted: 0,
+  AES_GCM_V1: 1
+};
+function blobEncryptionToMoveEnumIndex(encryption) {
+  return BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX[encryption];
+}
+function blobEncryptionFromMoveVariant(variant) {
+  switch (variant) {
+    case "Unencrypted":
+      return "Unencrypted";
+    case "AES_GCM_V1":
+      return "AES_GCM_V1";
+    default:
+      throw new Error(
+        "Could not parse encryption from Shelby Smart Contract, this SDK is out of date."
+      );
+  }
+}
+export {
+  blobEncryptionFromMoveVariant,
+  blobEncryptionToMoveEnumIndex
+};

package/dist/core/types/index.d.ts

@@ -1,7 +1,7 @@
-export { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding, StorageProviderAck } from './blobs.js';
+export { BlobActivity, BlobActivityType, BlobEncoding, BlobEncryption, BlobEncryptionMoveEnumIndex, ClayEncoding, FullObjectMetadata, StorageProviderAck, blobEncryptionFromMoveVariant, blobEncryptionToMoveEnumIndex } from './blobs.js';
 export { ChannelInfo, SenderBuiltMicropayment, StaleChannelStateError } from './payments.js';
 export { PlacementGroupInfo, PlacementGroupSlot, PlacementGroupSlotStatus } from './placement_groups.js';
-export { ActiveStateDetails, FrozenStateDetails, StorageProviderInfo, StorageProviderStateDetails, WaitlistedStateDetails } from './storage_providers.js';
+export { ActiveProviderCondition, ActiveStateDetails, FrozenStateDetails, StorageProviderInfo, StorageProviderStateDetails, WaitlistedStateDetails, isActiveForTasks, isActiveProviderCondition } from './storage_providers.js';
 import '@aptos-labs/ts-sdk';
 import '../../clay-codes-DdXABBDx.js';
 import '@shelby-protocol/clay-codes';

package/dist/core/types/index.mjs

@@ -1,14 +1,279 @@
-import "../../chunk-QQ57OGQ2.mjs";
-import "../../chunk-MQUVYMNQ.mjs";
-import "../../chunk-ZHXCVRZX.mjs";
-import "../../chunk-AD2G3QYD.mjs";
+// src/core/types/blobs.ts
+var BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX = {
+  Unencrypted: 0,
+  AES_GCM_V1: 1
+};
+function blobEncryptionToMoveEnumIndex(encryption) {
+  return BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX[encryption];
+}
+function blobEncryptionFromMoveVariant(variant) {
+  switch (variant) {
+    case "Unencrypted":
+      return "Unencrypted";
+    case "AES_GCM_V1":
+      return "AES_GCM_V1";
+    default:
+      throw new Error(
+        "Could not parse encryption from Shelby Smart Contract, this SDK is out of date."
+      );
+  }
+}
+
+// src/core/types/payments.ts
 import {
-  SenderBuiltMicropayment,
-  StaleChannelStateError
-} from "../../chunk-KG2TMLEV.mjs";
-import "../../chunk-MNCQBEMS.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  AccountAddress,
+  Deserializer,
+  Hex,
+  Serializer
+} 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/types/payments.ts
+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/types/storage_providers.ts
+var ACTIVE_PROVIDER_CONDITIONS = [
+  "Normal",
+  "Faulty",
+  "Leaving",
+  "Evicted",
+  "PendingLeaving"
+];
+function isActiveProviderCondition(value) {
+  return typeof value === "string" && ACTIVE_PROVIDER_CONDITIONS.includes(value);
+}
+var TASK_ELIGIBLE_CONDITIONS = /* @__PURE__ */ new Set([
+  "Normal",
+  "PendingLeaving"
+]);
+function isActiveForTasks(condition) {
+  return TASK_ELIGIBLE_CONDITIONS.has(condition);
+}
 export {
   SenderBuiltMicropayment,
-  StaleChannelStateError
+  StaleChannelStateError,
+  blobEncryptionFromMoveVariant,
+  blobEncryptionToMoveEnumIndex,
+  isActiveForTasks,
+  isActiveProviderCondition
 };