@msafe/sui-app-store 0.0.10 → 0.0.12

package/dist/index.mjs

@@ -1,8 +1,308 @@
-// src/apps/msafe-core/helper.ts
-import { TransactionDefaultApplication, TransactionSubTypes } from "@msafe/sui3-utils";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/apps/msafe-core/coin-transfer.ts
-import { buildCoinTransferTxb } from "@msafe/sui3-utils";
+// src/apps/mpay/helper.ts
+import { StreamEventType, TransactionType } from "@msafe/sui3-utils";
+
+// src/apps/mpay/config/dev.json
+var dev_exports = {};
+__export(dev_exports, {
+  contractId: () => contractId,
+  default: () => dev_default,
+  feeObjId: () => feeObjId,
+  roleObjId: () => roleObjId,
+  status: () => status,
+  transaction: () => transaction,
+  upgradeCapObjId: () => upgradeCapObjId,
+  vaultObjId: () => vaultObjId
+});
+var transaction = "DiBZq4UmVVYiRL6ZJmFKYoHcxtxqrhsCXSkFyT7wUr3j";
+var status = "success";
+var contractId = "0x81c960dc653975fbd0072deca8afb92d322898c911622898ba1b2e3ad0c4bd8d";
+var roleObjId = "0xc6ec0bdee0bb59a72077e9acd2f42457043cf47080b3d3fad4d39abf28bba63a";
+var vaultObjId = "0xbc4021387fbac149119fd24e92be9e58f745774292f3a2a12e2ac6daf5363e1d";
+var feeObjId = "0x4178f63970fe2daeb256dc5730ad172e82b3e8eb45f31b33e0daae72cd35e1e1";
+var upgradeCapObjId = "0xe1e9aa7d222d151bfe6dd83358b0d7fdcb11260f710800cfaf7ccc1b1e245115";
+var dev_default = {
+  transaction,
+  status,
+  contractId,
+  roleObjId,
+  vaultObjId,
+  feeObjId,
+  upgradeCapObjId
+};
+
+// src/apps/mpay/config/prod.json
+var prod_exports = {};
+__export(prod_exports, {
+  contractId: () => contractId2,
+  default: () => prod_default,
+  feeObjId: () => feeObjId2,
+  roleObjId: () => roleObjId2,
+  status: () => status2,
+  transaction: () => transaction2,
+  upgradeCapObjId: () => upgradeCapObjId2,
+  vaultObjId: () => vaultObjId2
+});
+var transaction2 = "855FNDV8o8Z3fWULPnQo9qdhLJpsg7wZrkCpNyfw9KfB";
+var status2 = "success";
+var contractId2 = "0xc357c3985e8fb875d6b37141497af660779aa1bab0ec489b2213efd74067d1fa";
+var roleObjId2 = "0x5ab49bdf9fd1413e328ef242b3f8d83dde791b38a0b627bfc87fb25c010d34f1";
+var vaultObjId2 = "0xb483558770d8eb26007f193b75db40f0a45f2e36863a687625885d4de6993378";
+var feeObjId2 = "0x48453fc4d7cde3fe35aad89e5dfb496608a6a55ea529a1c0274681a808627f94";
+var upgradeCapObjId2 = "0x34279779a0d0d36bd5044b04830d607fa1b0ecf316548c8ac3a44151e4f1a42a";
+var prod_default = {
+  transaction: transaction2,
+  status: status2,
+  contractId: contractId2,
+  roleObjId: roleObjId2,
+  vaultObjId: vaultObjId2,
+  feeObjId: feeObjId2,
+  upgradeCapObjId: upgradeCapObjId2
+};
+
+// src/apps/mpay/common/env.ts
+var DEV_RPC_ENDPOINT = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
+var STG_RPC_ENDPOINT = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
+var PREV_RPC_ENDPOINT = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
+var PROD_RPC_ENDPOINT = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
+var DEV_BE_API = "https://bc3p6l5unl.execute-api.us-west-1.amazonaws.com/prod";
+var STG_BE_API = "https://rolsbkota7.execute-api.us-west-1.amazonaws.com/prod";
+var PREV_BE_API = "https://6p6mkx33ne.execute-api.us-west-1.amazonaws.com/prod";
+var PROD_BE_API = "https://xrae3mrjv5.execute-api.us-west-1.amazonaws.com/prod";
+var CONTRACT_DEV = dev_exports;
+var CONTRACT_PROD = prod_exports;
+var ENV_CONFIG = /* @__PURE__ */ new Map([
+  [
+    "dev" /* dev */,
+    {
+      env: "dev" /* dev */,
+      rpc: {
+        url: DEV_RPC_ENDPOINT
+      },
+      backend: {
+        url: DEV_BE_API
+      },
+      contract: CONTRACT_DEV
+    }
+  ],
+  [
+    "stg" /* stg */,
+    {
+      env: "stg" /* stg */,
+      rpc: {
+        url: STG_RPC_ENDPOINT
+      },
+      backend: {
+        url: STG_BE_API
+      },
+      contract: CONTRACT_DEV
+    }
+  ],
+  [
+    "prev" /* prev */,
+    {
+      env: "prev" /* prev */,
+      rpc: {
+        url: PREV_RPC_ENDPOINT
+      },
+      backend: {
+        url: PREV_BE_API
+      },
+      contract: CONTRACT_PROD
+    }
+  ],
+  [
+    "prod" /* prod */,
+    {
+      env: "prod" /* prod */,
+      rpc: {
+        url: PROD_RPC_ENDPOINT
+      },
+      backend: {
+        url: PROD_BE_API
+      },
+      contract: CONTRACT_PROD
+    }
+  ]
+]);
+function getConfig(env, options) {
+  const ec = ENV_CONFIG.get(env);
+  if (!ec) {
+    throw new Error(`Env not supported: ${env}`);
+  }
+  if (options && options.rpc) {
+    ec.rpc = options.rpc;
+  }
+  if (options && options.backend) {
+    ec.backend = options.backend;
+  }
+  if (options && options.contract) {
+    ec.contract = options.contract;
+  }
+  return ec;
+}
+
+// src/apps/mpay/common/globals.ts
+import { SuiClient } from "@mysten/sui.js/client";
+
+// src/apps/mpay/error/base.ts
+var MPayError = class extends Error {
+  mpayErrorCode;
+  context;
+  constructor(mpayErrorCode, msg, options = {}) {
+    const { cause, context } = options;
+    if (cause) {
+      super(`[MPay] ${msg}: ${cause}`);
+    } else {
+      super(`[MPay] ${msg}`);
+    }
+    this.mpayErrorCode = mpayErrorCode;
+    this.context = context;
+  }
+};
+
+// src/apps/mpay/error/NoBackendError.ts
+var NoBackendError = class extends MPayError {
+  constructor() {
+    super(11 /* NoBackend */, "Backend is not specified");
+  }
+};
+
+// src/apps/mpay/error/WalletNotConnectedError.ts
+var WalletNotConnectedError = class extends MPayError {
+  constructor() {
+    super(1 /* walletNotConnected */, "Wallet not connected");
+  }
+};
+
+// src/apps/mpay/stream/backend.ts
+import axios, { AxiosError } from "axios";
+
+// src/apps/mpay/error/BackendError.ts
+var BackendError = class extends MPayError {
+  constructor(msg, context) {
+    super(10 /* BackendError */, msg, { context });
+  }
+};
+
+// src/apps/mpay/stream/backend.ts
+var Backend = class _Backend {
+  constructor(apiURL) {
+    this.apiURL = apiURL;
+  }
+  static parseResponseData(response) {
+    if (response instanceof AxiosError) {
+      throw new BackendError(response.response?.statusText);
+    }
+    if (response.status === 200) {
+      if (response.data.success) {
+        return response.data.data;
+      }
+      throw new BackendError(response.data.code);
+    }
+    throw new BackendError(response.status.toString());
+  }
+  async getIncomingStreams(recipient, options) {
+    const res = await axios.post(`${this.apiURL}/stream`, {
+      recipient,
+      ...options
+    });
+    return _Backend.parseResponseData(res);
+  }
+  async getOutgoingStreams(sender, options) {
+    const res = await axios.post(`${this.apiURL}/stream`, {
+      sender,
+      ...options
+    });
+    return _Backend.parseResponseData(res);
+  }
+  async getStreamHistory(query) {
+    const res = await axios.post(`${this.apiURL}/stream-events`, query);
+    const paginatedData = _Backend.parseResponseData(res);
+    paginatedData.data.forEach((event) => {
+      const formalizedEvent = event;
+      if (formalizedEvent.data.type === "create_stream") {
+        formalizedEvent.data.balance = BigInt(formalizedEvent.data.balance);
+      } else if (formalizedEvent.data.type === "cancel_stream") {
+        formalizedEvent.data.withdrawAmount = BigInt(formalizedEvent.data.withdrawAmount);
+      } else if (formalizedEvent.data.type === "claim" || formalizedEvent.data.type === "auto_claim") {
+        formalizedEvent.data.claimAmount = BigInt(formalizedEvent.data.claimAmount);
+      } else if (formalizedEvent.data.type === "set_auto_claim") {
+        formalizedEvent.data.enabled = !!formalizedEvent.data.enabled;
+      }
+      formalizedEvent.createdAt = new Date(formalizedEvent.createdAt);
+      return formalizedEvent;
+    });
+    return paginatedData;
+  }
+  async getAllCoinTypes(address) {
+    const res = await axios.post(`${this.apiURL}/stream-info`, { address });
+    return _Backend.parseResponseData(res);
+  }
+  async getAllRecipients(sender, options) {
+    const res = await axios.post(`${this.apiURL}/stream-info`, { sender, status: options });
+    return _Backend.parseResponseData(res);
+  }
+  async getAllSenders(recipient, options) {
+    const res = await axios.post(`${this.apiURL}/stream-info`, { recipient, status: options });
+    return _Backend.parseResponseData(res);
+  }
+};
+
+// src/apps/mpay/common/globals.ts
+var Globals = class _Globals {
+  signer;
+  suiClient;
+  envConfig;
+  _backend;
+  constructor(envConfig) {
+    this.envConfig = envConfig;
+    this.suiClient = new SuiClient({ url: envConfig.rpc.url });
+    if (envConfig.backend) {
+      this._backend = new Backend(envConfig.backend.url);
+    }
+  }
+  static new(env, options) {
+    const ec = getConfig(env, options);
+    return new _Globals(ec);
+  }
+  get walletType() {
+    if (!this.wallet) {
+      return "disconnected";
+    }
+    return this.wallet.type;
+  }
+  get backend() {
+    if (!this._backend) {
+      throw new NoBackendError();
+    }
+    return this._backend;
+  }
+  // Used for test cases
+  set backend(b) {
+    this._backend = b;
+  }
+  connectWallet(wallet) {
+    this.signer = wallet;
+  }
+  disconnect() {
+    this.signer = void 0;
+  }
+  get wallet() {
+    if (!this.signer) {
+      throw new WalletNotConnectedError();
+    }
+    return this.signer;
+  }
+  async walletAddress() {
+    return this.wallet.address();
+  }
+};
 
 // src/apps/msafe-core/intention.ts
 import sortKeys from "sort-keys-recursive";
