@shelby-protocol/sdk 0.2.0 → 0.2.2

package/dist/{chunk-E5QCRTBU.mjs → chunk-H5YZHUSJ.mjs}

@@ -1,20 +1,24 @@
 import {
   SenderBuiltMicropayment
-} from "./chunk-4MG4XGY4.mjs";
+} from "./chunk-TVLV7C74.mjs";
 import {
   getShelbyIndexerClient
-} from "./chunk-CGYJLKBU.mjs";
+} from "./chunk-EZPZAUIV.mjs";
 import {
   getAptosConfig
 } from "./chunk-AABBONAF.mjs";
+import {
+  normalizeAddress
+} from "./chunk-UEZNZBJO.mjs";
 import {
   MICROPAYMENTS_DEPLOYER
-} from "./chunk-4ZOFT75Q.mjs";
+} from "./chunk-7OV5ZYW6.mjs";
 
 // src/core/clients/ShelbyMicropaymentChannelClient.ts
 import {
   AccountAddress,
-  Aptos
+  Aptos,
+  MoveVector
 } from "@aptos-labs/ts-sdk";
 var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
   aptos;
@@ -110,7 +114,8 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
           receiver: params.receiver,
           expirationMicros: params.expirationMicros,
           depositAmount: params.depositAmount,
-          fungibleAssetAddress: params.fungibleAssetAddress
+          fungibleAssetAddress: params.fungibleAssetAddress,
+          publicKey: params.publicKey ?? params.sender.publicKey.toUint8Array()
         }
       ),
       sender: params.sender.accountAddress
@@ -132,6 +137,7 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
    * @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.publicKey - The Ed25519 public key bytes for the channel.
    *
    * @returns An Aptos transaction payload data object for the create_channel Move function.
    */
@@ -142,7 +148,8 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
         params.receiver,
         params.expirationMicros,
         params.depositAmount,
-        params.fungibleAssetAddress
+        params.fungibleAssetAddress,
+        MoveVector.U8(params.publicKey)
       ]
     };
   }
@@ -200,94 +207,86 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
   }
   /**
    * Creates a micropayment that can be sent to a receiver.
+   * The sender signs a WithdrawApproval message that authorizes the receiver
+   * to withdraw funds from the micropayment channel.
    *
-   * @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.sender - The account that owns the payment channel and signs the approval.
+   * @param params.receiver - The account address that will receive funds.
    * @param params.fungibleAssetAddress - The account address of the fungible asset.
-   * @param params.options - Optional transaction generation options.
+   * @param params.amount - The cumulative amount to authorize (not incremental).
+   * @param params.paymentChannelId - The id of the payment channel.
+   * @param params.sequenceNumber - The sequence number of the micropayment. Must be >= channel's next_withdrawn_sequence_number.
    *
-   * @returns An object containing the pending transaction and signature.
+   * @returns A SenderBuiltMicropayment containing the signed approval.
    *
    * @example
    * ```typescript
-   * const senderBuiltMicropayment = await client.createMicropayment({
-   *   sender: senderAddress,
-   *   receiver: receiver,
-   *   amount: 1,
-   *   paymentChannelId: channelIdFromLookup,
-   *   sequenceNumber: localSequenceNumber,
+   * const senderBuiltMicropayment = client.createMicropayment({
+   *   sender: senderAccount,
+   *   receiver: receiverAddress,
    *   fungibleAssetAddress: fungibleAssetAddress,
+   *   amount: 100,
+   *   paymentChannelId: channelId,
+   *   sequenceNumber: 1,
    * });
    * ```
    */
-  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
-        }
-      ),
+  createMicropayment(params) {
+    const message = SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
       sender: params.sender.accountAddress,
-      secondarySignerAddresses: [params.receiver]
+      receiver: params.receiver,
+      fungibleAssetAddress: params.fungibleAssetAddress,
+      amount: params.amount,
+      paymentChannelId: params.paymentChannelId,
+      sequenceNumber: params.sequenceNumber
     });
