@shelby-protocol/sdk 0.3.0 → 0.4.0

package/dist/core/clients/ShelbyMicropaymentChannelClient.mjs

@@ -1,17 +1,898 @@
+// src/core/clients/ShelbyMicropaymentChannelClient.ts
 import {
-  ShelbyMicropaymentChannelClient
-} from "../../chunk-M7W43K2Q.mjs";
-import "../../chunk-QQ57OGQ2.mjs";
-import "../../chunk-MQUVYMNQ.mjs";
-import "../../chunk-ZHXCVRZX.mjs";
-import "../../chunk-AD2G3QYD.mjs";
-import "../../chunk-KG2TMLEV.mjs";
-import "../../chunk-NEO7Z3ZQ.mjs";
-import "../../chunk-TET3DJEO.mjs";
-import "../../chunk-V4B3GAMQ.mjs";
-import "../../chunk-UEZNZBJO.mjs";
-import "../../chunk-MNCQBEMS.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  AccountAddress as AccountAddress3,
+  Aptos,
+  MoveVector
+} 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/operations/index.ts
+import { Network as Network2 } from "@aptos-labs/ts-sdk";
+import { GraphQLClient } from "graphql-request";
+
+// src/core/clients/utils.ts
+import { AptosConfig } from "@aptos-labs/ts-sdk";
+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/operations/generated/sdk.ts
+import gql from "graphql-tag";
+var GetBlobsDocument = gql`
+    query getBlobs($where: blobs_bool_exp, $orderBy: [blobs_order_by!], $limit: Int, $offset: Int) {
+  blobs(where: $where, order_by: $orderBy, limit: $limit, offset: $offset) {
+    uid
+    object_name
+    owner
+    blob_commitment
+    created_at
+    expires_at
+    updated_at
+    num_chunksets
+    size
+    slice_address
+    placement_group
+    is_persisted
+    is_committed
+    is_deleted
+  }
+}
+    `;
+var GetBlobActivitiesDocument = gql`
+    query getBlobActivities($where: blob_activities_bool_exp, $orderBy: [blob_activities_order_by!], $limit: Int, $offset: Int) {
+  blob_activities(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    uid
+    object_name
+    event_index
+    event_type
+    transaction_hash
+    transaction_version
+    timestamp
+    owner
+  }
+}
+    `;
+var GetBlobsCountDocument = gql`
+    query getBlobsCount($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetBlobActivitiesCountDocument = gql`
+    query getBlobActivitiesCount($where: blob_activities_bool_exp) {
+  blob_activities_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetTotalBlobsSizeDocument = gql`
+    query getTotalBlobsSize($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      sum {
+        size
+      }
+    }
+  }
+}
+    `;
+var GetPlacementGroupSlotsDocument = gql`
+    query getPlacementGroupSlots($where: placement_group_slots_bool_exp, $orderBy: [placement_group_slots_order_by!], $limit: Int, $offset: Int) {
+  placement_group_slots(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    placement_group
+    slot_index
+    storage_provider
+    status
+    updated_at
+  }
+}
+    `;
+var GetPlacementGroupSlotsCountDocument = gql`
+    query getPlacementGroupSlotsCount($where: placement_group_slots_bool_exp) {
+  placement_group_slots_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetProcessorStatusDocument = gql`
+    query getProcessorStatus {
+  processor_status {
+    last_success_version
+    last_transaction_timestamp
+    last_updated
+  }
+}
+    `;
+var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
+function getSdk(client, withWrapper = defaultWrapper) {
+  return {
+    getBlobs(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobs", "query", variables);
+    },
+    getBlobActivities(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivities", "query", variables);
+    },
+    getBlobsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobsCount", "query", variables);
+    },
+    getBlobActivitiesCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivitiesCount", "query", variables);
+    },
+    getTotalBlobsSize(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTotalBlobsSizeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getTotalBlobsSize", "query", variables);
+    },
+    getPlacementGroupSlots(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlots", "query", variables);
+    },
+    getPlacementGroupSlotsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlotsCount", "query", variables);
+    },
+    getProcessorStatus(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetProcessorStatusDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getProcessorStatus", "query", variables);
+    }
+  };
+}
+
+// src/core/operations/index.ts
+function createShelbyIndexerClient(baseUrl, options) {
+  const graphqlClient = new GraphQLClient(baseUrl, options);
+  return getSdk(graphqlClient);
+}
+function getShelbyIndexerClient(config) {
+  const aptosConfig = getAptosConfig(config);
+  let { apiKey: indexerApiKey, baseUrl } = config.indexer ?? {};
+  if (!baseUrl) {
+    switch (aptosConfig?.network) {
+      // TODO: Add endpoints for core networks
+      case Network2.MAINNET:
+      case Network2.TESTNET:
+      case Network2.DEVNET:
+      case Network2.SHELBYNET:
+      case Network2.LOCAL:
+        baseUrl = NetworkToShelbyBlobIndexerBaseUrl[aptosConfig.network];
+        break;
+    }
+  }
+  if (baseUrl === void 0) {
+    throw new Error(
+      "The ShelbyClientConfig does not support the Shelby indexer. Please configure the endpoint in the ShelbyClientConfig.indexer.endpoint or provide a supported Aptos network."
+    );
+  }
+  const apiKey = indexerApiKey ?? config.apiKey;
+  return createShelbyIndexerClient(baseUrl, {
+    headers: {
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      "x-aptos-client": "shelby-ts-sdk"
+    }
+  });
+}
+
+// src/core/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 SenderBuiltMicropayment = class _SenderBuiltMicropayment {
+  /**
+   * The sender's address (owner of the payment channel).
+   */
+  sender;
+  /**
+   * The receiver's address (beneficiary of the withdrawal).
+   */
+  receiver;
+  /**
+   * The unique ID of the payment channel.
+   */
+  paymentChannelId;
+  /**
+   * The cumulative amount the receiver is authorized to withdraw.
+   */
+  amount;
+  /**
+   * The fungible asset metadata address.
+   */
+  fungibleAssetAddress;
+  /**
+   * Monotonically increasing sequence number for replay protection.
+   */
+  sequenceNumber;
+  /**
+   * The sender's Ed25519 public key (32 bytes).
+   * Used by the receiver to verify the signature before submitting.
+   */
+  publicKey;
+  /**
+   * The Ed25519 signature of the SignedMessage<WithdrawApproval> struct.
+   * The SignedMessage includes TypeInfo for domain separation.
+   */
+  signature;
+  /**
+   * The deployer address of the micropayments module.
+   * This is needed to reconstruct the TypeInfo for signature verification.
+   */
+  deployer;
+  constructor(sender, receiver, paymentChannelId, amount, fungibleAssetAddress, sequenceNumber, publicKey, signature, deployer) {
+    this.sender = sender;
+    this.receiver = receiver;
+    this.paymentChannelId = paymentChannelId;
+    this.amount = amount;
+    this.fungibleAssetAddress = fungibleAssetAddress;
+    this.sequenceNumber = sequenceNumber;
+    this.publicKey = publicKey;
+    this.signature = signature;
+    this.deployer = deployer ?? AccountAddress.fromString(MICROPAYMENTS_DEPLOYER);
+  }
+  /**
+   * Creates the BCS-serialized message that was signed.
+   * This is a SignedMessage<WithdrawApproval> which includes:
+   * 1. TypeInfo (module_address, module_name, struct_name)
+   * 2. WithdrawApproval struct fields
+   *
+   * This format is used with signature_verify_strict_t for domain separation.
+   */
+  getSignedMessage() {
+    return _SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
+      sender: this.sender,
+      receiver: this.receiver,
+      fungibleAssetAddress: this.fungibleAssetAddress,
+      amount: this.amount,
+      paymentChannelId: this.paymentChannelId,
+      sequenceNumber: this.sequenceNumber
+    });
+  }
+  /**
+   * Static helper to build the SignedMessage<WithdrawApproval> bytes from raw parameters.
+   * This can be used to create the message for signing without constructing the full object.
+   *
+   * @param params - The withdrawal approval parameters.
+   * @returns The BCS-serialized SignedMessage<WithdrawApproval> bytes.
+   */
+  static buildSignedMessage(params) {
+    const serializer = new Serializer();
+    serializeTypeInfo(
+      serializer,
+      params.deployer,
+      MICROPAYMENTS_MODULE_NAME,
+      WITHDRAW_APPROVAL_STRUCT_NAME
+    );
+    params.sender.serialize(serializer);
+    params.receiver.serialize(serializer);
+    params.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(params.amount);
+    serializer.serializeU64(params.paymentChannelId);
+    serializer.serializeU64(params.sequenceNumber);
+    return serializer.toUint8Array();
+  }
+  serialize(serializer) {
+    this.sender.serialize(serializer);
+    this.receiver.serialize(serializer);
+    this.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(this.amount);
+    serializer.serializeU64(this.paymentChannelId);
+    serializer.serializeU64(this.sequenceNumber);
+    serializer.serializeBytes(this.publicKey);
+    serializer.serializeBytes(this.signature);
+    this.deployer.serialize(serializer);
+  }
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  bcsToHex() {
+    return Hex.fromHexInput(this.bcsToBytes());
+  }
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  toString() {
+    return this.bcsToHex().toString();
+  }
+  /**
+   * Deserializes a SenderBuiltMicropayment from BCS bytes.
+   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
+   * @returns A new SenderBuiltMicropayment instance.
+   */
+  static deserialize(bytes) {
+    const bytesArray = typeof bytes === "string" ? Hex.fromHexInput(bytes).toUint8Array() : bytes;
+    const deserializer = new Deserializer(bytesArray);
+    const sender = AccountAddress.deserialize(deserializer);
+    const receiver = AccountAddress.deserialize(deserializer);
+    const fungibleAssetAddress = AccountAddress.deserialize(deserializer);
+    const amount = deserializer.deserializeU64();
+    const paymentChannelId = deserializer.deserializeU64();
+    const sequenceNumber = deserializer.deserializeU64();
+    const publicKey = deserializer.deserializeBytes();
+    const signature = deserializer.deserializeBytes();
+    const deployer = AccountAddress.deserialize(deserializer);
+    return new _SenderBuiltMicropayment(
+      sender,
+      receiver,
+      paymentChannelId,
+      amount,
+      fungibleAssetAddress,
+      sequenceNumber,
+      publicKey,
+      signature,
+      deployer
+    );
+  }
+};
+
+// src/core/utils.ts
+import {
+  AccountAddress as AccountAddress2,
+  Hex as Hex2
+} from "@aptos-labs/ts-sdk";
+function normalizeAddress(address) {
+  return AccountAddress2.from(address, { maxMissingChars: 63 });
+}
+
+// src/core/clients/ShelbyMicropaymentChannelClient.ts
+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 ?? AccountAddress3.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,
+          publicKey: params.publicKey ?? params.sender.publicKey.toUint8Array()
+        }
+      ),
+      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.
+   * @param params.publicKey - The Ed25519 public key bytes for the channel.
+   *
+   * @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,
+        MoveVector.U8(params.publicKey)
+      ]
+    };
+  }
+  /**
+   * 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.
+   * The sender signs a WithdrawApproval message that authorizes the receiver
+   * to withdraw funds from the micropayment channel.
+   *
+   * @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.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 A SenderBuiltMicropayment containing the signed approval.
+   *
+   * @example
+   * ```typescript
+   * const senderBuiltMicropayment = client.createMicropayment({
+   *   sender: senderAccount,
+   *   receiver: receiverAddress,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   *   amount: 100,
+   *   paymentChannelId: channelId,
+   *   sequenceNumber: 1,
+   * });
+   * ```
+   */
+  createMicropayment(params) {
+    const message = SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
+      sender: params.sender.accountAddress,
+      receiver: params.receiver,
+      fungibleAssetAddress: params.fungibleAssetAddress,
+      amount: params.amount,
+      paymentChannelId: params.paymentChannelId,
+      sequenceNumber: params.sequenceNumber
+    });
+    const signature = params.sender.sign(message);
+    return new SenderBuiltMicropayment(
+      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 a helper method for constructing the transaction payload.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @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 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,
+        MoveVector.U8(params.signature)
+      ]
+    };
+  }
+  /**
+   * 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 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.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.receiverWithdraw({
+   *   receiver: receiverAccount,
+   *   micropayment: senderBuiltMicropayment,
+   * });
+   * ```
+   */
+  async receiverWithdraw(params) {
+    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.signAndSubmitTransaction({
+        signer: params.receiver,
+        transaction
+      })
+    };
+  }
+  /**
+   * 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) => {
+        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: normalizeAddress(
+            channelInfo.asset_metadata.inner
+          ),
+          balance: BigInt(channelInfo.balance),
+          creationMicros: BigInt(channelInfo.creation_micros),
+          expirationMicros: BigInt(channelInfo.expiration_micros),
+          nextWithdrawnSequenceNumber: BigInt(
+            channelInfo.next_withdrawn_sequence_number
+          ),
+          paymentChannelId: BigInt(channelInfo.payment_channel_id),
+          receiverWithdrawnAmount: BigInt(
+            channelInfo.receiver_withdrawn_amount
+          ),
+          publicKey
+        };
+      }
+    );
+  }
+};
 export {
   ShelbyMicropaymentChannelClient
 };