@@ -18,7 +318,2167 @@ var CoreBaseIntention = class {
   }
 };
 
+// src/apps/mpay/stream/client.ts
+import { normalizeStructTag as normalizeStructTag6, normalizeSuiAddress as normalizeSuiAddress3 } from "@mysten/sui.js/utils";
+
+// src/apps/mpay/stream/helper.ts
+import { normalizeStructTag as normalizeStructTag3, SUI_TYPE_ARG as SUI_TYPE_ARG2 } from "@mysten/sui.js/utils";
+import { Duration } from "luxon";
+
+// src/apps/mpay/builder/MPayBuilder.ts
+import { TransactionBlock as TransactionBlock3 } from "@mysten/sui.js/transactions";
+
+// src/apps/mpay/builder/CreateStreamHelper.ts
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { normalizeStructTag as normalizeStructTag2, SUI_TYPE_ARG } from "@mysten/sui.js/utils";
+
+// src/apps/mpay/builder/const.ts
+var FEE_NUMERATOR = 50n;
+var FEE_DENOMINATOR = 10000n;
+var CLAIM_FEE_NUMERATOR = 25n;
+var FLAT_FEE_SUI = 100000000n;
+
+// src/apps/mpay/common/transaction.ts
+var MoveObject = class {
+  constructor(object) {
+    this.object = object;
+  }
+  moveArg(txb) {
+    return txb.object(this.object);
+  }
+};
+var ObjectVector = class {
+  constructor(objects) {
+    this.objects = objects;
+  }
+  moveArgs(txb) {
+    return txb.makeMoveVec({ objects: this.objects.map((o) => txb.object(o)) });
+  }
+};
+var ResultRef = class _ResultRef {
+  constructor(result) {
+    this.result = result;
+    return new Proxy(this, {
+      set() {
+        throw new Error("The transaction result is a proxy, and does not support setting properties directly");
+      },
+      get(target, property) {
+        if (property in target) {
+          return Reflect.get(target, property);
+        }
+        const nestedResultFor = (resultIndex2) => new _ResultRef(target.result[resultIndex2]);
+        if (property === Symbol.iterator) {
+          return function* () {
+            let i = 0;
+            while (true) {
+              yield nestedResultFor(i);
+              i++;
+            }
+          };
+        }
+        if (typeof property === "symbol") {
+          return;
+        }
+        const resultIndex = parseInt(property, 10);
+        if (Number.isNaN(resultIndex) || resultIndex < 0) {
+          return;
+        }
+        return nestedResultFor(resultIndex);
+      }
+    });
+  }
+  moveArg() {
+    return this.result;
+  }
+};
+
+// src/apps/mpay/contract/InspectViewer.ts
+import { normalizeSuiAddress } from "@mysten/sui.js/utils";
+
+// src/apps/mpay/error/InvalidRpcResultError.ts
+var InvalidRpcResultError = class extends MPayError {
+  constructor(msg, ctx) {
+    super(3 /* InvalidRpcResult */, msg, { context: ctx });
+  }
+};
+
+// src/apps/mpay/contract/InspectViewer.ts
+var InspectViewer = class {
+  constructor(results) {
+    this.results = results;
+  }
+  callResult(index) {
+    return this.results.results[index];
+  }
+  returnValue(returned, index) {
+    return returned.returnValues[index];
+  }
+  getValue(callIndex = 0, returnIndex = 0) {
+    const callResult = this.callResult(callIndex);
+    return this.returnValue(callResult, returnIndex);
+  }
+  getAddress(callIndex = 0, returnIndex = 0) {
+    const [value, type] = this.getValue(callIndex, returnIndex);
+    if (type !== "address") {
+      throw new InvalidRpcResultError("Invalid contract return type.", {
+        ctx: {
+          expectType: "address",
+          gotType: type
+        }
+      });
+    }
+    return normalizeSuiAddress(Buffer.from(value).toString("hex"));
+  }
+  getU64(callIndex = 0, returnIndex = 0) {
+    const [value, type] = this.getValue(callIndex, returnIndex);
+    if (type !== "u64") {
+      throw new InvalidRpcResultError("Invalid contract return type.", {
+        ctx: {
+          expectType: "u64",
+          gotType: type
+        }
+      });
+    }
+    return Buffer.from(value).readBigInt64LE();
+  }
+};
+
+// src/apps/mpay/stream/metadata.ts
+import { bcs } from "@mysten/sui.js/bcs";
+
+// src/apps/mpay/error/InvalidInputError.ts
+var InvalidInputError = class extends MPayError {
+  constructor(msg, fieldKey, fieldValue) {
+    super(2 /* InvalidInput */, `Invalid input: ${msg}`, {
+      context: {
+        fieldKey,
+        fieldValue
+      }
+    });
+  }
+};
+
+// src/apps/mpay/stream/metadata.ts
+var metadataBcsType = {
+  groupId: "string",
+  name: "string"
+};
+var MAX_NAME_SIZE = 64;
+function encodeMetadata(metadata) {
+  validateMetadata(metadata);
+  return bcs.ser(metadataBcsType, metadata).toString("base64");
+}
+function decodeMetadata(metaStr) {
+  const metadata = bcs.de(metadataBcsType, metaStr, "base64");
+  validateMetadata(metadata);
+  return metadata;
+}
+function validateMetadata(metadata) {
+  if (!isAsciiString(metadata.name)) {
+    throw new InvalidInputError("Invalid metadata: Name contains unknown character");
+  }
+  if (!isAsciiString(metadata.groupId)) {
+    throw new InvalidInputError("Invalid metadata: Group ID contains unknown character");
+  }
+  if (metadata.name.length > MAX_NAME_SIZE) {
+    throw new InvalidInputError("Invalid metadata: Name exceed max length 64");
+  }
+}
+function isAsciiString(str) {
+  const asciiPattern = /^[\x00-\x7F]+$/;
+  return asciiPattern.test(str);
+}
+
+// src/apps/mpay/sui/utils.ts
+import { normalizeStructTag } from "@mysten/sui.js/utils";
+function isSameCoinType(type1, type2) {
+  return normalizeStructTag(type1) === normalizeStructTag(type2);
+}
+function isSameTarget(target1, target2) {
+  return normalizeStructTag(target1) === normalizeStructTag(target2);
+}
+
+// src/apps/mpay/types/wallet.ts
+var GAS_OBJECT_SPEC = "txn.gas";
+
+// src/apps/mpay/utils/random.ts
+function generateGroupId() {
+  return "nanoid()";
+}
+
+// src/apps/mpay/builder/CreateStreamHelper.ts
+var CreateStreamHelper = class _CreateStreamHelper {
+  constructor(globals, feeContract, streamContract) {
+    this.globals = globals;
+    this.feeContract = feeContract;
+    this.streamContract = streamContract;
+  }
+  static convertCreateStreamInfoToInternal(info) {
+    return {
+      metadata: encodeMetadata({
+        name: info.name,
+        groupId: generateGroupId()
+      }),
+      coinType: normalizeStructTag2(info.coinType),
+      recipients: info.recipients.map((recipient) => ({
+        address: recipient.address,
+        cliffAmount: recipient.cliffAmount,
+        amountPerEpoch: recipient.amountPerStep
+      })),
+      epochInterval: info.interval,
+      numberEpoch: info.steps,
+      startTime: info.startTimeMs,
+      cancelable: info.cancelable
+    };
+  }
+  async buildCreateStreamTransactionBlock(info) {
+    const txb = new TransactionBlock();
+    const paymentWithFee = this.calculateFeesInternal(info);
+    const coinReqs = this.getCreateStreamCoinRequests(info, paymentWithFee);
+    const coinResp = await this.wallet.requestCoins(coinReqs);
+    const paymentMergedObject = await this.addMergeCoins(txb, coinResp[0]);
+    let flatFeeMergedObject;
+    if (coinReqs.length > 1) {
+      flatFeeMergedObject = await this.addMergeCoins(txb, coinResp[1]);
+    } else {
+      flatFeeMergedObject = paymentMergedObject;
+    }
+    for (let i = 0; i < info.recipients.length; i++) {
+      const recipient = info.recipients[i];
+      const paymentAmount = this.amountForRecipient(recipient, info.numberEpoch);
+      const feeAmount = this.getStreamFeeLocal(paymentAmount);
+      const [paymentCoin] = txb.splitCoins(paymentMergedObject, [txb.pure(paymentAmount + feeAmount, "u64")]);
+      const [flatFeeCoin] = txb.splitCoins(flatFeeMergedObject, [txb.pure(this.flatSuiFee, "u64")]);
+      this.streamContract.createStream(txb, {
+        paymentCoin: new ResultRef(paymentCoin),
+        flatFeeCoin: new ResultRef(flatFeeCoin),
+        metadata: info.metadata,
+        recipient: recipient.address,
+        timeStart: info.startTime,
+        cliff: recipient.cliffAmount,
+        epochInterval: info.epochInterval,
+        numEpoch: info.numberEpoch,
+        amountPerEpoch: recipient.amountPerEpoch,
+        cancelable: info.cancelable,
+        coinType: info.coinType
+      });
+    }
+    return txb;
+  }
+  calculateCreateStreamFees(createInfo) {
+    const infoInternal = _CreateStreamHelper.convertCreateStreamInfoToInternal(createInfo);
+    return this.calculateFeesInternal(infoInternal);
+  }
+  feeParams() {
+    return {
+      createFeePercent: {
+        numerator: FEE_NUMERATOR,
+        denominator: FEE_DENOMINATOR
+      },
+      claimFeePercent: {
+        numerator: CLAIM_FEE_NUMERATOR,
+        denominator: FEE_DENOMINATOR
+      },
+      flatFeePerStream: FLAT_FEE_SUI
+    };
+  }
+  async addMergeCoins(txb, coins) {
+    let mergedCoin;
+    if (coins.mergedCoins && coins.mergedCoins.length) {
+      txb.mergeCoins(
+        txb.object(coins.primaryCoin),
+        coins.mergedCoins.map((coinId) => txb.object(coinId))
+      );
+      mergedCoin = txb.object(coins.primaryCoin);
+    } else if (coins.primaryCoin === GAS_OBJECT_SPEC) {
+      mergedCoin = txb.gas;
+    } else {
+      mergedCoin = txb.object(coins.primaryCoin);
+    }
+    return mergedCoin;
+  }
+  getCreateStreamCoinRequests(info, payment) {
+    const streamCoinType = info.coinType;
+    if (isSameCoinType(streamCoinType, SUI_TYPE_ARG)) {
+      return [
+        {
+          coinType: streamCoinType,
+          amount: payment.totalAmount + payment.streamFeeAmount + payment.flatFeeAmount
+        }
+      ];
+    }
+    return [
+      {
+        coinType: streamCoinType,
+        amount: payment.totalAmount + payment.streamFeeAmount
+      },
+      {
+        coinType: SUI_TYPE_ARG,
+        amount: payment.flatFeeAmount
+      }
+    ];
+  }
+  calculateFeesInternal(info) {
+    const streamPayment = info.recipients.reduce(
+      (sum, recipient) => {
+        const totalAmount = this.amountForRecipient(recipient, info.numberEpoch);
+        const fee = this.getStreamFeeLocal(totalAmount);
+        return {
+          totalAmount: sum.totalAmount + totalAmount,
+          streamFeeAmount: sum.streamFeeAmount + fee
+        };
+      },
+      {
+        totalAmount: 0n,
+        streamFeeAmount: 0n
+      }
+    );
+    const flatFeeAmount = BigInt(info.recipients.length) * this.flatSuiFee;
+    return {
+      flatFeeAmount,
+      ...streamPayment
+    };
+  }
+  amountForRecipient(recipient, numEpoch) {
+    return recipient.amountPerEpoch * numEpoch + recipient.cliffAmount;
+  }
+  get flatSuiFee() {
+    return FLAT_FEE_SUI;
+  }
+  getStreamFeeLocal(streamAmount) {
+    return streamAmount * FEE_NUMERATOR / FEE_DENOMINATOR;
+  }
+  async getStreamFeeRemote(streamAmount) {
+    const txb = this.feeContract.streamingFee(new TransactionBlock(), streamAmount);
+    const res = await this.globals.suiClient.devInspectTransactionBlock({
+      sender: await this.globals.walletAddress(),
+      transactionBlock: txb
+    });
+    const iv = new InspectViewer(res);
+    return iv.getU64();
+  }
+  get wallet() {
+    return this.globals.wallet;
+  }
+};
+
+// src/apps/mpay/contract/BaseContract.ts
+import { Transactions } from "@mysten/sui.js/transactions";
+
+// src/apps/mpay/const.ts
+var CLOCK_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+
+// src/apps/mpay/contract/BaseContract.ts
+var BaseContract = class {
+  constructor(moduleName, config, globals) {
+    this.moduleName = moduleName;
+    this.config = config;
+    this.globals = globals;
+  }
+  addContractCall(txb, input) {
+    const target = `${this.config.contractId}::${this.moduleName}::${input.method}`;
+    txb.add(
+      Transactions.MoveCall({
+        target,
+        arguments: input.arguments.map((arg) => {
+          if (arg instanceof ObjectVector) {
+            return arg.moveArgs(txb);
+          }
+          if (arg instanceof MoveObject) {
+            return arg.moveArg(txb);
+          }
+          if (arg instanceof ResultRef) {
+            return arg.moveArg();
+          }
+          return txb.pure(arg);
+        }),
+        typeArguments: input.typeArgs
+      })
+    );
+    return txb;
+  }
+  addTransactionBlock(txb, target, callArgs = [], typeArgs = []) {
+    txb.add(
+      Transactions.MoveCall({
+        target,
+        arguments: callArgs.map((arg) => {
+          if (arg instanceof ObjectVector) {
+            return arg.moveArgs(txb);
+          }
+          if (arg instanceof MoveObject) {
+            return arg.moveArg(txb);
+          }
+          if (arg instanceof ResultRef) {
+            return arg.moveArg();
+          }
+          return txb.pure(arg);
+        }),
+        typeArguments: typeArgs
+      })
+    );
+  }
+  makeObject(object) {
+    return typeof object === "string" ? new MoveObject(object) : object;
+  }
+  vaultObject() {
+    return new MoveObject(this.config.vaultObjId);
+  }
+  roleObject() {
+    return new MoveObject(this.config.roleObjId);
+  }
+  feeObject() {
+    return new MoveObject(this.config.feeObjId);
+  }
+  clockObject() {
+    return new MoveObject(CLOCK_ID);
+  }
+};
+
+// src/apps/mpay/contract/FeeContract.ts
+var FeeContract = class _FeeContract extends BaseContract {
+  constructor(config, globals) {
+    super(_FeeContract.ModuleName, config, globals);
+    this.config = config;
+    this.globals = globals;
+  }
+  static ModuleName = "fee_module";
+  static MethodName = {
+    set_streaming_fee: "set_streaming_fee",
+    set_claim_fee: "set_claim_fee",
+    set_streaming_flat_fee: "set_streaming_flat_fee",
+    streaming_flat_fee: "streaming_flat_fee",
+    streaming_fee: "streaming_fee",
+    claim_fee: "claim_fee",
+    fee_denominator: "fee_denominator"
+  };
+  setStreamingFee(txb, createFeeNumerator) {
+    const roleObject = this.roleObject();
+    const feeObject = this.feeObject();
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.set_streaming_fee,
+      arguments: [roleObject, feeObject, createFeeNumerator],
+      typeArgs: []
+    });
+  }
+  setStreamingFlatFee(txb, flatFee) {
+    const roleObject = this.roleObject();
+    const feeObject = this.feeObject();
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.set_streaming_flat_fee,
+      arguments: [roleObject, feeObject, flatFee],
+      typeArgs: []
+    });
+  }
+  setClaimFee(txb, claimFee) {
+    const roleObject = this.roleObject();
+    const feeObject = this.feeObject();
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.set_claim_fee,
+      arguments: [roleObject, feeObject, claimFee],
+      typeArgs: []
+    });
+  }
+  streamingFee(txb, amount) {
+    const feeObject = this.feeObject();
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.streaming_fee,
+      arguments: [feeObject, amount],
+      typeArgs: []
+    });
+  }
+  claimFee(txb, amount) {
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.claim_fee,
+      arguments: [this.feeObject(), amount],
+      typeArgs: []
+    });
+  }
+  feeDenominator(txb) {
+    return this.addContractCall(txb, {
+      method: _FeeContract.MethodName.fee_denominator,
+      arguments: [this.feeObject()],
+      typeArgs: []
+    });
+  }
+};
+
+// src/apps/mpay/contract/StreamContract.ts
+var StreamContract = class _StreamContract extends BaseContract {
+  constructor(config, globals) {
+    super(_StreamContract.ModuleName, config, globals);
+    this.config = config;
+    this.globals = globals;
+  }
+  static ModuleName = "stream";
+  static MethodName = {
+    create_stream: "create_stream",
+    set_auto_claim: "set_auto_claim",
+    cancel_stream: "cancel_stream",
+    claim_stream: "claim_stream",
+    claim_stream_by_proxy: "claim_stream_by_proxy",
+    stream_current_epoch: "stream_current_epoch",
+    now_milli_seconds: "now_milli_seconds"
+  };
+  createStream(txb, input) {
+    const feeObject = this.feeObject();
+    const vaultObject = this.vaultObject();
+    const paymentCoinObject = this.makeObject(input.paymentCoin);
+    const flatFeeObject = this.makeObject(input.flatFeeCoin);
+    const clockObject = this.clockObject();
+    return this.addContractCall(txb, {
+      method: _StreamContract.MethodName.create_stream,
+      arguments: [
+        feeObject,
+        vaultObject,
+        paymentCoinObject,
+        flatFeeObject,
+        input.metadata,
+        input.recipient,
+        input.timeStart,
+        input.cliff,
+        input.epochInterval,
+        input.numEpoch,
+        input.amountPerEpoch,
+        input.cancelable,
+        clockObject
+      ],
+      typeArgs: [input.coinType]
+    });
+  }
+  setAutoClaim(txb, input) {
+    const streamObject = this.makeObject(input.streamId);
+    return this.addContractCall(txb, {
+      method: _StreamContract.MethodName.set_auto_claim,
+      arguments: [streamObject, input.enabled],
+      typeArgs: [input.coinType]
+    });
+  }
+  cancelStream(txb, input) {
+    const streamObject = this.makeObject(input.streamId);
+    const clockObject = this.clockObject();
+    return this.addContractCall(txb, {
+      method: _StreamContract.MethodName.cancel_stream,
+      arguments: [streamObject, clockObject],
+      typeArgs: [input.coinType]
+    });
+  }
+  claimStream(txb, input) {
+    const streamObject = this.makeObject(input.streamId);
+    const clockObject = this.clockObject();
+    return this.addContractCall(txb, {
+      method: _StreamContract.MethodName.claim_stream,
+      arguments: [streamObject, clockObject],
+      typeArgs: [input.coinType]
+    });
+  }
+  claimStreamByProxy(txb, input) {
+    const streamObject = this.makeObject(input.streamId);
+    const vaultObject = this.vaultObject();
+    const feeObject = this.feeObject();
+    const clockObject = this.clockObject();
+    return this.addContractCall(txb, {
+      method: _StreamContract.MethodName.claim_stream_by_proxy,
+      arguments: [streamObject, vaultObject, feeObject, clockObject],
+      typeArgs: [input.coinType]
+    });
+  }
+  get createStreamTarget() {
+    return `${this.config.contractId}::${_StreamContract.ModuleName}::${_StreamContract.MethodName.create_stream}`;
+  }
+  get setAutoClaimTarget() {
+    return `${this.config.contractId}::${_StreamContract.ModuleName}::${_StreamContract.MethodName.set_auto_claim}`;
+  }
+  get cancelStreamTarget() {
+    return `${this.config.contractId}::${_StreamContract.ModuleName}::${_StreamContract.MethodName.cancel_stream}`;
+  }
+  get claimStreamTarget() {
+    return `${this.config.contractId}::${_StreamContract.ModuleName}::${_StreamContract.MethodName.claim_stream}`;
+  }
+  get claimStreamByProxyTarget() {
+    return `${this.config.contractId}::${_StreamContract.ModuleName}::${_StreamContract.MethodName.claim_stream_by_proxy}`;
+  }
+};
+
+// src/apps/mpay/builder/MPayBuilder.ts
+var MPayBuilder = class {
+  constructor(globals) {
+    this.globals = globals;
+    const config = globals.envConfig.contract;
+    this.feeContract = new FeeContract(config, globals);
+    this.streamContract = new StreamContract(config, globals);
+  }
+  feeContract;
+  streamContract;
+  async createStreams(info) {
+    const infoInternal = CreateStreamHelper.convertCreateStreamInfoToInternal(info);
+    return this.createStreamHelper().buildCreateStreamTransactionBlock(infoInternal);
+  }
+  createStreamHelper() {
+    return new CreateStreamHelper(this.globals, this.feeContract, this.streamContract);
+  }
+  setAutoClaim(streamId, enabled, coinType) {
+    const txb = new TransactionBlock3();
+    return this.streamContract.setAutoClaim(txb, {
+      streamId,
+      enabled,
+      coinType
+    });
+  }
+  claimStream(streamId, coinType) {
+    const txb = new TransactionBlock3();
+    return this.streamContract.claimStream(txb, {
+      streamId,
+      coinType
+    });
+  }
+  claimStreamByProxy(streamId, coinType) {
+    const txb = new TransactionBlock3();
+    return this.streamContract.claimStreamByProxy(txb, {
+      streamId,
+      coinType
+    });
+  }
+  cancelStream(streamId, coinType) {
+    const txb = new TransactionBlock3();
+    this.streamContract.cancelStream(txb, {
+      streamId,
+      coinType
+    });
+    return txb;
+  }
+};
+
+// src/apps/mpay/error/TransactionFailedError.ts
+var TransactionFailedError = class extends MPayError {
+  constructor(status3, msg) {
+    super(12 /* TransactionFailed */, `Transaction failed: ${msg}`, {
+      context: {
+        status: status3,
+        msg
+      }
+    });
+  }
+};
+
+// src/apps/mpay/stream/helper.ts
+var MIN_INTERVAL_MS = 1e3;
+var MPayHelper = class {
+  constructor(globals) {
+    this.globals = globals;
+    this.coinMetaHelper = new CoinMetaHelper(globals.suiClient);
+    this.createStreamHelper = new MPayBuilder(globals).createStreamHelper();
+  }
+  coinMetaHelper;
+  createStreamHelper;
+  getStreamIdsFromCreateStreamResponse(res) {
+    if (res.effects?.status.status !== "success") {
+      throw new TransactionFailedError(res.effects?.status.status, res.effects?.status.error);
+    }
+    return res.objectChanges.filter(
+      (change) => change.type === "created" && change.objectType.startsWith(`${this.globals.envConfig.contract.contractId}::stream::Stream`)
+    ).map((change) => change.objectId);
+  }
+  calculateCreateStreamFees(info) {
+    return this.createStreamHelper.calculateCreateStreamFees(info);
+  }
+  feeParams() {
+    return this.createStreamHelper.feeParams();
+  }
+  calculateStreamAmount(input) {
+    if (input.steps === 0n) {
+      throw new InvalidInputError("Invalid stream steps: 0");
+    }
+    const cliffFraction = input.cliff ? input.cliff : {
+      numerator: 0n,
+      denominator: 100n
+    };
+    const cliffAmount = input.totalAmount * cliffFraction.numerator / cliffFraction.denominator;
+    const amountPerStep = (input.totalAmount - cliffAmount) / input.steps;
+    const realTotalAmount = amountPerStep * input.steps + cliffAmount;
+    const res = {
+      realTotalAmount,
+      cliffAmount,
+      amountPerStep
+    };
+    this.validateStreamAmount(res, input.totalAmount);
+    return res;
+  }
+  calculateTimelineByInterval(input) {
+    if (input.steps === 0n) {
+      throw new InvalidInputError("Invalid stream steps: 0");
+    }
+    const timeEnd = input.timeStart.plus(input.interval.toMillis() * Number(input.steps));
+    const res = {
+      timeStart: input.timeStart,
+      timeEnd,
+      interval: input.interval,
+      steps: input.steps
+    };
+    this.validateTimeline(res);
+    return res;
+  }
+  calculateTimelineByTotalDuration(input) {
+    if (input.steps === 0n) {
+      throw new InvalidInputError("Invalid stream steps: 0");
+    }
+    const intervalMilli = BigInt(input.total.toMillis()) / input.steps;
+    const timeEnd = input.timeStart.plus(Duration.fromMillis(Number(intervalMilli * input.steps)));
+    const res = {
+      timeStart: input.timeStart,
+      timeEnd,
+      interval: Duration.fromMillis(Number(intervalMilli)),
+      steps: input.steps
+    };
+    this.validateTimeline(res);
+    return res;
+  }
+  async getBalance(address, coinType) {
+    const balance = await this.globals.suiClient.getBalance({
+      owner: address,
+      coinType
+    });
+    const coinMeta = await this.getCoinMeta(coinType);
+    return {
+      ...balance,
+      coinType: normalizeStructTag3(balance.coinType),
+      coinMeta
+    };
+  }
+  async getAllBalance(address) {
+    const allBalance = await this.globals.suiClient.getAllBalances({
+      owner: address
+    });
+    const coinMetas = await Promise.all(allBalance.map((bal) => this.getCoinMeta(bal.coinType)));
+    return allBalance.map((bal, i) => ({
+      ...bal,
+      coinType: normalizeStructTag3(bal.coinType),
+      coinMeta: coinMetas[i]
+    }));
+  }
+  async getCoinMeta(coinType) {
+    return this.coinMetaHelper.getCoinMeta(coinType);
+  }
+  async simulateTransactionBlock(txb) {
+    return this.globals.suiClient.devInspectTransactionBlock({
+      transactionBlock: txb,
+      sender: await this.globals.wallet.address()
+    });
+  }
+  validateStreamAmount(val, originTotalAmount) {
+    if (val.amountPerStep === 0n) {
+      throw new InvalidInputError("Stream amount too small", "totalAmount", originTotalAmount);
+    }
+    if (val.cliffAmount > val.realTotalAmount) {
+      throw new InvalidInputError("Invalid cliff settings");
+    }
+  }
+  validateTimeline(val) {
+    if (val.interval.toMillis() < MIN_INTERVAL_MS) {
+      throw new InvalidInputError("Interval shall be at least 1 second", "interval", val.interval);
+    }
+  }
+};
+var CoinMetaHelper = class {
+  constructor(suiClient) {
+    this.suiClient = suiClient;
+    this.coinMetaReg = /* @__PURE__ */ new Map();
+  }
+  coinMetaReg;
+  async getCoinMeta(coinType) {
+    const normalized = normalizeStructTag3(coinType || SUI_TYPE_ARG2);
+    if (this.coinMetaReg.has(normalized)) {
+      return this.coinMetaReg.get(normalized);
+    }
+    const meta = await this.queryCoinMeta(normalized);
+    if (meta) {
+      this.coinMetaReg.set(normalized, meta);
+    }
+    return meta;
+  }
+  async queryCoinMeta(coinType) {
+    const res = await this.suiClient.getCoinMetadata({ coinType });
+    return res || void 0;
+  }
+};
+
+// src/apps/mpay/stream/query.ts
+import { normalizeStructTag as normalizeStructTag5, normalizeSuiAddress as normalizeSuiAddress2 } from "@mysten/sui.js/utils";
+import { DateTime as DateTime4 } from "luxon";
+
+// src/apps/mpay/stream/Stream.ts
+import { TransactionBlock as TransactionBlock4 } from "@mysten/sui.js/transactions";
+import { normalizeStructTag as normalizeStructTag4, parseStructTag } from "@mysten/sui.js/utils";
+import { DateTime as DateTime3 } from "luxon";
+
+// src/apps/mpay/error/NotCreatorError.ts
+var NotCreatorError = class extends MPayError {
+  constructor() {
+    super(7 /* NotCreator */, "Connected wallet is not creator");
+  }
+};
+
+// src/apps/mpay/error/NotRecipientError.ts
+var NotRecipientError = class extends MPayError {
+  constructor() {
+    super(8 /* NotRecipient */, "Connected wallet is not recipient");
+  }
+};
+
+// src/apps/mpay/error/RpcError.ts
+var RpcError = class extends MPayError {
+  constructor(msg, context) {
+    super(6 /* RpcError */, msg, {
+      context
+    });
+  }
+};
+
+// src/apps/mpay/error/SanityError.ts
+var SanityError = class extends MPayError {
+  constructor(msg, options = {}) {
+    super(0 /* sanity */, msg, options);
+  }
+};
+
+// src/apps/mpay/error/StreamNotFoundError.ts
+var StreamNotFoundError = class extends MPayError {
+  constructor(streamId) {
+    super(5 /* StreamNotFound */, "Stream not found", {
+      context: {
+        streamId
+      }
+    });
+  }
+};
+
+// src/apps/mpay/utils/utils.ts
+import { DateTime as DateTime2, Duration as Duration2 } from "luxon";
+var MAX_U64 = (1n << 64n) - 1n;
+var TIME_ROUND_UNIT = 1e3;
+function roundDateTime(date) {
+  let dateMs;
+  if (typeof date === "number") {
+    dateMs = date;
+  } else if (typeof date === "bigint") {
+    dateMs = Number(date);
+  } else {
+    dateMs = date.toMillis();
+  }
+  const roundMs = Math.round(dateMs / TIME_ROUND_UNIT);
+  return DateTime2.fromMillis(roundMs * TIME_ROUND_UNIT);
+}
+function roundDuration(duration) {
+  let durationMs;
+  if (typeof duration === "number") {
+    durationMs = duration;
+  } else if (typeof duration === "bigint") {
+    durationMs = Number(duration);
+  } else {
+    durationMs = duration.toMillis();
+  }
+  const roundMs = Math.round(durationMs / TIME_ROUND_UNIT);
+  return Duration2.fromMillis(roundMs * TIME_ROUND_UNIT);
+}
+
+// src/apps/mpay/stream/Stream.ts
+var Stream = class _Stream {
+  constructor(globals, streamId, rawData) {
+    this.globals = globals;
+    this.streamId = streamId;
+    this.rawData = rawData;
+    this.streamContract = new StreamContract(globals.envConfig.contract, globals);
+  }
+  streamContract;
+  type = "Stream";
+  static async new(globals, streamId) {
+    const rawData = await _Stream.fetchStreamData(globals, streamId);
+    return new _Stream(globals, streamId, rawData);
+  }
+  static fromObjectData(globals, streamId, data) {
+    const rawData = _Stream.parseRawStreamData(streamId, data);
+    return new _Stream(globals, streamId, rawData);
+  }
+  get info() {
+    return {
+      name: this.name,
+      creator: this.creator,
+      coinType: this.coinType,
+      totalAmount: this.totalAmount,
+      start: this.timeStart,
+      end: this.timeEnd,
+      cancelable: this.cancelable,
+      cliffAmount: this.cliff,
+      duration: this.duration,
+      interval: this.interval,
+      steps: this.totalSteps,
+      nextReleaseDate: this.nextReleaseDate,
+      nextReleaseAmount: this.nextReleaseAmount,
+      groupId: this.groupId,
+      streamId: this.streamId,
+      recipient: this.recipient,
+      progress: this.progress,
+      autoClaim: this.autoClaim
+    };
+  }
+  get groupCommonInfo() {
+    return {
+      name: this.name,
+      groupId: this.groupId,
+      creator: this.creator,
+      start: this.timeStart,
+      interval: this.interval,
+      steps: this.totalSteps,
+      cancelable: this.cancelable
+    };
+  }
+  async refresh() {
+    this.rawData = await _Stream.fetchStreamData(this.globals, this.streamId);
+  }
+  refreshWithData(data) {
+    if (data.data?.objectId !== this.streamId) {
+      throw new SanityError("Object Id does not align");
+    }
+    this.rawData = _Stream.parseRawStreamData(this.streamId, data);
+  }
+  async historyEvents(pagination) {
+    return this.globals.backend.getStreamHistory({
+      streamId: this.streamId,
+      pagination
+    });
+  }
+  async cancel() {
+    if (await this.globals.walletAddress() !== this.creator) {
+      throw new NotCreatorError();
+    }
+    const txb = new TransactionBlock4();
+    this.streamContract.cancelStream(txb, {
+      streamId: this.streamId,
+      coinType: this.coinType
+    });
+    return txb;
+  }
+  async claim() {
+    if (await this.globals.walletAddress() !== this.recipient) {
+      throw new NotRecipientError();
+    }
+    const txb = new TransactionBlock4();
+    this.streamContract.claimStream(txb, {
+      streamId: this.streamId,
+      coinType: this.coinType
+    });
+    return txb;
+  }
+  async setAutoClaim(enabled) {
+    if (await this.globals.walletAddress() !== this.recipient) {
+      throw new NotRecipientError();
+    }
+    const txb = new TransactionBlock4();
+    this.streamContract.setAutoClaim(txb, {
+      streamId: this.streamId,
+      coinType: this.coinType,
+      enabled
+    });
+    return txb;
+  }
+  async claimByProxy() {
+    const txb = new TransactionBlock4();
+    this.streamContract.claimStreamByProxy(txb, {
+      streamId: this.streamId,
+      coinType: this.coinType
+    });
+    return txb;
+  }
+  get wallet() {
+    return this.globals.wallet;
+  }
+  get client() {
+    return this.globals.suiClient;
+  }
+  get coinType() {
+    return normalizeStructTag4(this.rawData.coinType);
+  }
+  get progress() {
+    return {
+      status: this.streamStatus,
+      total: this.totalAmount,
+      streamed: this.streamedAmount,
+      claimed: this.claimedAmount,
+      claimable: this.claimable,
+      canceled: this.canceledAmount
+    };
+  }
+  get balance() {
+    return this.rawData.balance;
+  }
+  get autoClaim() {
+    return this.rawData.autoClaim;
+  }
+  get amountPerEpoch() {
+    return this.rawData.config.amountPerEpoch;
+  }
+  get cancelable() {
+    return this.rawData.config.cancelable;
+  }
+  get cliff() {
+    return this.rawData.config.cliff;
+  }
+  get creator() {
+    return this.rawData.config.creator;
+  }
+  get interval() {
+    return roundDuration(this.rawData.config.epochInterval);
+  }
+  get groupId() {
+    const { metadata } = this.rawData.config;
+    const md = decodeMetadata(metadata);
+    return md.groupId;
+  }
+  get name() {
+    const { metadata } = this.rawData.config;
+    const md = decodeMetadata(metadata);
+    return md.name;
+  }
+  get recipient() {
+    return this.rawData.config.recipient;
+  }
+  get timeStart() {
+    return roundDateTime(this.rawData.config.timeStart);
+  }
+  get duration() {
+    const rawConfig = this.rawData.config;
+    const duration = rawConfig.epochInterval * rawConfig.totalEpoch;
+    return roundDuration(duration);
+  }
+  get timeEnd() {
+    return this.timeStart.plus(this.duration);
+  }
+  get totalSteps() {
+    return this.rawData.config.totalEpoch;
+  }
+  get claimable() {
+    return this.streamedAmount - this.claimedAmount;
+  }
+  get nextReleaseDate() {
+    if (this.currentEpoch === -1n) {
+      return this.timeStart;
+    }
+    if (this.currentEpoch >= this.totalSteps || this.isCanceled) {
+      return null;
+    }
+    return roundDateTime((this.currentEpoch + 1n) * this.rawData.config.epochInterval + this.rawData.config.timeStart);
+  }
+  get nextReleaseAmount() {
+    if (this.currentEpoch === -1n) {
+      return this.cliff;
+    }
+    if (this.currentEpoch >= this.totalSteps || this.isCanceled) {
+      return null;
+    }
+    return this.amountPerEpoch;
+  }
+  get streamStatus() {
+    const rawStatus = this.rawData.status.status;
+    if (rawStatus === 16 /* CANCELED */) {
+      return "CANCELED" /* CANCELED */;
+    }
+    if (rawStatus === 17 /* CANCELED_COMPLETED */) {
+      return "SETTLED" /* SETTLED */;
+    }
+    if (rawStatus === 1 /* COMPLETED */) {
+      return "COMPLETED" /* COMPLETED */;
+    }
+    if (this.currentEpoch >= this.totalSteps) {
+      return "STREAMED" /* STREAMED */;
+    }
+    return "STREAMING" /* STREAMING */;
+  }
+  get streamedAmount() {
+    if (this.currentEpoch === -1n) {
+      return 0n;
+    }
+    if (this.isCanceled) {
+      return this.rawData.status.epochCanceled * this.amountPerEpoch + this.cliff;
+    }
+    return this.currentEpoch * this.amountPerEpoch + this.cliff;
+  }
+  get claimedAmount() {
+    if (this.rawData.status.epochClaimed === MAX_U64) {
+      return 0n;
+    }
+    return this.rawData.status.epochClaimed * this.amountPerEpoch + this.cliff;
+  }
+  get currentEpoch() {
+    const timeNowMs = DateTime3.now().toMillis();
+    const timeStartMs = this.timeStart.toMillis();
+    if (timeNowMs < timeStartMs) {
+      return -1n;
+    }
+    const epoch = Math.floor((timeNowMs - timeStartMs) / Number(this.rawData.config.epochInterval));
+    return BigInt(epoch) > Number(this.rawData.config.totalEpoch) ? this.rawData.config.totalEpoch : BigInt(epoch);
+  }
+  get totalAmount() {
+    const rawConfig = this.rawData.config;
+    return rawConfig.amountPerEpoch * rawConfig.totalEpoch + rawConfig.cliff;
+  }
+  get isCanceled() {
+    const rawStatus = this.rawData.status.status;
+    return rawStatus === 16 /* CANCELED */ || rawStatus === 17 /* CANCELED_COMPLETED */;
+  }
+  get canceledAmount() {
+    return this.isCanceled ? this.totalAmount - this.streamedAmount : 0n;
+  }
+  static async fetchStreamData(globals, streamId) {
+    const res = await globals.suiClient.getObject({
+      id: streamId,
+      options: {
+        showContent: true,
+        showType: true
+      }
+    });
+    return _Stream.parseRawStreamData(streamId, res);
+  }
+  static parseRawStreamData(streamId, res) {
+    if (res.error) {
+      if (res.error.code === "notExists") {
+        throw new StreamNotFoundError(streamId);
+      }
+      throw new RpcError(`get stream data: ${res.error.code}`, {
+        streamId,
+        ...res.error
+      });
+    }
+    const content = res.data.content;
+    if (content.dataType !== "moveObject") {
+      throw new RpcError("Unexpected object type", {
+        gotType: content.dataType
+      });
+    }
+    const { typeParams } = parseStructTag(content.type);
+    const coinType = normalizeStructTag4(typeParams[0]);
+    const dataFields = content.fields;
+    const config = dataFields.config.fields;
+    const status3 = dataFields.status.fields;
+    return {
+      coinType,
+      autoClaim: dataFields.auto_claim,
+      balance: BigInt(dataFields.balance.fields.balance),
+      config: {
+        amountPerEpoch: BigInt(config.amount_per_epoch),
+        cancelable: config.cancelable,
+        cliff: BigInt(config.cliff),
+        creator: config.creator,
+        epochInterval: BigInt(config.epoch_interval),
+        metadata: config.metadata,
+        recipient: config.recipient,
+        timeStart: BigInt(config.time_start),
+        totalEpoch: BigInt(config.total_epoch)
+      },
+      status: {
+        status: status3.status,
+        epochCanceled: BigInt(status3.epoch_canceled),
+        epochClaimed: BigInt(status3.epoch_claimed)
+      }
+    };
+  }
+};
+
+// src/apps/mpay/error/InvalidStreamGroupError.ts
+var InvalidStreamGroupError = class extends MPayError {
+  constructor(msg, context) {
+    super(9 /* InvalidStreamGroup */, `Invalid stream group: ${msg}`, { context });
+  }
+};
+
+// src/apps/mpay/sui/iterator/iterator.ts
+async function getAllFromIterator(it) {
+  const res = [];
+  while (await it.hasNext()) {
+    const val = await it.next();
+    res.push(val);
+  }
+  if (res && Array.isArray(res[0])) {
+    return res.flat(1);
+  }
+  return res;
+}
+var PagedIterator = class {
+  constructor(requester) {
+    this.requester = requester;
+    this.curPage = void 0;
+    this.init = true;
+  }
+  curPage;
+  init;
+  async hasNext() {
+    if (this.init) {
+      if (!this.curPage) {
+        this.curPage = await this.requester.doNextRequest();
+      }
+      return !!this.curPage.data?.length || this.curPage.hasNext;
+    }
+    if (!this.curPage) {
+      throw new Error("invalid implementation of iterator");
+    }
+    return this.curPage.hasNext;
+  }
+  async next() {
+    if (this.init) {
+      this.init = false;
+      if (!this.curPage) {
+        this.curPage = await this.requester.doNextRequest();
+      }
+      return this.curPage.data;
+    }
+    this.curPage = await this.requester.doNextRequest();
+    return this.curPage.data;
+  }
+};
+var EntryIterator = class {
+  constructor(requester) {
+    this.requester = requester;
+    this.pager = new PagedIterator(requester);
+    this.curData = [];
+    this.cursor = 0;
+  }
+  cursor;
+  pager;
+  curData;
+  async hasNext() {
+    if (this.cursor < this.curData.length - 1) {
+      return true;
+    }
+    return this.pager.hasNext();
+  }
+  async next() {
+    this.cursor += 1;
+    while (this.cursor >= this.curData.length) {
+      if (!await this.pager.hasNext()) {
+        throw new Error("not more data");
+      } else {
+        this.curData = await this.pager.next();
+        this.cursor = 0;
+      }
+    }
+    return this.curData[this.cursor];
+  }
+};
+
+// src/apps/mpay/sui/iterator/object.ts
+var REQUEST_PAGE_SIZE = 25;
+async function getObjectsById(suiClient, ids, options) {
+  const oidIter = new ListOidIterator(ids);
+  const iter = new ObjectBatchIterator(suiClient, oidIter, options);
+  return await getAllFromIterator(iter);
+}
+var ListOidIterator = class {
+  constructor(ids) {
+    this.ids = ids;
+    this.cursor = -1;
+  }
+  cursor;
+  async hasNext() {
+    return this.cursor < this.ids.length - 1;
+  }
+  async next() {
+    this.cursor += 1;
+    if (this.cursor >= this.ids.length) {
+      throw new Error("invalid iterator implementation");
+    }
+    return this.ids[this.cursor];
+  }
+};
+var ObjectBatchIterator = class extends EntryIterator {
+  constructor(suiClient, idIter, options) {
+    super(new ObjectBatchRequester(suiClient, idIter, options));
+    this.suiClient = suiClient;
+    this.idIter = idIter;
+    this.options = options;
+  }
+};
+var ObjectBatchRequester = class {
+  constructor(suiClient, stringIter, options) {
+    this.suiClient = suiClient;
+    this.stringIter = stringIter;
+    this.options = options;
+    this.filter = options?.filter;
+    this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
+    this.objectOptions = options?.objectOptions || {
+      showType: true,
+      showContent: true
+    };
+  }
+  filter;
+  pageSize;
+  objectOptions;
+  async doNextRequest() {
+    const requestPage = [];
+    while (requestPage.length < this.pageSize) {
+      const hasNext = await this.stringIter.hasNext();
+      if (!hasNext) {
+        break;
+      }
+      const objId = await this.stringIter.next();
+      if (objId) {
+        requestPage.push(objId);
+      }
+    }
+    const res = await this.suiClient.multiGetObjects({
+      ids: requestPage,
+      options: this.objectOptions
+    });
+    let filtered;
+    if (this.filter) {
+      const { filter } = this;
+      filtered = res.filter((r) => filter?.(r));
+    } else {
+      filtered = res;
+    }
+    return {
+      data: filtered,
+      hasNext: await this.stringIter.hasNext()
+    };
+  }
+};
+
+// src/apps/mpay/stream/StreamGroup.ts
+var StreamGroup = class _StreamGroup {
+  constructor(globals, streams) {
+    this.globals = globals;
+    this.streams = streams;
+    if (streams.length === 0) {
+      throw new InvalidStreamGroupError("stream size 0");
+    }
+    const gids = streams.map((st) => st.groupId);
+    const set = new Set(gids);
+    if (set.size !== 1) {
+      throw new InvalidInputError("Stream does not have same group ID");
+    }
+  }
+  type = "StreamGroup";
+  static async new(globals, ids) {
+    const streamObjs = await getObjectsById(globals.suiClient, ids);
+    streamObjs.forEach((obj) => {
+      if (!obj) {
+        throw new SanityError("stream group object data undefined");
+      }
+    });
+    return _StreamGroup.newFromObjectResponse(globals, ids, streamObjs);
+  }
+  static async newFromObjectResponse(globals, ids, responses) {
+    const streams = await _StreamGroup.parseGroupStreams(globals, ids, responses);
+    return new _StreamGroup(globals, streams);
+  }
+  static checkStreamGroup(streams) {
+    const commonInfos = streams.map((stream) => stream.groupCommonInfo);
+    const expInfo = commonInfos[0];
+    let isEqual = true;
+    commonInfos.forEach((info) => {
+      if (!isEqualStreamGroupCommonInfo(expInfo, info)) {
+        isEqual = false;
+      }
+    });
+    return isEqual;
+  }
+  async refresh() {
+    const streamObjs = await getObjectsById(
+      this.globals.suiClient,
+      this.streams.map((stream) => stream.streamId)
+    );
+    this.streams.forEach((stream, i) => {
+      stream.refreshWithData(streamObjs[i]);
+    });
+  }
+  get groupId() {
+    return this.streams[0].groupId;
+  }
+  get creator() {
+    return this.streams[0].creator;
+  }
+  get info() {
+    return {
+      groupId: this.groupId,
+      streamIds: this.streams.map((st) => st.streamId),
+      progress: this.progress,
+      name: this.streams[0].name,
+      creator: this.creator,
+      coinType: this.streams[0].coinType,
+      totalAmount: this.streams.reduce((sum, st) => sum + st.totalAmount, 0n),
+      start: this.streams[0].timeStart,
+      end: this.streams[0].timeEnd,
+      cancelable: this.streams[0].cancelable,
+      cliffAmount: this.streams.reduce((sum, st) => sum + st.cliff, 0n),
+      duration: this.streams[0].duration,
+      interval: this.streams[0].interval,
+      steps: this.streams[0].totalSteps,
+      nextReleaseAmount: this.streams.reduce((sum, st) => {
+        if (st.nextReleaseAmount === null) {
+          return sum;
+        }
+        return sum + st.nextReleaseAmount;
+      }, 0n),
+      nextReleaseDate: this.streams[0].nextReleaseDate
+    };
+  }
+  get progress() {
+    return {
+      total: this.streams.reduce((sum, st) => sum + st.totalAmount, 0n),
+      streamed: this.streams.reduce((sum, st) => sum + st.streamedAmount, 0n),
+      claimed: this.streams.reduce((sum, st) => sum + st.claimedAmount, 0n),
+      claimable: this.streams.reduce((sum, st) => sum + st.claimable, 0n),
+      canceled: this.streams.reduce((sum, st) => sum + st.canceledAmount, 0n)
+    };
+  }
+  async historyEvents(pagination) {
+    return this.globals.backend.getStreamHistory({
+      groupId: this.groupId,
+      pagination
+    });
+  }
+  static async parseGroupStreams(globals, ids, responses) {
+    const streams = responses.map((obj, i) => Stream.fromObjectData(globals, ids[i], obj)).filter((stream) => !!stream);
+    if (new Set(streams.map((st) => st.groupId)).size !== 1) {
+      throw new InvalidStreamGroupError("Not same group ID");
+    }
+    if (!this.checkStreamGroup(streams)) {
+      throw new InvalidStreamGroupError("Not same stream settings");
+    }
+    return streams;
+  }
+};
+function isEqualStreamGroupCommonInfo(info1, info2) {
+  return info1.name === info2.name && info1.groupId === info2.groupId && info1.creator === info2.creator && info1.start.toMillis() === info2.start.toMillis() && info1.interval.toMillis() === info2.interval.toMillis() && info1.steps === info2.steps && info1.cancelable === info2.cancelable;
+}
+
+// src/apps/mpay/stream/query.ts
+var PagedStreamListIterator = class _PagedStreamListIterator {
+  constructor(it, pageSize) {
+    this.it = it;
+    this.pageSize = pageSize;
+  }
+  static async newIncoming(input) {
+    const it = await StreamListIterator.newIncoming(input);
+    return new _PagedStreamListIterator(it, input.pageSize);
+  }
+  static async newOutgoing(input) {
+    const it = await StreamListIterator.newOutgoing(input);
+    return new _PagedStreamListIterator(it, input.pageSize);
+  }
+  async hasNext() {
+    return this.it.hasNext();
+  }
+  async next() {
+    const res = [];
+    while (res.length < this.pageSize && await this.it.hasNext()) {
+      res.push(await this.it.next());
+    }
+    return res;
+  }
+};
+var StreamListIterator = class _StreamListIterator {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  cachedNext;
+  static async newIncoming(input) {
+    const requester = await StreamListRequester.newIncomingQuery(input);
+    return new _StreamListIterator(requester);
+  }
+  static async newOutgoing(input) {
+    const requester = await StreamListRequester.newOutgoingQuery(input);
+    return new _StreamListIterator(requester);
+  }
+  async hasNext() {
+    if (this.cachedNext === void 0) {
+      this.cachedNext = await this.requester.doNextRequest();
+    }
+    return this.cachedNext !== null;
+  }
+  async next() {
+    if (this.cachedNext === void 0) {
+      const res2 = await this.requester.doNextRequest();
+      if (res2 === null) {
+        throw new SanityError("No more results");
+      }
+      return res2;
+    }
+    const res = this.cachedNext;
+    this.cachedNext = void 0;
+    if (res === null) {
+      throw new SanityError("No more results");
+    }
+    return res;
+  }
+};
+var StreamListRequester = class _StreamListRequester {
+  constructor(globals, recipient, groupRefs, query) {
+    this.globals = globals;
+    this.recipient = recipient;
+    this.groupRefs = groupRefs;
+    this.query = query;
+    this.current = 0;
+    const oidIter = new ListOidIterator(groupRefs.flat().map((ref) => ref.streamId));
+    this.objectIter = new ObjectBatchIterator(globals.suiClient, oidIter);
+  }
+  current = 0;
+  objectIter;
+  static async newIncomingQuery(input) {
+    const backendQuery = convertToIncomingBackendQuery(input.query);
+    const recipient = await input.globals.walletAddress();
+    const refs = await input.globals.backend.getIncomingStreams(recipient, backendQuery);
+    const filtered = refs.filter((ref) => normalizeSuiAddress2(ref.recipient) === normalizeSuiAddress2(recipient));
+    const groupedRefs = groupAndSortRefs(filtered);
+    return new _StreamListRequester(input.globals, recipient, groupedRefs, input.query);
+  }
+  static async newOutgoingQuery(input) {
+    const backendQuery = convertToOutgoingBackendQuery(input.query);
+    const sender = await input.globals.walletAddress();
+    const refs = await input.globals.backend.getOutgoingStreams(sender, backendQuery);
+    const groupedRefs = groupAndSortRefs(refs);
+    return new _StreamListRequester(input.globals, sender, groupedRefs, input.query);
+  }
+  async doNextRequest() {
+    if (this.current >= this.groupRefs.length) {
+      return null;
+    }
+    const stRefs = this.groupRefs[this.current];
+    if (stRefs.length === 1) {
+      const stream = await getStreamFromIterator(this.globals, stRefs[0].streamId, this.objectIter);
+      this.current++;
+      return isStreamOfQuery(stream, this.query) ? stream : this.doNextRequest();
+    }
+    if (stRefs.length > 1) {
+      const sg = await getStreamGroupFromIterator(
+        this.globals,
+        stRefs.map((ref) => ref.streamId),
+        this.objectIter
+      );
+      this.current++;
+      return isStreamGroupOfQuery(sg, this.query) ? sg : this.doNextRequest();
+    }
+    throw new SanityError("Stream group with no stream");
+  }
+};
+function groupAndSortRefs(refs) {
+  const m = /* @__PURE__ */ new Map();
+  refs.forEach((ref) => {
+    const groupList = m.get(ref.groupId);
+    if (groupList) {
+      groupList.push(ref);
+      m.set(ref.groupId, groupList);
+    } else {
+      m.set(ref.groupId, [ref]);
+    }
+  });
+  return Array.from(m.values()).sort(
+    (gl1, gl2) => DateTime4.fromISO(gl2[0].createDate).toMillis() - DateTime4.fromISO(gl1[0].createDate).toMillis()
+  );
+}
+function isStreamOfQuery(stream, query) {
+  if (query === void 0) {
+    return true;
+  }
+  const isStatus = isStreamOfStatus(stream, query.status);
+  if (query && "claimable" in query && query.claimable !== void 0) {
+    const isClaimable = query.claimable ? stream.progress.claimable !== 0n : stream.progress.claimable === 0n;
+    return isStatus && isClaimable;
+  }
+  return isStatus;
+}
+function isStreamOfStatus(stream, filter) {
+  if (filter === void 0) {
+    return true;
+  }
+  if (!Array.isArray(filter)) {
+    return stream.progress.status === filter;
+  }
+  return filter.includes(stream.progress.status);
+}
+function isStreamGroupOfQuery(sg, query) {
+  if (!query) {
+    return true;
+  }
+  let isStatus = false;
+  sg.streams.forEach((stream) => {
+    if (isStreamOfQuery(stream, query)) {
+      isStatus = true;
+    }
+  });
+  return isStatus;
+}
+async function getStreamFromIterator(globals, streamId, it) {
+  const data = await getStreamObjectResponseFromIter(it, streamId);
+  return Stream.fromObjectData(globals, streamId, data);
+}
+async function getStreamGroupFromIterator(globals, streamIds, it) {
+  const objResponses = [];
+  while (objResponses.length < streamIds.length) {
+    const data = await getStreamObjectResponseFromIter(it, streamIds[objResponses.length]);
+    objResponses.push(data);
+  }
+  return StreamGroup.newFromObjectResponse(globals, streamIds, objResponses);
+}
+async function getStreamObjectResponseFromIter(it, streamId) {
+  if (!await it.hasNext()) {
+    throw new SanityError("object iterator has been consumed");
+  }
+  const data = await it.next();
+  if (!data || data.error || data.data === void 0 || data.data === null) {
+    throw new SanityError(`object iterator undefined response`, {
+      cause: data?.error
+    });
+  }
+  if (data?.data?.objectId !== streamId) {
+    throw new SanityError("stream id not aligned");
+  }
+  return data;
+}
+function convertToIncomingBackendQuery(query) {
+  return {
+    status: convertStreamStatus(query?.status),
+    coinType: normalizeCoinTypeFilter(query?.coinType),
+    sender: normalizeAddressFilter(query?.sender)
+  };
+}
+function convertToOutgoingBackendQuery(query) {
+  return {
+    status: convertStreamStatus(query?.status),
+    coinType: normalizeCoinTypeFilter(query?.coinType),
+    recipient: normalizeAddressFilter(query?.recipient)
+  };
+}
+function convertStreamStatus(status3) {
+  if (status3 === void 0 || status3.length === 0) {
+    return "all";
+  }
+  if (!Array.isArray(status3)) {
+    return convertStreamStatusSingle(status3);
+  }
+  return status3.reduce((res, st) => {
+    const sts = convertStreamStatus(st);
+    if (!res) {
+      return sts;
+    }
+    if (res === sts) {
+      return sts;
+    }
+    return "all";
+  }, void 0);
+}
+function convertStreamStatusSingle(status3) {
+  switch (status3) {
+    case "STREAMING":
+    case "STREAMED":
+    case "CANCELED":
+      return "active";
+    case "COMPLETED":
+    case "SETTLED":
+      return "inactive";
+    default:
+      throw new InvalidInputError("Unknown stream filtered status");
+  }
+}
+function normalizeCoinTypeFilter(coinType) {
+  if (!coinType) {
+    return void 0;
+  }
+  if (!Array.isArray(coinType)) {
+    return normalizeStructTag5(coinType);
+  }
+  return coinType.length !== 0 ? coinType.map((ct) => normalizeStructTag5(ct)) : void 0;
+}
+function normalizeAddressFilter(address) {
+  if (!address) {
+    return void 0;
+  }
+  if (!Array.isArray(address)) {
+    return normalizeSuiAddress2(address);
+  }
+  return address.length !== 0 ? address.map((addr) => normalizeSuiAddress2(addr)) : void 0;
+}
+
+// src/apps/mpay/stream/client.ts
+var MSafeAccountAdapter = class {
+  constructor(msafe) {
+    this.msafe = msafe;
+  }
+  get type() {
+    return "msafe" /* msafe */;
+  }
+  async address() {
+    return this.msafe.address();
+  }
+  async requestCoins(reqs) {
+    return this.msafe.requestCoins(reqs);
+  }
+};
+var MPayClient = class {
+  globals;
+  helper;
+  constructor(env, options) {
+    this.globals = Globals.new(env, options);
+    this.helper = new MPayHelper(this.globals);
+  }
+  connectMSafeAccount(msafe) {
+    const adapter = new MSafeAccountAdapter(msafe);
+    this.globals.connectWallet(adapter);
+  }
+  async createStream(info) {
+    return this.builder().createStreams(info);
+  }
+  async getStream(streamId) {
+    return Stream.new(this.globals, streamId);
+  }
+  async getIncomingStreams(query, pageSize = 10) {
+    return PagedStreamListIterator.newIncoming({
+      globals: this.globals,
+      query,
+      pageSize
+    });
+  }
+  async getOutgoingStreams(query, pageSize = 10) {
+    return PagedStreamListIterator.newOutgoing({
+      globals: this.globals,
+      query,
+      pageSize
+    });
+  }
+  async getCoinTypesForStreamFilter() {
+    const address = await this.wallet.address();
+    const coinTypes = await this.globals.backend.getAllCoinTypes(address);
+    return coinTypes.map((coinType) => normalizeStructTag6(coinType));
+  }
+  async getRecipientsForStreamFilter(options) {
+    const address = await this.wallet.address();
+    const recipients = await this.globals.backend.getAllRecipients(address, options);
+    return recipients.map((recipient) => normalizeSuiAddress3(recipient));
+  }
+  async getCreatorsForStreamFilter(options) {
+    const address = await this.wallet.address();
+    const creators = await this.globals.backend.getAllSenders(address, options);
+    return creators.map((creator) => normalizeSuiAddress3(creator));
+  }
+  get wallet() {
+    return this.globals.wallet;
+  }
+  builder() {
+    return new MPayBuilder(this.globals);
+  }
+};
+
+// src/apps/mpay/create-stream.ts
+var CreateStreamIntention = class _CreateStreamIntention extends CoreBaseIntention {
+  constructor(data) {
+    super(data);
+    this.data = data;
+  }
+  txType;
+  txSubType;
+  async build(input) {
+    const { network } = input;
+    const mpayClient = new MPayClient(network === "sui:mainnet" ? "prod" /* prod */ : "dev" /* dev */);
+    const txb = await mpayClient.createStream(this.data);
+    return txb;
+  }
+  static fromData(data) {
+    return new _CreateStreamIntention(data);
+  }
+};
+
+// src/apps/mpay/decoder/create.ts
+import { normalizeStructTag as normalizeStructTag8, SUI_TYPE_ARG as SUI_TYPE_ARG3 } from "@mysten/sui.js/utils";
+
+// src/apps/mpay/decoder/moveCall.ts
+import { bcs as bcs2 } from "@mysten/sui.js/bcs";
+import { normalizeStructTag as normalizeStructTag7, normalizeSuiAddress as normalizeSuiAddress4 } from "@mysten/sui.js/utils";
+var MoveCallHelper = class _MoveCallHelper {
+  constructor(moveCall, txb) {
+    this.moveCall = moveCall;
+    this.txb = txb;
+  }
+  decodeSharedObjectId(argIndex) {
+    const input = this.getInputParam(argIndex);
+    return _MoveCallHelper.getSharedObjectId(input);
+  }
+  decodeOwnedObjectId(argIndex) {
+    const input = this.getInputParam(argIndex);
+    return _MoveCallHelper.getOwnedObjectId(input);
+  }
+  decodeInputU64(argIndex) {
+    const strVal = this.decodePureArg(argIndex, "u64");
+    return BigInt(strVal);
+  }
+  decodeInputAddress(argIndex) {
+    const input = this.decodePureArg(argIndex, "address");
+    return normalizeSuiAddress4(input);
+  }
+  decodeInputString(argIndex) {
+    return this.decodePureArg(argIndex, "string");
+  }
+  decodeInputBool(argIndex) {
+    return this.decodePureArg(argIndex, "bool");
+  }
+  decodePureArg(argIndex, bcsType) {
+    const input = this.getInputParam(argIndex);
+    return _MoveCallHelper.getPureInputValue(input, bcsType);
+  }
+  getInputParam(argIndex) {
+    const arg = this.moveCall.arguments[argIndex];
+    if (arg.kind !== "Input") {
+      throw new Error("not input type");
+    }
+    return this.txb.blockData.inputs[arg.index];
+  }
+  static getPureInputValue(input, bcsType) {
+    if (input.type !== "pure") {
+      throw new Error("not pure argument");
+    }
+    if (typeof input.value === "object" && "Pure" in input.value) {
+      const bcsNums = input.value.Pure;
+      return bcs2.de(bcsType, new Uint8Array(bcsNums));
+    }
+    return input.value;
+  }
+  static getOwnedObjectId(input) {
+    if (input.type !== "object") {
+      throw new Error(`not object argument: ${JSON.stringify(input)}`);
+    }
+    if (typeof input.value === "object") {
+      if (!("Object" in input.value) || !("ImmOrOwned" in input.value.Object)) {
+        throw new Error("not ImmOrOwned");
+      }
+      return normalizeSuiAddress4(input.value.Object.ImmOrOwned.objectId);
+    }
+    return normalizeSuiAddress4(input.value);
+  }
+  static getSharedObjectId(input) {
+    if (input.type !== "object") {
+      throw new Error(`not object argument: ${JSON.stringify(input)}`);
+    }
+    if (typeof input.value !== "object") {
+      return normalizeSuiAddress4(input.value);
+    }
+    if (!("Object" in input.value) || !("Shared" in input.value.Object)) {
+      throw new Error("not Shared");
+    }
+    return normalizeSuiAddress4(input.value.Object.Shared.objectId);
+  }
+  static getPureInput(input, bcsType) {
+    if (input.type !== "pure") {
+      throw new Error("not pure argument");
+    }
+    if (typeof input.value !== "object") {
+      return input.value;
+    }
+    if (!("Pure" in input.value)) {
+      throw new Error("Pure not in value");
+    }
+    const bcsVal = input.value.Pure;
+    return bcs2.de(bcsType, new Uint8Array(bcsVal));
+  }
+  typeArg(index) {
+    return normalizeStructTag7(this.moveCall.typeArguments[index]);
+  }
+  txArg(index) {
+    return this.moveCall.arguments[index];
+  }
+};
+
+// src/apps/mpay/decoder/create.ts
+var CreateStreamDecodeHelper = class {
+  constructor(globals, txb) {
+    this.globals = globals;
+    this.txb = txb;
+  }
+  decode() {
+    const streamInfo = this.decodeCreateStreamInfo();
+    const fees = this.createStreamHelper().calculateCreateStreamFees(streamInfo);
+    const coinMerges = this.getCoinMerges();
+    return {
+      type: "CreateStream" /* CREATE_STREAM */,
+      info: streamInfo,
+      fees,
+      coinMerges
+    };
+  }
+  decodeCreateStreamInfo() {
+    const moveCalls = this.createStreamTransactions();
+    const infos = moveCalls.map((moveCall) => this.getCreationInfoFromMoveCall(moveCall));
+    return this.aggregateGroupStreamInfo(infos);
+  }
+  createStreamTransactions() {
+    const txs = this.transactions.filter(
+      (tx) => tx.kind === "MoveCall" && isSameTarget(tx.target, this.contract.createStreamTarget)
+    );
+    if (txs.length === 0) {
+      throw new SanityError("No create stream transactions");
+    }
+    return txs.map((tx) => new MoveCallHelper(tx, this.txb));
+  }
+  getCreationInfoFromMoveCall(moveCall) {
+    const metadata = moveCall.decodeInputString(4);
+    const { name, groupId } = decodeMetadata(metadata);
+    const recipient = moveCall.decodeInputAddress(5);
+    const timeStart = moveCall.decodeInputU64(6);
+    const cliff = moveCall.decodeInputU64(7);
+    const epochInterval = moveCall.decodeInputU64(8);
+    const totalEpoch = moveCall.decodeInputU64(9);
+    const amountPerEpoch = moveCall.decodeInputU64(10);
+    const cancelable = moveCall.decodeInputBool(11);
+    const coinType = moveCall.typeArg(0);
+    return {
+      name,
+      groupId,
+      recipient,
+      timeStart,
+      cliff,
+      epochInterval,
+      totalEpoch,
+      amountPerEpoch,
+      cancelable,
+      coinType
+    };
+  }
+  aggregateGroupStreamInfo(infos) {
+    const commonInfoSet = new Set(
+      infos.map(
+        (info) => JSON.stringify({
+          name: info.name,
+          groupId: info.groupId,
+          timeStart: String(info.timeStart),
+          epochInterval: String(info.epochInterval),
+          totalEpoch: String(info.totalEpoch),
+          cancelable: info.cancelable,
+          coinType: info.coinType
+        })
+      )
+    );
+    if (commonInfoSet.size !== 1) {
+      throw new InvalidInputError("Stream group not have common info");
+    }
+    const recipients = infos.map((info) => ({
+      address: info.recipient,
+      amountPerStep: info.amountPerEpoch,
+      cliffAmount: info.cliff
+    }));
+    return {
+      name: infos[0].name,
+      coinType: infos[0].coinType,
+      recipients,
+      interval: infos[0].epochInterval,
+      steps: infos[0].totalEpoch,
+      startTimeMs: infos[0].timeStart,
+      cancelable: infos[0].cancelable
+    };
+  }
+  getCoinMerges() {
+    const createStreamTx = this.createStreamTransactions()[0];
+    return this.getCoinMergeForCreateStream(createStreamTx);
+  }
+  getCoinMergeForCreateStream(moveCall) {
+    const coinType = moveCall.typeArg(0);
+    const paymentCoin = moveCall.txArg(2);
+    const paymentCoinMerge = this.getCoinMergeFromNestedResult(paymentCoin, coinType, moveCall);
+    if (coinType === normalizeStructTag8(SUI_TYPE_ARG3)) {
+      return [paymentCoinMerge];
+    }
+    const flatFeeCoin = moveCall.txArg(3);
+    const flatCoinMerge = this.getCoinMergeFromNestedResult(flatFeeCoin, normalizeStructTag8(SUI_TYPE_ARG3), moveCall);
+    return [paymentCoinMerge, flatCoinMerge];
+  }
+  getCoinMergeFromNestedResult(coinArg, coinType, moveCall) {
+    if (coinArg.kind === "GasCoin") {
+      return {
+        primary: "GAS",
+        coinType
+      };
+    }
+    if (coinArg.kind === "Input") {
+      const arg = this.getInputArg(coinArg);
+      const objectId = MoveCallHelper.getOwnedObjectId(arg);
+      const mergeTx = this.transactions.find((tx) => {
+        if (tx.kind !== "MergeCoins") {
+          return false;
+        }
+        if (tx.destination.kind !== "Input") {
+          throw new Error("merge coin destination not Input type");
+        }
+        const primaryCoinInput = this.getInputArg(tx.destination);
+        return MoveCallHelper.getOwnedObjectId(primaryCoinInput) === objectId;
+      });
+      if (!mergeTx) {
+        return {
+          primary: objectId,
+          coinType
+        };
+      }
+      return {
+        primary: objectId,
+        merged: mergeTx.sources.map((sourceArg) => {
+          const sourceInputArg = this.getInputArg(sourceArg);
+          return MoveCallHelper.getOwnedObjectId(sourceInputArg);
+        }),
+        coinType
+      };
+    }
+    if (coinArg.kind === "NestedResult") {
+      const parentTx = this.transactions[coinArg.index];
+      if (parentTx.kind !== "SplitCoins") {
+        throw new InvalidInputError(`Transaction type not expected. Expect SplitCoins, got ${parentTx.kind}`);
+      }
+      return this.getCoinMergeFromNestedResult(parentTx.coin, coinType, moveCall);
+    }
+    if (coinArg.kind === "Result") {
+      throw new Error("Result type not expected for coin inputs");
+    }
+    throw new Error(`Unknown argument kind`);
+  }
+  mergeCoinTransactions() {
+    return this.transactions.filter((tx) => tx.kind === "MergeCoins");
+  }
+  get transactions() {
+    return this.txb.blockData.transactions;
+  }
+  get contract() {
+    return new StreamContract(this.globals.envConfig.contract, this.globals);
+  }
+  get feeContract() {
+    return new FeeContract(this.globals.envConfig.contract, this.globals);
+  }
+  createStreamHelper() {
+    return new CreateStreamHelper(this.globals, this.feeContract, this.contract);
+  }
+  getInputArg(arg) {
+    if (arg.kind !== "Input") {
+      throw new Error("not input type");
+    }
+    return "value" in arg ? arg : this.txb.blockData.inputs[arg.index];
+  }
+};
+
+// src/apps/mpay/decoder/decoder.ts
+var DecodeHelper = class {
+  constructor(globals, txb) {
+    this.globals = globals;
+    this.txb = txb;
+    this.contract = new StreamContract(globals.envConfig.contract, globals);
+  }
+  contract;
+  decode() {
+    if (this.isCreateStreamTransaction()) {
+      return this.decodeCreateStreamTransaction();
+    }
+    if (this.isClaimByProxyTransaction()) {
+      return this.decodeClaimByProxyTransaction();
+    }
+    if (this.isSetAutoClaimTransaction()) {
+      return this.decodeSetAutoClaimTransaction();
+    }
+    if (this.isCancelStreamTransaction()) {
+      return this.decodeCancelStreamTransaction();
+    }
+    if (this.isClaimStreamTransaction()) {
+      return this.decodeClaimTransaction();
+    }
+    return void 0;
+  }
+  get transactions() {
+    return this.txb.blockData.transactions;
+  }
+  isCreateStreamTransaction() {
+    const createStreamIndex = this.transactions.findIndex(
+      (tx) => tx.kind === "MoveCall" && isSameTarget(tx.target, this.contract.createStreamTarget)
+    );
+    return createStreamIndex !== -1;
+  }
+  isSetAutoClaimTransaction() {
+    return this.transactions.length === 1 && this.transactions[0].kind === "MoveCall" && isSameTarget(this.transactions[0].target, this.contract.setAutoClaimTarget);
+  }
+  isCancelStreamTransaction() {
+    return this.transactions.length === 1 && this.transactions[0].kind === "MoveCall" && isSameTarget(this.transactions[0].target, this.contract.cancelStreamTarget);
+  }
+  isClaimStreamTransaction() {
+    return this.transactions.length === 1 && this.transactions[0].kind === "MoveCall" && isSameTarget(this.transactions[0].target, this.contract.claimStreamTarget);
+  }
+  isClaimByProxyTransaction() {
+    return this.transactions.length === 1 && this.transactions[0].kind === "MoveCall" && isSameTarget(this.transactions[0].target, this.contract.claimStreamByProxyTarget);
+  }
+  decodeCreateStreamTransaction() {
+    const helper = new CreateStreamDecodeHelper(this.globals, this.txb);
+    return helper.decode();
+  }
+  decodeSetAutoClaimTransaction() {
+    const streamId = this.helper.decodeSharedObjectId(0);
+    const enabled = this.helper.decodeInputBool(1);
+    return {
+      type: "SetAutoClaim" /* SET_AUTO_CLAIM */,
+      streamId,
+      enabled
+    };
+  }
+  decodeClaimTransaction() {
+    const streamId = this.helper.decodeSharedObjectId(0);
+    return {
+      type: "Claim" /* CLAIM */,
+      streamId
+    };
+  }
+  decodeClaimByProxyTransaction() {
+    const streamId = this.helper.decodeSharedObjectId(0);
+    return {
+      type: "ClaimByProxy" /* CLAIM_BY_PROXY */,
+      streamId
+    };
+  }
+  decodeCancelStreamTransaction() {
+    const streamId = this.helper.decodeSharedObjectId(0);
+    return {
+      type: "Cancel" /* CANCEL */,
+      streamId
+    };
+  }
+  get helper() {
+    const moveCall = this.transactions[0];
+    return new MoveCallHelper(moveCall, this.txb);
+  }
+};
+
+// src/apps/mpay/helper.ts
+var MPayAppHelper = class {
+  application = "mpay";
+  async deserialize(input) {
+    const { chain, transactionBlock } = input;
+    const globals = Globals.new(chain === "sui:mainnet" ? "prod" /* prod */ : "dev" /* dev */);
+    const decoder = new DecodeHelper(globals, transactionBlock);
+    const result = decoder.decode();
+    console.log("\u{1F680} ~ MPayHelper ~ deserialize ~ input:", input, result);
+    if (result.type === "CreateStream" /* CREATE_STREAM */) {
+      return {
+        txType: TransactionType.Other,
+        txSubType: StreamEventType.Create,
+        intentionData: result.info
+      };
+    }
+    throw new Error(`Unknown transaction type: ${result.type}`);
+  }
+  async build(input) {
+    const { network, intentionData, suiClient, account } = input;
+    let intention;
+    switch (input.txSubType) {
+      case StreamEventType.Create:
+        intention = CreateStreamIntention.fromData(intentionData);
+        break;
+      default:
+        throw new Error("not implemented");
+    }
+    return intention.build({ network, suiClient, account });
+  }
+};
+
+// src/apps/msafe-core/helper.ts
+import { TransactionDefaultApplication, TransactionSubTypes } from "@msafe/sui3-utils";
+
 // src/apps/msafe-core/coin-transfer.ts