+    const signature = params.sender.sign(message);
     return new SenderBuiltMicropayment(
-      micropayment,
-      this.aptos.sign({
-        signer: params.sender,
-        transaction: micropayment
-      })
+      params.sender.accountAddress,
+      params.receiver,
+      BigInt(params.paymentChannelId),
+      BigInt(params.amount),
+      params.fungibleAssetAddress,
+      BigInt(params.sequenceNumber),
+      params.sender.publicKey.toUint8Array(),
+      signature.toUint8Array(),
+      this.deployer
     );
   }
   /**
-   * 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.
+   * Creates a static payload for the receiver_withdraw Move function.
+   * This is a helper method for constructing the transaction payload.
    *
    * @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.sender - The sender's account address.
    * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.amount - The cumulative amount authorized to withdraw.
+   * @param params.paymentChannelId - The payment channel id.
+   * @param params.sequenceNumber - The sequence number for this withdrawal.
+   * @param params.signature - The Ed25519 signature bytes.
    *
-   * @returns An Aptos transaction payload data object for the sender_withdraw Move function.
+   * @returns An Aptos transaction payload data object for the receiver_withdraw Move function.
    */
   static createMicropaymentTransactionPayload(params) {
     return {
       function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::receiver_withdraw`,
       functionArguments: [
+        params.sender,
+        params.fungibleAssetAddress,
         params.amount,
         params.paymentChannelId,
         params.sequenceNumber,
-        params.fungibleAssetAddress
+        MoveVector.U8(params.signature)
       ]
     };
   }
   /**
-   * Withdraws funds from a micropayment channel as the receiver. The receiver
-   * does this by signing and submitting a signed transaction the sender sent it.
+   * Withdraws funds from a micropayment channel as the receiver.
+   * The receiver submits the sender's signed approval to claim funds.
    *
-   * @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.receiver - The receiver account that will sign and submit the transaction.
+   * @param params.micropayment - The sender's signed micropayment approval.
    * @param params.options - Optional transaction generation options.
    *
    * @returns An object containing the pending transaction.
@@ -295,23 +294,31 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
    * @example
    * ```typescript
    * const { transaction } = await client.receiverWithdraw({
-   *   receiver: receiver,
-   *   micropayment,
-   *   senderSignature,
+   *   receiver: receiverAccount,
+   *   micropayment: senderBuiltMicropayment,
    * });
    * ```
    */
   async receiverWithdraw(params) {
-    const mySignature = this.aptos.signAsFeePayer({
-      signer: params.receiver,
-      transaction: params.micropayment.micropayment
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.createMicropaymentTransactionPayload(
+        {
+          deployer: this.deployer,
+          sender: params.micropayment.sender,
+          fungibleAssetAddress: params.micropayment.fungibleAssetAddress,
+          amount: params.micropayment.amount,
+          paymentChannelId: params.micropayment.paymentChannelId,
+          sequenceNumber: params.micropayment.sequenceNumber,
+          signature: params.micropayment.signature
+        }
+      ),
+      sender: params.receiver.accountAddress
     });
     return {
-      transaction: await this.aptos.transaction.submit.multiAgent({
-        transaction: params.micropayment.micropayment,
-        senderAuthenticator: params.micropayment.senderSignature,
-        additionalSignersAuthenticators: [mySignature],
-        feePayerAuthenticator: mySignature
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.receiver,
+        transaction
       })
     };
   }
@@ -447,7 +454,7 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
    * ```typescript
    * const channelInfoVec = await client.getChannelInfo({
    *   sender: AccountAddress.fromString("0x1"),
-   *   receiver: AccountAddress.fromSTring("0x2"),
+   *   receiver: AccountAddress.fromString("0x2"),
    * });
    * ```
    */
@@ -466,10 +473,14 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
     const channelInfoArray = rawArray[0];
     return channelInfoArray.map(
       (channelInfo) => {
+        const publicKeyHex = channelInfo.public_key.startsWith("0x") ? channelInfo.public_key.slice(2) : channelInfo.public_key;
+        const publicKey = new Uint8Array(
+          publicKeyHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) ?? []
+        );
         return {
           sender: params.sender,
           receiver: params.receiver,
-          fungibleAssetAddress: AccountAddress.fromString(
+          fungibleAssetAddress: normalizeAddress(
             channelInfo.asset_metadata.inner
           ),
           balance: Number(channelInfo.balance),
@@ -481,7 +492,8 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
           paymentChannelId: Number(channelInfo.payment_channel_id),
           receiverWithdrawnAmount: Number(
             channelInfo.receiver_withdrawn_amount
-          )
+          ),
+          publicKey
         };
       }
     );

package/dist/{chunk-7PN65RDX.mjs → chunk-ONOOCOQ5.mjs}

@@ -1,34 +1,36 @@
 import {
   ShelbyBlobClient
-} from "./chunk-SRV4YWFH.mjs";
-import {
-  defaultErasureCodingConfig
-} from "./chunk-HPPMI7DC.mjs";
-import {
-  ClayErasureCodingProvider
-} from "./chunk-OGKZ575S.mjs";
+} from "./chunk-PESSW3FK.mjs";
 import {
   ShelbyMetadataClient
-} from "./chunk-MV6FNYAU.mjs";
+} from "./chunk-H53O23I7.mjs";
 import {
   ShelbyRPCClient
-} from "./chunk-PJVWGMVI.mjs";
+} from "./chunk-E5PP7BZJ.mjs";
 import {
   getAptosConfig
 } from "./chunk-AABBONAF.mjs";
+import {
+  defaultErasureCodingConfig
+} from "./chunk-HPPMI7DC.mjs";
+import {
+  ClayErasureCodingProvider
+} from "./chunk-OGKZ575S.mjs";
 import {
   createBlobKey
-} from "./chunk-OTBLZL2S.mjs";
+} from "./chunk-3NRBHSMQ.mjs";
 import {
   generateCommitments
-} from "./chunk-2WEX3K7C.mjs";
+} from "./chunk-BXEVML7N.mjs";
+import {
+  normalizeAddress
+} from "./chunk-UEZNZBJO.mjs";
 import {
   NetworkToShelbyRPCBaseUrl
-} from "./chunk-4ZOFT75Q.mjs";
+} from "./chunk-7OV5ZYW6.mjs";
 
 // src/core/clients/ShelbyClient.ts
 import {
-  AccountAddress,
   Aptos,
   DEFAULT_TXN_TIMEOUT_SEC,
   Network,
@@ -316,7 +318,7 @@ var ShelbyClient = class {
       const response = await fetch(`${faucet}`, {
         method: "POST",
         body: JSON.stringify({
-          address: AccountAddress.from(address).toString(),
+          address: normalizeAddress(address).toString(),
           amount
         }),
         headers: {

package/dist/{chunk-SRV4YWFH.mjs → chunk-PESSW3FK.mjs}

@@ -1,21 +1,22 @@
-import {
-  defaultErasureCodingConfig
-} from "./chunk-HPPMI7DC.mjs";
 import {
   getShelbyIndexerClient
-} from "./chunk-CGYJLKBU.mjs";
+} from "./chunk-EZPZAUIV.mjs";
 import {
   getAptosConfig
 } from "./chunk-AABBONAF.mjs";
+import {
+  defaultErasureCodingConfig
+} from "./chunk-HPPMI7DC.mjs";
 import {
   createBlobKey
-} from "./chunk-OTBLZL2S.mjs";
+} from "./chunk-3NRBHSMQ.mjs";
 import {
   expectedTotalChunksets
-} from "./chunk-2WEX3K7C.mjs";
+} from "./chunk-BXEVML7N.mjs";
 import {
-  getBlobNameSuffix
-} from "./chunk-4JZO2D7T.mjs";
+  getBlobNameSuffix,
+  normalizeAddress
+} from "./chunk-UEZNZBJO.mjs";
 import {
   ERASURE_CODE_AND_CHUNK_MAPPING
 } from "./chunk-JTXYKO3U.mjs";
@@ -24,7 +25,7 @@ import {
 } from "./chunk-AUQDI5BS.mjs";
 import {
   SHELBY_DEPLOYER
-} from "./chunk-4ZOFT75Q.mjs";
+} from "./chunk-7OV5ZYW6.mjs";
 
 // src/core/clients/ShelbyBlobClient.ts
 import {
@@ -174,14 +175,14 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         blobMerkleRoot: Hex.fromHexInput(
           metadata.blob_commitment
         ).toUint8Array(),
-        owner: AccountAddress.fromString(metadata.owner),
+        owner: normalizeAddress(metadata.owner),
         name: params.name,
         blobNameSuffix: getBlobNameSuffix(params.name),
         size: Number(metadata.blob_size),
         encoding,
         expirationMicros: Number(metadata.expiration_micros),
         creationMicros: Number(metadata.creation_micros),
-        sliceAddress: AccountAddress.fromString(metadata.slice.inner),
+        sliceAddress: normalizeAddress(metadata.slice.inner),
         isWritten: metadata.is_written
       };
     } catch (error) {
@@ -214,7 +215,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return this.getBlobs({
       where: {
         ...where,
-        owner: { _eq: AccountAddress.from(params.account).toString() }
+        owner: { _eq: normalizeAddress(params.account).toString() }
       },
       pagination: rest.pagination,
       orderBy: rest.orderBy
@@ -253,7 +254,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     });
     return blobs.map(
       (blob) => ({
-        owner: AccountAddress.from(blob.owner),
+        owner: normalizeAddress(blob.owner),
         name: blob.blob_name,
         blobNameSuffix: getBlobNameSuffix(blob.blob_name),
         blobMerkleRoot: Hex.fromHexInput(blob.blob_commitment).toUint8Array(),
@@ -266,7 +267,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         },
         expirationMicros: Number(blob.expires_at),
         creationMicros: Number(blob.created_at),
-        sliceAddress: AccountAddress.from(blob.slice_address),
+        sliceAddress: normalizeAddress(blob.slice_address),
         isWritten: Boolean(Number(blob.is_written)),
         isDeleted: Boolean(Number(blob.is_deleted))
       })
@@ -290,9 +291,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return blob_activities.map(
       (activity) => ({
         blobName: activity.blob_name,
-        accountAddress: AccountAddress.from(
-          activity.blob_name.substring(1, 65)
-        ),
+        accountAddress: normalizeAddress(activity.blob_name.substring(1, 65)),
         type: activityTypeMapping[activity.event_type] ?? "unknown",
         eventType: activity.event_type,
         eventIndex: Number(activity.event_index),
@@ -725,6 +724,42 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       ]
     };
   }
+  static createBlobAcknowledgementsPayload(params) {
+    const ackBitMask = params.storageProviderAcks.reduce(
+      (acc, ack) => acc | 1 << ack.slot,
+      0
+    );
+    return {
+      function: `${SHELBY_DEPLOYER}::blob_metadata::add_blob_acknowledgements`,
+      functionArguments: [
+        createBlobKey({
+          account: params.blobOwner,
+          blobName: params.blobName
+        }),
+        params.creationMicros,
+        new U32(Number(ackBitMask)),
+        params.storageProviderAcks.map((ack) => ack.signature)
+      ]
+    };
+  }
+  async addBlobAcknowledgements(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      ...params.options?.build,
+      data: _ShelbyBlobClient.createBlobAcknowledgementsPayload({
+        blobOwner: params.blobOwner,
+        blobName: params.blobName,
+        creationMicros: params.creationMicros,
+        storageProviderAcks: params.storageProviderAcks
+      }),
+      sender: params.account.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
+  }
 };
 
 export {

package/dist/chunk-TVLV7C74.mjs

@@ -0,0 +1,207 @@
+import {
+  MICROPAYMENTS_DEPLOYER
+} from "./chunk-7OV5ZYW6.mjs";
+
+// 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
+    );
+  }
+};
+
+export {
+  StaleChannelStateError,
+  SenderBuiltMicropayment
+};