@msafe/sui3-sdk 0.0.2-pre-9f39791.0 → 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1812 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AUTH_SIGN_MESSAGE: () => AUTH_SIGN_MESSAGE,
+  COIN_TYPE_ARG_REGEX: () => COIN_TYPE_ARG_REGEX,
+  Coin: () => Coin,
+  CoinHelper: () => CoinHelper,
+  CreateHelper: () => CreateHelper,
+  DEV_DATABASE_CONFIG: () => DEV_DATABASE_CONFIG,
+  ENV_CONFIGS: () => ENV_CONFIGS,
+  Formatter: () => Formatter,
+  HexToUint8Array: () => HexToUint8Array,
+  IntentionHelper: () => IntentionHelper,
+  LOCAL_DATABASE_CONFIG: () => LOCAL_DATABASE_CONFIG,
+  MAINNET_RPC_URL: () => MAINNET_RPC_URL,
+  MAX_OWNER_WITHOUT_NONCE: () => MAX_OWNER_WITHOUT_NONCE,
+  MAX_OWNER_WITH_NONCE: () => MAX_OWNER_WITH_NONCE,
+  MAX_WEIGHT: () => MAX_WEIGHT,
+  MIN_THRESHOLD: () => MIN_THRESHOLD,
+  MIN_WEIGHT: () => MIN_WEIGHT,
+  MSafeAccount: () => MSafeAccount,
+  MSafeClient: () => MSafeClient,
+  MSafeEnv: () => MSafeEnv,
+  MSafeGlobals: () => MSafeGlobals,
+  MessageHelper: () => MessageHelper,
+  NONCE_PK_PREFIX: () => NONCE_PK_PREFIX,
+  NONCE_PK_WEIGHT: () => NONCE_PK_WEIGHT,
+  NONCE_PREFIX_MAX_SIZE: () => NONCE_PREFIX_MAX_SIZE,
+  PublicKeySerde: () => PublicKeySerde,
+  RawMultiSig: () => RawMultiSig,
+  SUI_COIN: () => SUI_COIN,
+  SignatureVerifier: () => SignatureVerifier,
+  TESTNET_RPC_URL: () => TESTNET_RPC_URL,
+  Uint8ArrayToHex: () => Uint8ArrayToHex,
+  getAllCoins: () => getAllCoins,
+  getMSafeConfig: () => getMSafeConfig,
+  getMultiSigPublicKey: () => getMultiSigPublicKey,
+  getPublicKeyFromChain: () => getPublicKeyFromChain,
+  makeNoncePublicKey: () => makeNoncePublicKey,
+  stringToBuffer: () => stringToBuffer,
+  validateMultiSigConfig: () => validateMultiSigConfig
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/transactions/coin-transfer.ts
+var import_transactions = require("@mysten/sui.js/transactions");
+
+// src/utils/format.ts
+var import_utils2 = require("@mysten/sui.js/utils");
+
+// src/utils/coin.ts
+var import_utils = require("@mysten/sui.js/utils");
+var CoinHelper = class {
+  _client;
+  _coinMetaReg;
+  constructor(client) {
+    this._client = client;
+    this._coinMetaReg = /* @__PURE__ */ new Map();
+  }
+  async getCoinMeta(coinType) {
+    const normalized = (0, import_utils.normalizeStructTag)(coinType);
+    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._client.getCoinMetadata({ coinType });
+    return res || void 0;
+  }
+};
+var COIN_TYPE_ARG_REGEX = /^0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<(.+)>$/;
+var Coin = class _Coin {
+  static isCoin(type) {
+    if (!type) {
+      return false;
+    }
+    return (0, import_utils.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) != null;
+  }
+  static getCoinType(type) {
+    const [, res] = (0, import_utils.normalizeStructTag)(type).match(COIN_TYPE_ARG_REGEX) ?? [];
+    return res || null;
+  }
+  static getBalance(data) {
+    if (!_Coin.isCoin(data.type)) {
+      return void 0;
+    }
+    if (data.content?.dataType !== "moveObject") {
+      return void 0;
+    }
+    const { balance } = data.content?.fields;
+    if (balance === void 0) {
+      return void 0;
+    }
+    return BigInt(balance);
+  }
+};
+
+// src/utils/format.ts
+var Formatter = class {
+  static normalizeSuiAddress(addr) {
+    return (0, import_utils2.normalizeSuiAddress)(addr);
+  }
+  static normalizeStructTag(struct) {
+    return (0, import_utils2.normalizeStructTag)(struct);
+  }
+  static isSuiAddressEqual(addr1, addr2) {
+    return (0, import_utils2.normalizeSuiAddress)(addr1) === (0, import_utils2.normalizeSuiAddress)(addr2);
+  }
+  static isSuiStructEqual(struct1, struct2) {
+    return (0, import_utils2.normalizeStructTag)(struct1) === (0, import_utils2.normalizeStructTag)(struct2);
+  }
+  static isCoinObjectType(struct) {
+    return Coin.isCoin(struct);
+  }
+};
+
+// src/utils/sui.ts
+var import_cryptography2 = require("@mysten/sui.js/cryptography");
+var import_multisig = require("@mysten/sui.js/multisig");
+
+// src/utils/crypto.ts
+var import_cryptography = require("@mysten/sui.js/cryptography");
+var import_ed25519 = require("@mysten/sui.js/keypairs/ed25519");
+var import_secp256k1 = require("@mysten/sui.js/keypairs/secp256k1");
+var import_secp256r1 = require("@mysten/sui.js/keypairs/secp256r1");
+var import_verify = require("@mysten/sui.js/verify");
+
+// src/utils/buffer.ts
+function stringToBuffer(s) {
+  return Buffer.from(s, "utf-8");
+}
+function Uint8ArrayToHex(b) {
+  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
+}
+function HexToUint8Array(hex) {
+  return Uint8Array.from(Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
+}
+
+// src/utils/crypto.ts
+var SignatureVerifier = class _SignatureVerifier {
+  static async getPublicKeyFromSignature(input) {
+    if (input.messageType === "TransactionBlock") {
+      return (0, import_verify.verifyTransactionBlock)(input.message, input.signature);
+    }
+    return (0, import_verify.verifyPersonalMessage)(input.message, input.signature);
+  }
+  static async getPublicKeyFromPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.getPublicKeyFromSignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature
+    });
+  }
+  static async verifySignature(input) {
+    const publicKey = await _SignatureVerifier.getPublicKeyFromSignature(input);
+    return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
+  }
+  static async verifyPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.verifySignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
+  }
+  static async verifyTransactionSignature(input) {
+    return this.verifySignature({
+      messageType: "TransactionBlock",
+      message: input.payload,
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
+  }
+};
+var PublicKeySerde = class {
+  static ser(publicKey) {
+    return {
+      publicKey: publicKey.toBase64(),
+      scheme: import_cryptography.SIGNATURE_FLAG_TO_SCHEME[publicKey.flag()]
+    };
+  }
+  static de(input) {
+    switch (input.scheme) {
+      case "ED25519":
+        return new import_ed25519.Ed25519PublicKey(input.publicKey);
+      case "Secp256k1":
+        return new import_secp256k1.Secp256k1PublicKey(input.publicKey);
+      case "Secp256r1":
+        return new import_secp256r1.Secp256r1PublicKey(input.publicKey);
+      default:
+        throw new Error("Unsupported signature scheme: $input.scheme");
+    }
+  }
+};
+
+// src/utils/sui.ts
+var SUI_COIN = "0x2::sui::SUI";
+async function getPublicKeyFromChain(suiClient, address) {
+  let txs;
+  try {
+    txs = await suiClient.queryTransactionBlocks({
+      // Disable naming rule since the variable is defined by Mysten
+      filter: { FromAddress: address },
+      options: { showInput: true },
+      limit: 2
+    });
+  } catch (e) {
+    return void 0;
+  }
+  if (txs.data.length === 0 || !txs.data[0].transaction?.txSignatures) {
+    return void 0;
+  }
+  const tx = txs.data[0];
+  const signatures = tx.transaction?.txSignatures;
+  for (let i = 0; i !== signatures.length; i++) {
+    const serializedSig = signatures[i];
+    const pk = getAddressFromSignatures(serializedSig, address);
+    if (!pk) {
+      continue;
+    }
+    return pk;
+  }
+  return void 0;
+}
+function getAddressFromSignatures(serializedSig, targetAddress) {
+  const decoded = (0, import_cryptography2.parseSerializedSignature)(serializedSig);
+  switch (decoded.signatureScheme) {
+    case "MultiSig": {
+      const multiSigAddress = new import_multisig.MultiSigPublicKey(decoded.multisig.multisig_pk).toSuiAddress();
+      if (Formatter.isSuiAddressEqual(multiSigAddress, targetAddress)) {
+        throw new Error("multi-sig wallet cannot be owner");
+      }
+      return void 0;
+    }
+    case "ZkLogin": {
+      if (Formatter.isSuiAddressEqual(decoded.zkLogin.address, targetAddress)) {
+        throw new Error("ZkLogin wallet cannot be owner");
+      }
+      return void 0;
+    }
+    case "ED25519":
+    case "Secp256k1":
+    case "Secp256r1": {
+      const pk = PublicKeySerde.de({ publicKey: decoded.publicKey, scheme: decoded.signatureScheme });
+      if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
+        return pk;
+      }
+      return void 0;
+    }
+    default:
+      throw new Error("Unknown schema");
+  }
+}
+async function getAllCoins(input) {
+  let hasNext = true;
+  let cursor;
+  const res = [];
+  while (hasNext) {
+    const currentPage = await input.suiClient.getCoins({
+      owner: input.owner,
+      coinType: input.coinType,
+      cursor
+    });
+    res.push(...currentPage.data);
+    hasNext = currentPage.hasNextPage;
+    cursor = currentPage.nextCursor;
+  }
+  return res;
+}
+
+// src/transactions/coin-transfer.ts
+async function buildCoinTransferTxb(input) {
+  if (Formatter.isSuiStructEqual(input.intention.coinType, SUI_COIN)) {
+    return buildSuiCoinTransferTxb(input);
+  }
+  return buildOtherCoinTransferTxb(input);
+}
+function buildSuiCoinTransferTxb(input) {
+  const txb = new import_transactions.TransactionBlock();
+  const [coin] = txb.splitCoins(txb.gas, [txb.pure(input.intention.amount)]);
+  txb.transferObjects([coin], txb.pure(input.intention.recipient));
+  txb.setSender(input.sender);
+  return txb;
+}
+async function buildOtherCoinTransferTxb(input) {
+  const { suiClient, sender, intention } = input;
+  const objs = await getAllCoins({
+    suiClient,
+    owner: sender,
+    coinType: intention.coinType
+  });
+  if (objs.length === 0) {
+    throw new Error("No valid coin found to send");
+  }
+  const totalBal = objs.reduce((sum, coin2) => sum + BigInt(coin2.balance), 0n);
+  if (totalBal < BigInt(intention.amount)) {
+    throw new Error("Not enough balance");
+  }
+  const txb = new import_transactions.TransactionBlock();
+  const primary = txb.object(objs[0].coinObjectId);
+  if (objs.length > 1) {
+    txb.mergeCoins(
+      primary,
+      objs.slice(1).map((obj) => txb.object(obj.coinObjectId))
+    );
+  }
+  const [coin] = txb.splitCoins(primary, [txb.pure(intention.amount)]);
+  txb.transferObjects([coin], txb.pure(intention.recipient));
+  txb.setSender(input.sender);
+  return txb;
+}
+
+// src/transactions/object-transfer.ts
+var import_transactions2 = require("@mysten/sui.js/transactions");
+async function buildObjectTransferTxb(input) {
+  await validateObjectTransfer(input);
+  const txb = new import_transactions2.TransactionBlock();
+  txb.transferObjects([txb.object(input.intention.objectId)], txb.pure(input.intention.receiver));
+  txb.setSender(input.sender);
+  return txb;
+}
+async function validateObjectTransfer(input) {
+  const { suiClient, sender, intention } = input;
+  const obj = await suiClient.getObject({
+    id: intention.objectId
+  });
+  if (obj.data === void 0) {
+    throw new Error("Object not found");
+  }
+  if (!obj.data?.type) {
+    throw new Error("Object type is null");
+  }
+  if (!Formatter.isSuiStructEqual(obj.data.type, intention.objectType)) {
+    throw new Error("Object type not expected");
+  }
+  if (Formatter.isCoinObjectType(obj.data.type)) {
+    throw new Error("Can not transfer coin object in Object Transfer transactions");
+  }
+  const addressOwner = getAddressOwner(obj);
+  if (!Formatter.isSuiAddressEqual(addressOwner, sender)) {
+    throw new Error("Object owner not match");
+  }
+}
+function getAddressOwner(object) {
+  const owner = object.data?.owner;
+  if (!owner) {
+    throw new Error("Object Owner not found");
+  }
+  if (typeof owner !== "object" || !("AddressOwner" in owner)) {
+    throw new Error("Invalid object owner");
+  }
+  return owner.AddressOwner;
+}
+
+// src/transactions/reject.ts
+var import_transactions3 = require("@mysten/sui.js/transactions");
+async function buildRejectTxb(input) {
+  const approveTxb = import_transactions3.TransactionBlock.from(HexToUint8Array(input.payloadToReject));
+  const gasPayment = approveTxb.blockData.gasConfig.payment;
+  if (!gasPayment) {
+    throw new Error("No gas payment found for approve payload");
+  }
+  const txb = new import_transactions3.TransactionBlock();
+  txb.setGasPayment(gasPayment);
+  txb.setSender(input.sender);
+  return txb;
+}
+
+// src/transactions/intention.ts
+var IntentionHelper = class {
+  static ser(intention) {
+    return JSON.stringify(intention);
+  }
+  static de(val) {
+    const intention = JSON.parse(val);
+    if (typeof intention !== "object" || !("txType" in intention)) {
+      throw new Error(`Failed to deserialize intention: ${val}`);
+    }
+    return JSON.parse(val);
+  }
+  // TODO: Add gas option here.
+  static buildTxb(input) {
+    switch (input.intention.txType) {
+      case "CoinTransfer":
+        return buildCoinTransferTxb({
+          suiClient: input.suiClient,
+          sender: input.sender,
+          intention: input.intention
+        });
+      case "ObjectTransfer":
+        return buildObjectTransferTxb({
+          suiClient: input.suiClient,
+          sender: input.sender,
+          intention: input.intention
+        });
+      default:
+        throw new Error(`Unknown tx type: ${input.intention}`);
+    }
+  }
+  static getTxType(intention) {
+    switch (intention.txType) {
+      case "CoinTransfer":
+        return {
+          txType: "CoinTransfer",
+          txSubType: "CoinTransfer"
+        };
+      case "ObjectTransfer":
+        return {
+          txType: "ObjectTransfer",
+          txSubType: "ObjectTransfer"
+        };
+      default:
+        throw new Error("Unknown intention type");
+    }
+  }
+  static buildRejectTransaction(input) {
+    return buildRejectTxb({ sender: input.msafeAddress, payloadToReject: input.payloadToReject });
+  }
+};
+
+// src/core/MessageHelper.ts
+var MessageHelper = class {
+  // Message used for MSafe creation
+  static createMSafeMessage(msafeAddress) {
+    return `Create MSafe Account: ${msafeAddress}`;
+  }
+  static deCreateMSafeMessage(msg) {
+    const regex = /Create MSafe Account: (.+)/;
+    const matches = msg.match(regex);
+    return matches ? matches[1] : void 0;
+  }
+  // Message to be used when user login. The timestamp string
+  // is used to for extra validation.
+  static welcomeMessage(timestamp) {
+    return `Welcome to MSafe. ${timestamp}`;
+  }
+  static deWelcomeMessage(msg) {
+    const regex = /Welcome to MSafe. (.+)/;
+    const matches = msg.match(regex);
+    return matches ? matches[1] : void 0;
+  }
+  static proposeIntentionMessage(data) {
+    const { intention, sn } = data;
+    const intentionData = IntentionHelper.ser(intention);
+    const msg = {
+      intentionData,
+      sequenceNumber: sn
+    };
+    return JSON.stringify(msg);
+  }
+  static deProposeIntentionMessage(s) {
+    const de = JSON.parse(s);
+    if (!("intentionData" in de) || typeof de.intentionData !== "string" || !("sequenceNumber" in de) || typeof de.sequenceNumber !== "number") {
+      throw new Error("Invalid intention data");
+    }
+    const { sequenceNumber, intentionData } = de;
+    return {
+      sn: sequenceNumber,
+      intention: IntentionHelper.de(intentionData)
+    };
+  }
+};
+
+// src/utils/multi-sig.ts
+var import_ed255192 = require("@mysten/sui.js/keypairs/ed25519");
+var import_multisig2 = require("@mysten/sui.js/multisig");
+var NONCE_PK_PREFIX = "maven";
+var NONCE_PREFIX_MAX_SIZE = 16;
+var NONCE_PK_WEIGHT = 1;
+var MAX_WEIGHT = 255;
+var MIN_WEIGHT = 1;
+var MAX_OWNER_WITH_NONCE = 9;
+var MAX_OWNER_WITHOUT_NONCE = 10;
+var MIN_THRESHOLD = 1;
+var RawMultiSig = class _RawMultiSig {
+  constructor(config) {
+    this.config = config;
+    this.rawMsPK = getMultiSigPublicKey(config);
+  }
+  rawMsPK;
+  static fromMSafeAccountInfo(info) {
+    const parsed = {
+      threshold: info.threshold,
+      ownerWithWeight: info.ownersWithWeightPK,
+      creationNonce: info.creationNonce
+    };
+    return new _RawMultiSig(parsed);
+  }
+  get suiAddress() {
+    return this.rawMsPK.toSuiAddress();
+  }
+  get publicKeys() {
+    return this.rawMsPK.getPublicKeys();
+  }
+  get threshold() {
+    return this.config.threshold;
+  }
+  combinePartialSignatures(signatures) {
+    return this.rawMsPK.combinePartialSignatures(signatures);
+  }
+  async verifyPersonalMessage(messageStr, multiSigSignature) {
+    const message = stringToBuffer(messageStr);
+    return this.rawMsPK.verifyPersonalMessage(message, multiSigSignature);
+  }
+};
+function getMultiSigPublicKey(config) {
+  const { ownerWithWeight, threshold, creationNonce } = config;
+  const pks = ownerWithWeight.map((pk) => ({
+    publicKey: pk.publicKey,
+    weight: pk.weight
+  }));
+  if (creationNonce !== void 0) {
+    pks.push({
+      publicKey: makeNoncePublicKey(creationNonce),
+      weight: NONCE_PK_WEIGHT
+    });
+  }
+  return import_multisig2.MultiSigPublicKey.fromPublicKeys({ threshold, publicKeys: pks });
+}
+function makeNoncePublicKey(nonce) {
+  const buffer = new ArrayBuffer(import_ed255192.Ed25519PublicKey.SIZE);
+  const textEncoder = new TextEncoder();
+  textEncoder.encodeInto(NONCE_PK_PREFIX, new Uint8Array(buffer, 0, NONCE_PREFIX_MAX_SIZE));
+  const nonceView = new DataView(buffer, NONCE_PREFIX_MAX_SIZE, 4);
+  nonceView.setUint32(0, nonce, true);
+  return new import_ed255192.Ed25519PublicKey(new Uint8Array(buffer));
+}
+function validateMultiSigConfig(config) {
+  config.ownerWithWeight.forEach((pk) => {
+    const { weight } = pk;
+    if (weight < MIN_WEIGHT || weight > MAX_WEIGHT) {
+      throw new Error(`Invalid multi-sig weight: ${weight} (1-${MAX_WEIGHT})`);
+    }
+  });
+  const totalWeight = config.ownerWithWeight.reduce((s, pk) => s + pk.weight, 0);
+  if (config.threshold > totalWeight) {
+    throw new Error("Threshold is larger than total weight");
+  }
+  if (config.threshold < MIN_THRESHOLD) {
+    throw new Error("Threshold is smaller than 1");
+  }
+  const maxOwner = config.creationNonce === void 0 ? MAX_OWNER_WITHOUT_NONCE : MAX_OWNER_WITH_NONCE;
+  if (config.ownerWithWeight.length > maxOwner) {
+    throw new Error("Owner number bigger than upper cap");
+  }
+  const addressSet = new Set(config.ownerWithWeight.map((pk) => pk.publicKey.toSuiAddress()));
+  if (addressSet.size !== config.ownerWithWeight.length) {
+    throw new Error("Duplicate address detected");
+  }
+}
+
+// src/core/CreateHelper.ts
+var CreateHelper = class {
+  constructor(globals, pkHelper) {
+    this.globals = globals;
+    this.pkHelper = pkHelper;
+  }
+  async getPublicKeyBatch(addresses) {
+    return this.pkHelper.getPublicKeyBatch(addresses);
+  }
+  async calculateMSafeAddress(info) {
+    const msConfig = await this.reduceCreationInfoToRawConfig(info);
+    const ms = new RawMultiSig(msConfig);
+    return ms.suiAddress;
+  }
+  // Validate the create info and return the msafe address.
+  async validateCreateInfo(createInfo) {
+    const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
+    validateMultiSigConfig(rawConfig);
+    return this.calculateMSafeAddress(createInfo);
+  }
+  async submitMSafeCreation(creationInfo) {
+    const msafeAddress = await this.validateCreateInfo(creationInfo);
+    const signingMessage = MessageHelper.createMSafeMessage(msafeAddress);
+    const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
+    await this.submitToBackend(creationInfo, signature.signature);
+    return msafeAddress;
+  }
+  async reduceCreationInfoToRawConfig(info) {
+    const publicKeys = await this.getPublicKeyBatch(info.ownerWithWeight.map((oww) => oww.address));
+    publicKeys.forEach((pk, i) => {
+      if (pk === void 0) {
+        throw new Error(`Unknown public key for address: ${info.ownerWithWeight[i].address}`);
+      }
+    });
+    return {
+      threshold: info.threshold,
+      ownerWithWeight: info.ownerWithWeight.map((owner, i) => ({
+        publicKey: publicKeys[i],
+        weight: owner.weight
+      })),
+      creationNonce: info.creationNonce
+    };
+  }
+  async submitToBackend(createInfo, signature) {
+    const pks = await this.pkHelper.getPublicKeyBatch(createInfo.ownerWithWeight.map((owner) => owner.address));
+    await this.globals.backend.createMSafeAccount({
+      ownerWithWeight: createInfo.ownerWithWeight.map((owner, i) => ({
+        address: owner.address,
+        weight: owner.weight,
+        publicKey: pks[i]
+        // PublicKey has been verified.
+      })),
+      threshold: createInfo.threshold,
+      name: createInfo.name,
+      // name validation is deferred to backend
+      description: createInfo.description,
+      // description validation is deferred to backend
+      creationNonce: createInfo.creationNonce,
+      signature
+    });
+  }
+};
+
+// src/core/MSafeAccount.ts
+var MSafeAccount = class _MSafeAccount {
+  constructor(globals, info) {
+    this.globals = globals;
+    this.info = info;
+    this.rawMultiSig = RawMultiSig.fromMSafeAccountInfo(info);
+  }
+  rawMultiSig;
+  static async new(globals, address) {
+    const info = await globals.backend.getMSafeAccountInfo(address);
+    return new _MSafeAccount(globals, info);
+  }
+  async pendingTransactions() {
+    return this.backend.getPendingTransactions(this.address);
+  }
+  async historyTransaction() {
+    return this.backend.getHistoryTransactions(this.address);
+  }
+  async futureIntentions() {
+    return this.backend.getFutureIntentions(this.address);
+  }
+  async currentSequenceNumber() {
+    return this.backend.getCurrentSequenceNumber(this.address);
+  }
+  async nextSequenceNumber() {
+    return this.backend.getNextSequenceNumber(this.address);
+  }
+  async proposeIntention(intention, sequenceNumber) {
+    const message = MessageHelper.proposeIntentionMessage({ intention, sn: sequenceNumber });
+    const signature = await this.wallet.signPersonalMessage({
+      messageStr: message
+    });
+    await this.backend.proposeIntention({
+      intention,
+      sequenceNumber,
+      msafeAddress: this.address,
+      userAddress: await this.userAddress(),
+      signature: signature.signature
+    });
+  }
+  async voteForTransaction(digest, payload) {
+    const payloadBytes = HexToUint8Array(payload);
+    const signature = await this.wallet.signTransactionBlock({ transactionBlock: payloadBytes });
+    return this.backend.voteForTransaction({
+      msafeAddress: this.address,
+      userAddress: await this.userAddress(),
+      txDigest: digest,
+      signature: signature.signature
+    });
+  }
+  // Shortcut for proposing a transaction to be a pending transaction, and add user vote to it.
+  // Requires the multi-sig to be empty in pending transaction.
+  async proposePendingTransaction(intention) {
+    const txb = await IntentionHelper.buildTxb({
+      suiClient: this.suiClient,
+      intention,
+      sender: this.address
+    });
+    const payload = await txb.build({ client: this.suiClient });
+    const digest = await txb.getDigest({ client: this.suiClient });
+    const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
+    return this.backend.proposePendingTransaction({
+      msafeAddress: this.address,
+      userAddress: await this.userAddress(),
+      intention,
+      digest,
+      signature: signature.signature
+    });
+  }
+  async rejectCurrentTx(pending) {
+    let payloadToReject;
+    if (pending) {
+      if (pending.isRejectTx) {
+        throw new Error("Pending not reject transaction");
+      }
+      payloadToReject = pending.payload;
+    } else {
+      const pendings = await this.pendingTransactions();
+      if (pendings.length !== 1 || pendings[0].isRejectTx) {
+        throw new Error("Already rejected");
+      }
+      payloadToReject = pendings[0].payload;
+    }
+    const rejectTxb = await IntentionHelper.buildRejectTransaction({
+      msafeAddress: this.address,
+      payloadToReject
+    });
+    const digest = await rejectTxb.getDigest({ client: this.suiClient });
+    const payload = await rejectTxb.build({ client: this.suiClient });
+    const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
+    return this.backend.rejectCurrentTx({
+      msafeAddress: this.address,
+      userAddress: await this.userAddress(),
+      digest,
+      signature: signature.signature
+    });
+  }
+  async buildNextIntentionAndAddToPending() {
+    return this.backend.buildNextIntentionAndAddToPending({ msafeAddress: this.address });
+  }
+  async skipNextFailedIntention() {
+    return this.backend.skipNextFailedIntention({ msafeAddress: this.address, userAddress: await this.userAddress() });
+  }
+  async executePendingTx(pending) {
+    if (pending.votes.length < this.info.threshold) {
+      throw new Error("Not enough signatures");
+    }
+    const sigs = [];
+    const gotSigs = new Map(pending.votes.map((vote) => [vote.userAddress, vote.signature]));
+    for (let i = 0; i < this.info.ownersWithWeightPK.length; i++) {
+      const owner = this.info.ownersWithWeightPK[i];
+      const signature = gotSigs.get(owner.publicKey.toSuiAddress());
+      if (signature) {
+        sigs.push(signature);
+      }
+    }
+    const multiSignature = this.rawMultiSig.combinePartialSignatures(sigs);
+    return this.suiClient.executeTransactionBlock({
+      transactionBlock: HexToUint8Array(pending.payload),
+      signature: multiSignature,
+      options: { showEffects: true }
+    });
+  }
+  get address() {
+    return this.info.address;
+  }
+  get backend() {
+    return this.globals.backend;
+  }
+  get wallet() {
+    return this.globals.wallet;
+  }
+  async userAddress() {
+    return this.globals.wallet.address();
+  }
+  get suiClient() {
+    return this.globals.suiClient;
+  }
+};
+
+// src/core/PublicKeyHelper.ts
+var PublicKeyHelper = class {
+  constructor(globals) {
+    this.globals = globals;
+    this.knownPublicKeys = /* @__PURE__ */ new Map();
+  }
+  knownPublicKeys;
+  async getPublicKey(address) {
+    const cached = this.knownPublicKeys.get(address);
+    if (cached) {
+      return cached;
+    }
+    const pk = await this._getPublicKey(address);
+    if (pk) {
+      this.knownPublicKeys.set(address, pk);
+    }
+    return pk;
+  }
+  async getPublicKeyBatch(addresses) {
+    const results = new Array(addresses.length).fill(void 0);
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      results[i] = this.knownPublicKeys.get(address);
+    }
+    const emptyIndexes = results.map((elem, index) => elem === void 0 ? index : -1).filter((index) => index !== -1);
+    const backendResult = await this.globals.backend.getPublicKeyBatch(emptyIndexes.map((index) => addresses[index]));
+    for (let i = 0; i < emptyIndexes.length; i++) {
+      const index = emptyIndexes[i];
+      results[index] = backendResult[i];
+    }
+    for (let i = 0; i < results.length; i++) {
+      if (results[i] === void 0) {
+        results[i] = await this.getPublicKeyFromChain(addresses[i]);
+      }
+    }
+    for (let i = 0; i < addresses.length; i++) {
+      if (results[i]) {
+        this.knownPublicKeys.set(addresses[i], results[i]);
+      }
+    }
+    return results;
+  }
+  async _getPublicKey(address) {
+    const pkBackend = await this.getPublicKeyFromBackend(address);
+    if (pkBackend) {
+      return pkBackend;
+    }
+    const pkChain = await this.getPublicKeyFromChain(address);
+    if (pkChain) {
+      return pkChain;
+    }
+    return void 0;
+  }
+  async getPublicKeyFromBackend(address) {
+    try {
+      const pk = await this.globals.backend.getPublicKey(address);
+      return pk;
+    } catch (_) {
+      return void 0;
+    }
+  }
+  async getPublicKeyFromChain(address) {
+    return getPublicKeyFromChain(this.globals.suiClient, address);
+  }
+};
+
+// src/globals/MSafeGlobals.ts
+var import_client = require("@mysten/sui.js/client");
+
+// src/backend/PseudoBackend.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+var import_typeorm = require("typeorm");
+
+// src/backend/CoreDatabase.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_core = require("@msafe/sui3-model/core");
+var WALLET_TYPE_KEY = "wallet_type";
+var CoreDB = class _CoreDB {
+  constructor(coreModel) {
+    this.coreModel = coreModel;
+  }
+  static async New(dbConfig) {
+    const core = await import_core.CoreModel.New(dbConfig);
+    return new _CoreDB(core);
+  }
+  async upsertUser(input) {
+    const currentUser = await this.coreModel.user.findOneBy({
+      address: input.address
+    });
+    if (currentUser !== null) {
+      currentUser.lastLogin = input.lastLogin;
+      await this.coreModel.user.save(currentUser);
+    } else {
+      const serializedPublicKey = PublicKeySerde.ser(input.publicKey);
+      const user = {
+        address: input.address,
+        publicKey: serializedPublicKey.publicKey,
+        schema: serializedPublicKey.scheme,
+        nonce: 0,
+        lastLogin: /* @__PURE__ */ new Date()
+      };
+      await this.coreModel.user.save(user);
+    }
+  }
+  async updateUserWalletType(input) {
+    const exist = await this.coreModel.userSetting.findOneBy({
+      userAddress: input.address,
+      key: WALLET_TYPE_KEY
+    });
+    const walletType = input.walletType.trim();
+    if (exist === null || exist.value !== walletType) {
+      const userSetting = {
+        userAddress: input.address,
+        key: WALLET_TYPE_KEY,
+        value: walletType
+      };
+      await this.coreModel.userSetting.save(userSetting);
+    }
+  }
+};
+
+// src/backend/PseudoBackend.ts
+var PseudoBackend = class _PseudoBackend {
+  constructor(db, _suiClient) {
+    this.db = db;
+    this._suiClient = _suiClient;
+  }
+  _token;
+  static async New(dbConfig, suiClient) {
+    const db = await CoreDB.New(dbConfig);
+    return new _PseudoBackend(db, suiClient);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
+  async isJWTTokenValid(_jwt) {
+    return true;
+  }
+  async authSign(input) {
+    const timestamp = MessageHelper.deWelcomeMessage(input.message);
+    if (!timestamp) {
+      throw new Error("Invalid welcome message");
+    }
+    const date = Date.parse(timestamp);
+    if ((/* @__PURE__ */ new Date()).getTime() - date < 0) {
+      throw new Error("Invalid timestamp");
+    }
+    if ((/* @__PURE__ */ new Date()).getTime() - date > 10 * 1e3) {
+      throw new Error("Signing message expired");
+    }
+    const publicKey = await SignatureVerifier.getPublicKeyFromPersonalSignature({
+      messageStr: input.message,
+      signature: input.signature
+    });
+    if (!Formatter.isSuiAddressEqual(input.address, publicKey.toSuiAddress())) {
+      throw new Error("Invalid signature");
+    }
+    await this.db.upsertUser({
+      address: input.address,
+      publicKey,
+      lastLogin: /* @__PURE__ */ new Date()
+    });
+    await this.db.updateUserWalletType({
+      address: input.address,
+      walletType: input.walletType
+    });
+    this._token = "";
+    return this._token;
+  }
+  setJWTToken(token) {
+    this._token = token;
+  }
+  async getPublicKey(address) {
+    const user = await this.model.user.findOneBy({
+      address
+    });
+    if (user === null) {
+      return void 0;
+    }
+    return PublicKeySerde.de({
+      publicKey: user.publicKey,
+      scheme: user.schema
+    });
+  }
+  async getPublicKeyBatch(addresses) {
+    const res = [];
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      const user = await this.getUser(address);
+      res.push(
+        user ? PublicKeySerde.de({
+          publicKey: user.publicKey,
+          scheme: user.schema
+        }) : void 0
+      );
+    }
+    return res;
+  }
+  async createMSafeAccount(input) {
+    const ms = new RawMultiSig(input);
+    const msafeAddr = ms.suiAddress;
+    const signingMsg = MessageHelper.createMSafeMessage(msafeAddr);
+    const targetAddr = input.ownerWithWeight[0].address;
+    const verifyResult = await SignatureVerifier.verifyPersonalSignature({
+      messageStr: signingMsg,
+      signature: input.signature,
+      targetAddress: targetAddr
+    });
+    if (!verifyResult) {
+      throw new Error("Signature verification failed");
+    }
+    if (input.name.length > 128) {
+      throw new Error("Name too long");
+    }
+    if (input.description && input.description.length > 512) {
+      throw new Error("Description too long");
+    }
+    const creatorAddress = input.ownerWithWeight[0].address;
+    const creator = await this.getUser(creatorAddress);
+    if (creator === null) {
+      throw new Error("Creator not found");
+    }
+    if (creator.nonce !== input.creationNonce) {
+      throw new Error("Nonce not match");
+    }
+    const msafeExistCheck = await this.model.msafe.findOneBy({
+      address: msafeAddr
+    });
+    if (msafeExistCheck !== null) {
+      throw new Error("MSafe already exist in database");
+    }
+    input.ownerWithWeight.forEach((ownerInfo) => {
+      if (!Formatter.isSuiAddressEqual(ownerInfo.address, ownerInfo.publicKey.toSuiAddress())) {
+        throw new Error("Sui address public key not match");
+      }
+    });
+    for (let i = 0; i !== input.ownerWithWeight.length; i++) {
+      const ownerInfo = input.ownerWithWeight[i];
+      if (i !== 0) {
+        const coManager = await this.getUser(ownerInfo.address);
+        const serPK = PublicKeySerde.ser(ownerInfo.publicKey);
+        if (coManager === null) {
+          const user = {
+            address: ownerInfo.address,
+            publicKey: serPK.publicKey,
+            schema: serPK.scheme,
+            nonce: 0,
+            lastLogin: /* @__PURE__ */ new Date()
+          };
+          await this.model.user.save(user);
+        }
+      }
+      const userMSafe = {
+        userAddress: ownerInfo.address,
+        msafeAddress: msafeAddr,
+        index: i,
+        weight: ownerInfo.weight,
+        status: i === 0 ? "active" : "pending"
+      };
+      await this.model.userMSafe.save(userMSafe);
+    }
+    const creationNonce = creator.nonce;
+    creator.nonce++;
+    await this.model.user.save(creator);
+    const msafe = {
+      address: msafeAddr,
+      creationNonce,
+      creator: creatorAddress,
+      name: input.name,
+      description: input.description,
+      threshold: input.threshold
+    };
+    await this.model.msafe.save(msafe);
+  }
+  async getMSafeAccountInfo(msafeAddress) {
+    const msafe = await this.model.msafe.findOneBy({ address: msafeAddress });
+    if (msafe === null) {
+      throw new Error("MSafe not found");
+    }
+    const userMSafes = await this.model.userMSafe.find({
+      where: {
+        msafeAddress
+      },
+      order: {
+        index: "asc"
+      }
+    });
+    if (userMSafes.length === 0) {
+      throw new Error("MSafe does not have user info.");
+    }
+    const users = await Promise.all(userMSafes.map((um) => this.getUser(um.userAddress)));
+    users.forEach((user) => {
+      if (user === null) {
+        throw new Error("User not found");
+      }
+    });
+    const ownersWithWeightPK = userMSafes.map((userMSafe, i) => ({
+      address: userMSafe.userAddress,
+      weight: userMSafe.weight,
+      publicKey: PublicKeySerde.de({ publicKey: users[i].publicKey, scheme: users[i].schema })
+    }));
+    return {
+      address: msafeAddress,
+      ownersWithWeightPK,
+      threshold: msafe.threshold,
+      name: msafe.name,
+      description: msafe.description,
+      creationNonce: msafe.creationNonce
+    };
+  }
+  async getUserInfo(userAddress) {
+    const user = await this.getUser(userAddress);
+    if (user === null) {
+      throw new Error("404: user not found");
+    }
+    const msafeAccounts = await this.model.userMSafe.findBy({ userAddress });
+    const ownedMSafe = await Promise.all(
+      msafeAccounts.map(async (msafeAccount) => this.getMSafeAccountInfo(msafeAccount.msafeAddress))
+    );
+    return {
+      address: userAddress,
+      publicKey: user.publicKey,
+      schema: user.schema,
+      creationNonce: user.nonce,
+      ownedMSafe
+    };
+  }
+  async getPendingTransactions(msafeAddress) {
+    const pendings = await this.db.coreModel.pendingTransaction.findBy({
+      msafeAddress
+    });
+    if (pendings.length === 0) {
+      return [];
+    }
+    const votes = await Promise.all(
+      pendings.map((pending) => this.db.coreModel.userVote.findBy({ txDigest: pending.digest, isValid: true }))
+    );
+    const intention = await this.model.transactionIntention.findOneBy({
+      msafeAddress,
+      sequenceNumber: pendings[0].sequenceNumber
+    });
+    if (intention === null) {
+      throw new Error("Intention not found");
+    }
+    const intent = IntentionHelper.de(intention.data);
+    return pendings.map((pending, i) => ({
+      digest: pending.digest,
+      payload: pending.payload,
+      msafeAddress: pending.msafeAddress,
+      isRejectTx: pending.isRejectTx,
+      creator: pending.creator,
+      createdAt: pending.createdAt,
+      votes: votes[i].map((vote) => ({
+        userAddress: vote.userAddress,
+        signature: vote.signature,
+        timestamp: vote.updatedAt
+      })),
+      sequenceNumber: pending.sequenceNumber,
+      intention: pending.isRejectTx ? void 0 : intent
+    }));
+  }
+  async getCurrentSequenceNumber(msafeAddress) {
+    const maxSNHistory = await this.model.historyTransaction.findOne({
+      where: { msafeAddress },
+      order: { sequenceNumber: "desc" }
+    });
+    return maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
+  }
+  async getNextSequenceNumber(msafeAddress) {
+    const maxSNIntention = await this.model.transactionIntention.findOne({
+      where: { msafeAddress },
+      order: { sequenceNumber: "desc" }
+    });
+    return maxSNIntention === null ? 0 : maxSNIntention.sequenceNumber + 1;
+  }
+  async getHistoryTransactions(msafeAddress) {
+    const transactions = await this.db.coreModel.historyTransaction.find({
+      where: {
+        msafeAddress
+      },
+      order: { sequenceNumber: "desc" }
+    });
+    const votes = await Promise.all(
+      transactions.map(
+        (tx) => this.db.coreModel.userVote.findBy({
+          txDigest: tx.digest,
+          isValid: true
+        })
+      )
+    );
+    return transactions.map((tx, i) => ({
+      digest: tx.digest,
+      payload: tx.payload,
+      msafeAddress: tx.msafeAddress,
+      isRejectTx: tx.isRejectTx,
+      status: tx.status,
+      creator: tx.creator,
+      createdAt: tx.createdAt,
+      sequenceNumber: tx.sequenceNumber,
+      votes: votes[i].map((vote) => ({
+        userAddress: vote.userAddress,
+        timestamp: vote.updatedAt
+      }))
+    }));
+  }
+  async getFutureIntentions(msafeAddress) {
+    const currentSequenceNumber = await this.getCurrentSequenceNumber(msafeAddress);
+    const hasPending = await this.model.pendingTransaction.findOneBy({ msafeAddress }) !== null;
+    const futureSNStart = hasPending ? currentSequenceNumber + 1 : currentSequenceNumber;
+    const futureTxs = await this.model.transactionIntention.find({
+      where: { msafeAddress, sequenceNumber: (0, import_typeorm.MoreThanOrEqual)(futureSNStart) },
+      order: { sequenceNumber: "asc" }
+    });
+    return futureTxs.map((tx) => ({
+      intention: IntentionHelper.de(tx.data),
+      msafeAddress: tx.msafeAddress,
+      sequenceNumber: tx.sequenceNumber,
+      rawData: tx.data,
+      txType: tx.txType,
+      txSubType: tx.txSubType,
+      status: tx.status,
+      statusRemark: tx.statusRemark,
+      creator: tx.creator,
+      createdAt: tx.createdAt
+    }));
+  }
+  async proposeIntention(input) {
+    const userMSafe = await this.model.userMSafe.findOneBy({
+      msafeAddress: input.msafeAddress,
+      userAddress: input.userAddress
+    });
+    if (!userMSafe) {
+      throw new Error("User does not have permission to propose intention");
+    }
+    const verified = await SignatureVerifier.verifyPersonalSignature({
+      messageStr: MessageHelper.proposeIntentionMessage({ intention: input.intention, sn: input.sequenceNumber }),
+      signature: input.signature,
+      targetAddress: input.userAddress
+    });
+    if (!verified) {
+      throw new Error("Invalid signature");
+    }
+    const sequenceNumber = await this.model.transactionIntention.count({
+      where: {
+        msafeAddress: input.msafeAddress
+      }
+    });
+    if (sequenceNumber !== input.sequenceNumber) {
+      throw new Error("Sequence number not expected");
+    }
+    const intention = {
+      msafeAddress: input.msafeAddress,
+      sequenceNumber,
+      ...IntentionHelper.getTxType(input.intention),
+      data: IntentionHelper.ser(input.intention),
+      status: "future",
+      creator: input.userAddress
+    };
+    await this.model.transactionIntention.save(intention);
+  }
+  // Propose a pending transaction. Require the msafe account
+  // Does not have any pending transactions.
+  async proposePendingTransaction(input) {
+    const userMSafe = await this.model.userMSafe.findOneBy({
+      msafeAddress: input.msafeAddress,
+      userAddress: input.userAddress
+    });
+    if (userMSafe === null) {
+      throw new Error("Unauthorized");
+    }
+    const msafePendings = await this.model.pendingTransaction.findBy({
+      msafeAddress: input.msafeAddress
+    });
+    if (msafePendings.length !== 0) {
+      throw new Error("Still have pending transaction");
+    }
+    const txb = await IntentionHelper.buildTxb({
+      suiClient: this._suiClient,
+      intention: input.intention,
+      sender: input.msafeAddress
+    });
+    const payload = await txb.build({ client: this._suiClient });
+    const txDigest = await txb.getDigest({ client: this._suiClient });
+    if (txDigest !== input.digest) {
+      throw new Error("Transaction digest un-match");
+    }
+    const verified = await SignatureVerifier.verifyTransactionSignature({
+      payload,
+      targetAddress: input.userAddress,
+      signature: input.signature
+    });
+    if (!verified) {
+      throw new Error("Failed to verify signature");
+    }
+    const maxSNHistory = await this.model.historyTransaction.findOne({
+      where: { msafeAddress: input.msafeAddress },
+      order: { sequenceNumber: "desc" }
+    });
+    const sequenceNumber = maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
+    const intention = {
+      msafeAddress: input.msafeAddress,
+      sequenceNumber,
+      ...IntentionHelper.getTxType(input.intention),
+      data: IntentionHelper.ser(input.intention),
+      status: "future",
+      creator: input.userAddress
+    };
+    await this.model.transactionIntention.save(intention);
+    const pendingTx = {
+      digest: txDigest,
+      msafeAddress: input.msafeAddress,
+      payload: Uint8ArrayToHex(payload),
+      sequenceNumber,
+      isRejectTx: false,
+      creator: input.userAddress
+    };
+    await this.model.pendingTransaction.save(pendingTx);
+    const userVote = {
+      userAddress: input.userAddress,
+      txDigest,
+      msafeAddress: input.msafeAddress,
+      signature: input.signature,
+      isValid: true
+    };
+    await this.model.userVote.save(userVote);
+  }
+  // Calls for the first reject transaction
+  async rejectCurrentTx(input) {
+    const userMSafe = await this.model.userMSafe.findOneBy({
+      userAddress: input.userAddress,
+      msafeAddress: input.msafeAddress
+    });
+    if (userMSafe === null) {
+      throw new Error("User does not have permission to MSafe");
+    }
+    const currentPending = await this.model.pendingTransaction.findOneBy({
+      msafeAddress: input.msafeAddress,
+      isRejectTx: false
+    });
+    if (currentPending === null) {
+      throw new Error("No active pending transaction");
+    }
+    const txb = await IntentionHelper.buildRejectTransaction({
+      msafeAddress: input.msafeAddress,
+      payloadToReject: currentPending.payload
+    });
+    const payload = await txb.build({ client: this._suiClient });
+    const digest = await txb.getDigest({ client: this._suiClient });
+    if (input.digest !== digest) {
+      throw new Error("Digest not match");
+    }
+    const verified = await SignatureVerifier.verifyTransactionSignature({
+      payload,
+      targetAddress: input.userAddress,
+      signature: input.signature
+    });
+    if (!verified) {
+      throw new Error("Signature unverified");
+    }
+    const existPendingReject = await this.model.pendingTransaction.findOneBy({
+      msafeAddress: input.msafeAddress,
+      isRejectTx: true
+    });
+    if (existPendingReject !== null) {
+      await this.voteForTransaction({
+        txDigest: existPendingReject.digest,
+        msafeAddress: input.msafeAddress,
+        userAddress: input.userAddress,
+        signature: input.signature
+      });
+      return;
+    }
+    const rejectPayloadStr = Uint8ArrayToHex(payload);
+    const rejectDigest = await txb.getDigest({ client: this._suiClient });
+    const rejectPending = {
+      msafeAddress: input.msafeAddress,
+      digest: rejectDigest,
+      payload: rejectPayloadStr,
+      sequenceNumber: currentPending.sequenceNumber,
+      isRejectTx: true,
+      creator: input.userAddress
+    };
+    await this.model.pendingTransaction.save(rejectPending);
+    const rejectVote = {
+      userAddress: input.userAddress,
+      msafeAddress: input.msafeAddress,
+      txDigest: rejectDigest,
+      signature: input.signature,
+      isValid: true
+    };
+    await this.model.userVote.save(rejectVote);
+    const existVote = await this.model.userVote.findOneBy({
+      txDigest: currentPending.digest,
+      userAddress: input.userAddress
+    });
+    if (existVote !== null) {
+      await this.model.userVote.update(
+        { userAddress: input.userAddress, txDigest: currentPending.digest },
+        { isValid: false }
+      );
+    }
+  }
+  async voteForTransaction(input) {
+    const pendingTx = await this.model.pendingTransaction.findOneBy({ digest: input.txDigest });
+    if (!pendingTx) {
+      throw new Error(`Pending transaction not found: ${input.txDigest}`);
+    }
+    if (pendingTx.msafeAddress !== input.msafeAddress) {
+      throw new Error("MSafe address not match");
+    }
+    const userMSafe = await this.model.userMSafe.findOneBy({
+      userAddress: input.userAddress,
+      msafeAddress: input.msafeAddress
+    });
+    if (userMSafe === null) {
+      throw new Error(`User (${input.userAddress}) does not have permission on MSafe account (${input.msafeAddress})`);
+    }
+    const payload = HexToUint8Array(pendingTx.payload);
+    const verified = await SignatureVerifier.verifyTransactionSignature({
+      payload,
+      targetAddress: input.userAddress,
+      signature: input.signature
+    });
+    if (!verified) {
+      throw new Error("Invalid signature");
+    }
+    const rejectPendingTx = await this.model.pendingTransaction.findOneBy({
+      msafeAddress: input.msafeAddress,
+      sequenceNumber: pendingTx.sequenceNumber,
+      isRejectTx: !pendingTx.isRejectTx
+    });
+    if (rejectPendingTx !== null) {
+      await this.model.userVote.update(
+        {
+          userAddress: input.userAddress,
+          txDigest: rejectPendingTx.digest,
+          isValid: true
+        },
+        { isValid: false }
+      );
+    }
+    const existVote = await this.model.userVote.exist({
+      where: {
+        txDigest: input.txDigest,
+        userAddress: input.userAddress
+      }
+    });
+    if (!existVote) {
+      const userVote = {
+        txDigest: input.txDigest,
+        userAddress: input.userAddress,
+        msafeAddress: input.msafeAddress,
+        signature: input.signature,
+        isValid: true
+      };
+      await this.model.userVote.save(userVote);
+    } else {
+      await this.model.userVote.update(
+        {
+          txDigest: input.txDigest,
+          userAddress: input.userAddress
+        },
+        { isValid: true }
+      );
+    }
+  }
+  // Mock the process of an executed transaction
+  // Here only the essential logic of transaction processing logic
+  // is implemented. Need more transaction parsing from the fetcher
+  // module.
+  //
+  // TODO: User queryRunner to make the transaction atomic.
+  async processExecutedTransaction(digest) {
+    const historyTx = await this.model.historyTransaction.findOneBy({ digest });
+    if (historyTx) {
+      const allHistories = await this.model.historyTransaction.findBy({
+        msafeAddress: historyTx.msafeAddress
+      });
+      console.log(allHistories);
+      return;
+    }
+    const pendingTx = await this.model.pendingTransaction.findOneBy({ digest });
+    if (!pendingTx) {
+      throw new Error("Transaction digest not found");
+    }
+    await this.model.transactionIntention.update(
+      { msafeAddress: pendingTx.msafeAddress, sequenceNumber: pendingTx.sequenceNumber },
+      { status: "processed" }
+    );
+    const pendings = await this.model.pendingTransaction.findBy({
+      msafeAddress: pendingTx.msafeAddress,
+      sequenceNumber: pendingTx.sequenceNumber
+    });
+    if (pendings.length === 0) {
+      throw new Error("Pending transaction not found");
+    }
+    const executionResult = "success";
+    for (let i = 0; i !== pendings.length; i++) {
+      const pending = pendings[i];
+      const history = {
+        digest: pending.digest,
+        payload: pending.payload,
+        msafeAddress: pending.msafeAddress,
+        sequenceNumber: pending.sequenceNumber,
+        isRejectTx: pending.isRejectTx,
+        creator: pending.creator,
+        createdAt: pending.createdAt,
+        // TODO: Fill in this field based on transaction processing result
+        status: pending.digest === digest ? executionResult : "rejected"
+      };
+      await this.model.historyTransaction.save(history);
+      await this.model.pendingTransaction.delete({ digest: pending.digest });
+    }
+  }
+  /**
+   * Build the next transaction intention, and add the built transaction to pendings.
+   * @param input
+   */
+  async buildNextIntentionAndAddToPending(input) {
+    const maxSNHistory = await this.model.historyTransaction.findOne({
+      where: { msafeAddress: input.msafeAddress },
+      order: { sequenceNumber: "desc" }
+    });
+    const nextSequenceNumber = maxSNHistory ? maxSNHistory.sequenceNumber + 1 : 0;
+    const currentPendings = await this.model.pendingTransaction.findBy({
+      msafeAddress: input.msafeAddress
+    });
+    if (currentPendings.length !== 0) {
+      throw new Error("Still have pendings");
+    }
+    const nextTx = await this.model.transactionIntention.findOneBy({
+      msafeAddress: input.msafeAddress,
+      sequenceNumber: nextSequenceNumber
+    });
+    if (nextTx === null) {
+      throw new Error("No future intentions to build");
+    }
+    const nextIntention = IntentionHelper.de(nextTx.data);
+    try {
+      const newTxb = await IntentionHelper.buildTxb({
+        suiClient: this._suiClient,
+        sender: input.msafeAddress,
+        intention: nextIntention
+      });
+      const payload = await newTxb.build({ client: this._suiClient });
+      const newDigest = await newTxb.getDigest({ client: this._suiClient });
+      const newPending = {
+        digest: newDigest,
+        payload: Uint8ArrayToHex(payload),
+        msafeAddress: input.msafeAddress,
+        sequenceNumber: nextTx.sequenceNumber,
+        isRejectTx: false,
+        creator: nextTx.creator
+      };
+      await this.model.pendingTransaction.save(newPending);
+    } catch (e) {
+      await this.model.transactionIntention.update(
+        {
+          msafeAddress: input.msafeAddress,
+          sequenceNumber: nextSequenceNumber
+        },
+        {
+          status: "failed",
+          statusRemark: e.toString()
+        }
+      );
+      throw new Error(`Intention build failed: {sequenceNumber: ${nextSequenceNumber}}`);
+    }
+  }
+  /**
+   *   Skip next failed transaction if build of the intention has been failed before.
+   */
+  async skipNextFailedIntention(input) {
+    const userMSafe = await this.model.userMSafe.findOneBy({
+      msafeAddress: input.msafeAddress,
+      userAddress: input.userAddress
+    });
+    if (userMSafe === null) {
+      throw new Error("user does not have permission to MSafe");
+    }
+    const curSequenceNumber = await this.model.historyTransaction.findOne({
+      where: { msafeAddress: input.msafeAddress },
+      order: { sequenceNumber: "desc" }
+    });
+    const nextSequenceNumber = curSequenceNumber ? curSequenceNumber.sequenceNumber + 1 : 0;
+    const failedIntention = await this.model.transactionIntention.findOneBy({
+      msafeAddress: input.msafeAddress,
+      sequenceNumber: nextSequenceNumber
+    });
+    if (failedIntention === null) {
+      throw new Error("Next intention not found");
+    }
+    if (failedIntention.status !== "failed") {
+      throw new Error("Next intention not failed");
+    }
+    const history = {
+      msafeAddress: input.msafeAddress,
+      digest: "0x0",
+      // Special case for build has been failed,
+      payload: "",
+      sequenceNumber: nextSequenceNumber,
+      creator: failedIntention.creator,
+      isRejectTx: false,
+      status: "build-failed"
+    };
+    await this.model.historyTransaction.save(history);
+  }
+  async getUser(address) {
+    return this.model.user.findOneBy({ address });
+  }
+  get model() {
+    return this.db.coreModel;
+  }
+};
+
+// src/globals/const.ts
+var MSafeEnv = /* @__PURE__ */ ((MSafeEnv3) => {
+  MSafeEnv3["local"] = "local";
+  MSafeEnv3["unit"] = "unit";
+  MSafeEnv3["dev"] = "dev";
+  MSafeEnv3["prev"] = "prev";
+  MSafeEnv3["prod"] = "prod";
+  return MSafeEnv3;
+})(MSafeEnv || {});
+var LOCAL_DATABASE_CONFIG = {
+  type: "mysql",
+  host: "127.0.0.1",
+  port: 3306,
+  username: "msafe",
+  password: "msafe",
+  database: "msafe_sui_local",
+  logging: false
+};
+var DEV_DATABASE_CONFIG = {
+  type: "mysql",
+  host: "msafe-dev-database.cluster-caos3ssocrx6.us-west-1.rds.amazonaws.com",
+  port: 3306,
+  username: "msafe",
+  password: "Momentum.Safe2022",
+  database: "msafe_sui_dev",
+  logging: false
+};
+var TESTNET_RPC_URL = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
+var MAINNET_RPC_URL = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
+var ENV_CONFIGS = /* @__PURE__ */ new Map([
+  [
+    "unit" /* unit */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: LOCAL_DATABASE_CONFIG
+    }
+  ],
+  [
+    "local" /* local */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: LOCAL_DATABASE_CONFIG
+    }
+  ],
+  [
+    "dev" /* dev */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: DEV_DATABASE_CONFIG
+    }
+  ]
+]);
+function getMSafeConfig(env, options) {
+  const config = ENV_CONFIGS.get(env);
+  if (!config) {
+    throw new Error("Unknown environment");
+  }
+  if (options?.suiClient?.url) {
+    config.suiClient.url = options.suiClient.url;
+  }
+  if (options?.backend) {
+    config.backend = options.backend;
+  }
+  return config;
+}
+var AUTH_SIGN_MESSAGE = "Welcome to MSafe";
+
+// src/globals/MSafeGlobals.ts
+var MSafeGlobals = class _MSafeGlobals {
+  backend;
+  suiClient;
+  config;
+  _wallet;
+  constructor(input) {
+    this.backend = input.backend;
+    this.suiClient = input.suiClient;
+    this.config = input.config;
+  }
+  static async New(env, options) {
+    const config = getMSafeConfig(env, options);
+    const suiClient = new import_client.SuiClient(config.suiClient);
+    const backend = await PseudoBackend.New(config.backend, suiClient);
+    return new _MSafeGlobals({
+      backend,
+      suiClient,
+      config
+    });
+  }
+  connectWallet(wallet) {
+    this._wallet = wallet;
+  }
+  get wallet() {
+    if (!this._wallet) {
+      throw new Error("wallet not connected");
+    }
+    return this._wallet;
+  }
+  set wallet(val) {
+    this._wallet = val;
+  }
+};
+
+// src/core/MSafeClient.ts
+var MSafeClient = class _MSafeClient {
+  constructor(globals) {
+    this.globals = globals;
+  }
+  _creationHelper;
+  _publicKeyHelper;
+  static async New(env, options) {
+    const globals = await MSafeGlobals.New(env, options);
+    return new _MSafeClient(globals);
+  }
+  async connectWallet(input) {
+    this.globals.wallet = input.wallet;
+    const isValidJWT = input.jwtToken && await this.backend.isJWTTokenValid(input.jwtToken);
+    if (isValidJWT) {
+      this.backend.setJWTToken(input.jwtToken);
+      return input.jwtToken;
+    }
+    const messageStr = MessageHelper.welcomeMessage((/* @__PURE__ */ new Date()).toUTCString());
+    const sig = await input.wallet.signPersonalMessage({
+      messageStr
+    });
+    return this.backend.authSign({
+      address: await input.wallet.address(),
+      message: messageStr,
+      signature: sig.signature,
+      walletType: input.wallet.walletType
+    });
+  }
+  async userInfo() {
+    return this.globals.backend.getUserInfo(await this.walletAddress());
+  }
+  async createAccount(info) {
+    return this.creationHelper.submitMSafeCreation(info);
+  }
+  getMSafeAccount(info) {
+    return new MSafeAccount(this.globals, info);
+  }
+  async getMSafeAccountFromAddress(msafeAddress) {
+    const info = await this.backend.getMSafeAccountInfo(msafeAddress);
+    return new MSafeAccount(this.globals, info);
+  }
+  // Get the creation helper to calculate the msafe account address,
+  // validation, and more.
+  get creationHelper() {
+    if (!this._creationHelper) {
+      this._creationHelper = new CreateHelper(this.globals, this.publicKeyHelper);
+    }
+    return this._creationHelper;
+  }
+  get publicKeyHelper() {
+    if (!this._publicKeyHelper) {
+      this._publicKeyHelper = new PublicKeyHelper(this.globals);
+    }
+    return this._publicKeyHelper;
+  }
+  get config() {
+    return this.globals.config;
+  }
+  get backend() {
+    return this.globals.backend;
+  }
+  get wallet() {
+    return this.globals.wallet;
+  }
+  async walletAddress() {
+    return this.wallet.address();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_SIGN_MESSAGE,
+  COIN_TYPE_ARG_REGEX,
+  Coin,
+  CoinHelper,
+  CreateHelper,
+  DEV_DATABASE_CONFIG,
+  ENV_CONFIGS,
+  Formatter,
+  HexToUint8Array,
+  IntentionHelper,
+  LOCAL_DATABASE_CONFIG,
+  MAINNET_RPC_URL,
+  MAX_OWNER_WITHOUT_NONCE,
+  MAX_OWNER_WITH_NONCE,
+  MAX_WEIGHT,
+  MIN_THRESHOLD,
+  MIN_WEIGHT,
+  MSafeAccount,
+  MSafeClient,
+  MSafeEnv,
+  MSafeGlobals,
+  MessageHelper,
+  NONCE_PK_PREFIX,
+  NONCE_PK_WEIGHT,
+  NONCE_PREFIX_MAX_SIZE,
+  PublicKeySerde,
+  RawMultiSig,
+  SUI_COIN,
+  SignatureVerifier,
+  TESTNET_RPC_URL,
+  Uint8ArrayToHex,
+  getAllCoins,
+  getMSafeConfig,
+  getMultiSigPublicKey,
+  getPublicKeyFromChain,
+  makeNoncePublicKey,
+  stringToBuffer,
+  validateMultiSigConfig
+});
+//# sourceMappingURL=index.cjs.map