+import { buildCoinTransferTxb } from "@msafe/sui3-utils";
 var CoinTransferIntention = class _CoinTransferIntention extends CoreBaseIntention {
   constructor(data) {
     super(data);
@@ -55,7 +2515,7 @@ var ObjectTransferIntention = class _ObjectTransferIntention extends CoreBaseInt
 
 // src/apps/msafe-core/plain-payload.ts
 import { isSameAddress } from "@msafe/sui3-utils";
-import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TransactionBlock as TransactionBlock5 } from "@mysten/sui.js/transactions";
 var PlainPayloadIntention = class _PlainPayloadIntention extends CoreBaseIntention {
   constructor(data) {
     super(data);
@@ -65,7 +2525,7 @@ var PlainPayloadIntention = class _PlainPayloadIntention extends CoreBaseIntenti
   txSubType;
   async build(input) {
     const { account } = input;
-    const tb = TransactionBlock.from(this.data.content);
+    const tb = TransactionBlock5.from(this.data.content);
     if (!isSameAddress(tb.blockData.sender, account.address)) {
       throw new Error("Invalid sender address");
     }
@@ -118,16 +2578,10 @@ var MSafeApps = class {
     }
     return app;
   }
-  deserialize(appName, input) {
-    return this.getAppHelper(appName).deserialize(input);
-  }
-  build(appName, input) {
-    return this.getAppHelper(appName).build(input);
-  }
 };
 
 // src/index.ts
-var appHelpers = new MSafeApps([new CoreHelper()]);
+var appHelpers = new MSafeApps([new CoreHelper(), new MPayAppHelper()]);
 export {
   appHelpers
 };