@msafe/sui3-sdk 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -30,21 +30,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AUTH_SIGN_MESSAGE: () => AUTH_SIGN_MESSAGE,
   AddressBookSDK: () => AddressBookSDK,
   COIN_TYPE_ARG_REGEX: () => COIN_TYPE_ARG_REGEX,
   Coin: () => Coin,
   CoinHelper: () => CoinHelper,
   CreateHelper: () => CreateHelper,
   DEV_API_URL: () => DEV_API_URL,
-  DEV_DATABASE_CONFIG: () => DEV_DATABASE_CONFIG,
   DEV_SYNCING_URL: () => DEV_SYNCING_URL,
   ENV_CONFIGS: () => ENV_CONFIGS,
   Formatter: () => Formatter,
   HexToUint8Array: () => HexToUint8Array,
   IntentionHelper: () => IntentionHelper,
   LOCAL_API_URL: () => LOCAL_API_URL,
-  LOCAL_DATABASE_CONFIG: () => LOCAL_DATABASE_CONFIG,
   LOCAL_SYNCING_URL: () => LOCAL_SYNCING_URL,
   MAINNET_RPC_URL: () => MAINNET_RPC_URL,
   MSAFE_APPLICATION: () => MSAFE_APPLICATION,
@@ -52,13 +49,9 @@ __export(src_exports, {
   MSafeClient: () => MSafeClient,
   MSafeEnv: () => MSafeEnv,
   MSafeGlobals: () => MSafeGlobals,
-  MessageHelper: () => MessageHelper,
-  OpAddressBookType: () => OpAddressBookType,
-  PublicKeySerde: () => PublicKeySerde,
   SUI_COIN: () => SUI_COIN,
   SignatureVerifier: () => SignatureVerifier,
   TESTNET_RPC_URL: () => TESTNET_RPC_URL,
-  UNIT_DATABASE_CONFIG: () => UNIT_DATABASE_CONFIG,
   Uint8ArrayToHex: () => Uint8ArrayToHex,
   getAllCoins: () => getAllCoins,
   getMSafeConfig: () => getMSafeConfig,
@@ -69,24 +62,103 @@ module.exports = __toCommonJS(src_exports);
 
 // src/core/CreateHelper.ts
 var import_sui3_utils = require("@msafe/sui3-utils");
+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 import_sui3_utils.MultiSigAccount(msConfig);
+    return ms.address;
+  }
+  // Validate the create info and return the msafe address.
+  async validateCreateInfo(createInfo) {
+    return this.calculateMSafeAddress(createInfo);
+  }
+  async submitMSafeCreation(creationInfo) {
+    const msafeAddress = await this.validateCreateInfo(creationInfo);
+    const signingMessage = import_sui3_utils.SigningMessageHelper.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.owners.map((owner) => owner.address));
+    publicKeys.forEach((pk, i) => {
+      if (pk === void 0) {
+        throw new Error(`Unknown public key for address: ${info.owners[i].address}`);
+      }
+    });
+    return {
+      threshold: info.threshold,
+      ownersWithWeight: info.owners.map((owner, i) => ({
+        publicKey: publicKeys[i],
+        weight: owner.weight
+      })),
+      creationNonce: info.creationNonce
+    };
+  }
+  async submitToBackend(createInfo, signature) {
+    const pks = await this.pkHelper.getPublicKeyBatch(createInfo.owners.map((owner) => owner.address));
+    await this.globals.backend.createMSafeAccount({
+      owners: createInfo.owners.map((owner, i) => ({
+        address: owner.address,
+        weight: owner.weight,
+        ...import_sui3_utils.PublicKeySerde.ser(pks[i])
+      })),
+      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/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/core/MSafeClient.ts
+var import_sui3_utils6 = require("@msafe/sui3-utils");
 
-// 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/core/AddressBookSDK.ts
+var import_sui3_utils2 = require("@msafe/sui3-utils");
+var AddressBookSDK = class {
+  constructor(globals) {
+    this.globals = globals;
+  }
+  async getEntries(pagination) {
+    return this.globals.backend.getAddressBookEntries(pagination);
+  }
+  async update(updates) {
+    const messageStr = import_sui3_utils2.SigningMessageHelper.updateAddressBookMessage(updates);
+    const sig = await this.globals.wallet.signPersonalMessage({ messageStr });
+    return this.globals.backend.updateAddressBook({ updates, signature: sig.signature });
+  }
+};
+
+// src/core/InvitationSDK.ts
+var InvitationSDK = class {
+  constructor(globals) {
+    this.globals = globals;
+  }
+  async getMSafeByStatus(status, pagination) {
+    return this.globals.backend.getOwnedMSafeByStatus({ status, pagination });
+  }
+  async updateMSafeStatus(msafeAddress, status) {
+    return this.globals.backend.updateMSafeStatus({ msafeAddress, status });
+  }
+};
+
+// src/core/MSafeAccount.ts
+var import_sui3_utils4 = require("@msafe/sui3-utils");
+var import_utils3 = require("@mysten/sui.js/utils");
+
+// 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");
@@ -162,140 +234,9 @@ var Formatter = class {
   }
 };
 
-// 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/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 import_sui3_utils.MultisigAccountManager(msConfig);
-    return ms.address;
-  }
-  // Validate the create info and return the msafe address.
-  async validateCreateInfo(createInfo) {
-    const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
-    (0, import_sui3_utils.validateCreateAccountRequest)(rawConfig);
-    return this.calculateMSafeAddress(createInfo);
-  }
-  async submitMSafeCreation(creationInfo) {
-    const msafeAddress = await this.validateCreateInfo(creationInfo);
-    const signingMessage = (0, import_sui3_utils.createAccountCreationMessage)(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,
-      ownersWithWeight: 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({
-      ownersWithWeightPKEncoded: createInfo.ownerWithWeight.map((owner, i) => {
-        const publicKeySer = PublicKeySerde.ser(pks[i]);
-        return {
-          address: owner.address,
-          weight: owner.weight,
-          publicKeyEncoded: publicKeySer.publicKey,
-          schema: publicKeySer.scheme
-        };
-      }),
-      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/MessageHelper.ts
-var import_utils3 = require("@mysten/sui.js/utils");
-var import_crypto_js = require("crypto-js");
-
-// src/transactions/coin-transfer.ts
-var import_transactions = require("@mysten/sui.js/transactions");
-
 // src/utils/sui.ts
-var import_cryptography2 = require("@mysten/sui.js/cryptography");
+var import_sui3_utils3 = require("@msafe/sui3-utils");
+var import_cryptography = require("@mysten/sui.js/cryptography");
 var import_multisig = require("@mysten/sui.js/multisig");
 var SUI_COIN = "0x2::sui::SUI";
 async function getPublicKeyFromChain(suiClient, address) {
@@ -326,7 +267,7 @@ async function getPublicKeyFromChain(suiClient, address) {
   return void 0;
 }
 function getAddressFromSignatures(serializedSig, targetAddress) {
-  const decoded = (0, import_cryptography2.parseSerializedSignature)(serializedSig);
+  const decoded = (0, import_cryptography.parseSerializedSignature)(serializedSig);
   switch (decoded.signatureScheme) {
     case "MultiSig": {
       const multiSigAddress = new import_multisig.MultiSigPublicKey(decoded.multisig.multisig_pk).toSuiAddress();
@@ -344,7 +285,7 @@ function getAddressFromSignatures(serializedSig, targetAddress) {
     case "ED25519":
     case "Secp256k1":
     case "Secp256r1": {
-      const pk = PublicKeySerde.de({ publicKey: decoded.publicKey, scheme: decoded.signatureScheme });
+      const pk = import_sui3_utils3.PublicKeySerde.de({ publicKeyEncoded: decoded.publicKey, schema: decoded.signatureScheme });
       if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
         return pk;
       }
@@ -457,6 +398,19 @@ function getAddressOwner(object) {
 
 // src/transactions/reject.ts
 var import_transactions3 = require("@mysten/sui.js/transactions");
+
+// 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/transactions/reject.ts
 async function buildRejectTxb(input) {
   const approveTxb = import_transactions3.TransactionBlock.from(HexToUint8Array(input.payloadToReject));
   const gasPayment = approveTxb.blockData.gasConfig.payment;
@@ -521,483 +475,43 @@ var IntentionHelper = class {
   }
 };
 
-// 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 { msafeAddress, intention, sn } = data;
-    const intentionData = IntentionHelper.ser(intention);
-    const msg = {
-      intentionData,
-      sequenceNumber: sn,
-      msafeAddress
-    };
-    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");
+// src/utils/crypto.ts
+var import_verify = require("@mysten/sui.js/verify");
+var SignatureVerifier = class _SignatureVerifier {
+  static async getPublicKeyFromSignature(input) {
+    if (input.messageType === "TransactionBlock") {
+      return (0, import_verify.verifyTransactionBlock)(input.message, input.signature);
     }
-    const { msafeAddress, sequenceNumber, intentionData } = de;
-    return {
-      msafeAddress,
-      sn: sequenceNumber,
-      intention: IntentionHelper.de(intentionData)
-    };
+    return (0, import_verify.verifyPersonalMessage)(input.message, input.signature);
   }
-  static updateAddressBookMessage(updates) {
-    const normalized = updates.map((update) => ({
-      ...update,
-      address: (0, import_utils3.normalizeSuiAddress)(update.address)
-    }));
-    function sortObjectKeys(obj) {
-      return Object.keys(obj).sort().reduce((result, key) => ({ ...result, [key]: obj[key] }), {});
-    }
-    const sortedUpdates = normalized.map((update) => sortObjectKeys(update));
-    const raw = JSON.stringify(sortedUpdates, null, 2);
-    const encoded = stringToBuffer(raw);
-    if (encoded.length <= 1024) {
-      return raw;
-    }
-    const md5 = (0, import_crypto_js.MD5)(raw);
-    return `Bulk address book update: ${md5}`;
+  static async getPublicKeyFromPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.getPublicKeyFromSignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature
+    });
   }
-};
-
-// src/core/AddressBookSDK.ts
-var AddressBookSDK = class {
-  constructor(globals) {
-    this.globals = globals;
+  static async verifySignature(input) {
+    const publicKey = await _SignatureVerifier.getPublicKeyFromSignature(input);
+    return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
   }
-  async getEntries(pagination) {
-    return this.globals.backend.getAddressBookEntries(pagination);
+  static async verifyPersonalSignature(input) {
+    const message = stringToBuffer(input.messageStr);
+    return this.verifySignature({
+      message,
+      messageType: "Personal",
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
   }
-  async update(updates) {
-    const messageStr = MessageHelper.updateAddressBookMessage(updates);
-    const sig = await this.globals.wallet.signPersonalMessage({ messageStr });
-    return this.globals.backend.updateAddressBook({ updates, signature: sig.signature });
-  }
-};
-
-// src/core/MSafeAccount.ts
-var import_sui3_utils2 = require("@msafe/sui3-utils");
-var import_utils5 = require("@mysten/sui.js/utils");
-
-// 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 UNIT_DATABASE_CONFIG = {
-  type: "sqlite",
-  database: ":memory:",
-  logging: false
-};
-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 MSAFE_APPLICATION = "msafe";
-var TESTNET_RPC_URL = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
-var MAINNET_RPC_URL = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
-var LOCAL_API_URL = "http://127.0.0.1:3000";
-var LOCAL_SYNCING_URL = "http://127.0.0.1:3001";
-var DEV_API_URL = "http://13.56.226.148";
-var DEV_SYNCING_URL = "http://52.53.228.20";
-var ENV_CONFIGS = /* @__PURE__ */ new Map([
-  [
-    "unit" /* unit */,
-    {
-      suiClient: {
-        url: TESTNET_RPC_URL
-      },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
-      syncingURL: LOCAL_SYNCING_URL
-    }
-  ],
-  [
-    "local" /* local */,
-    {
-      suiClient: {
-        url: TESTNET_RPC_URL
-      },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
-      syncingURL: LOCAL_SYNCING_URL
-    }
-  ],
-  [
-    "dev" /* dev */,
-    {
-      suiClient: {
-        url: TESTNET_RPC_URL
-      },
-      backend: DEV_DATABASE_CONFIG,
-      apiURL: DEV_API_URL,
-      syncingURL: DEV_SYNCING_URL
-    }
-  ]
-]);
-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 import_client = require("@mysten/sui.js/client");
-
-// src/backend/BackendImpl.ts
-var import_axios = __toESM(require("axios"), 1);
-var BackendImpl = class {
-  constructor(apiURL) {
-    this.apiURL = apiURL;
-  }
-  _token;
-  async authSign(input) {
-    const res = await import_axios.default.post(`${this.apiURL}/auth/login`, input);
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid authSign return: ${res}`);
-    }
-    this._token = res.data.accessToken;
-    return this._token;
-  }
-  async verifyToken(jwt) {
-    try {
-      const res = await import_axios.default.get(`${this.apiURL}/auth`, { headers: this.headers(jwt) });
-      return res.status === 200;
-    } catch (_) {
-      return false;
-    }
-  }
-  setJWTToken(token) {
-    this._token = token;
-  }
-  async getPublicKey(address) {
-    return (await this.getPublicKeyBatch([address]))[0];
-  }
-  async getPublicKeyBatch(addresses) {
-    const res = await import_axios.default.post(
-      `${this.apiURL}/account/getPublicKeyBatch`,
-      addresses,
-      {
-        headers: this.headers()
-      }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-    return res.data?.map(
-      (publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde.de({ ...publicKeyWithSchema }) : void 0
-    );
-  }
-  async getMSafeAccountInfo(msafeAddress) {
-    const res = await import_axios.default.get(
-      `${this.apiURL}/account/getMSafeAccountInfo/${msafeAddress}`,
-      {
-        headers: this.headers()
-      }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-    const msafeResp = res.data;
-    return {
-      address: msafeResp.address,
-      ownersWithWeightPK: msafeResp.ownersWithWeightPKEncoded.map(
-        (owner) => ({
-          publicKey: PublicKeySerde.de({ publicKey: owner.publicKeyEncoded, scheme: owner.schema }),
-          address: owner.address,
-          weight: owner.weight
-        })
-      ),
-      threshold: msafeResp.threshold,
-      name: msafeResp.name,
-      description: msafeResp.description,
-      creationNonce: msafeResp.creationNonce
-    };
-  }
-  async getUserInfo(userAddress) {
-    const res = await import_axios.default.get(`${this.apiURL}/account/user/${userAddress}`, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-    return {
-      address: res.data.address,
-      publicKey: res.data.publicKey,
-      schema: res.data.schema,
-      creationNonce: res.data.creationNonce,
-      ownedMSafe: res.data.ownedMSafe.map(
-        (msafe) => ({
-          address: msafe.address,
-          ownersWithWeightPK: msafe.ownersWithWeightPKEncoded.map(
-            (owner) => ({
-              publicKey: PublicKeySerde.de({ publicKey: owner.publicKeyEncoded, scheme: owner.schema }),
-              address: owner.address,
-              weight: owner.weight
-            })
-          ),
-          threshold: msafe.threshold,
-          name: msafe.name,
-          description: msafe.description,
-          creationNonce: msafe.creationNonce
-        })
-      )
-    };
-  }
-  async getPendingTransactions(msafeAddress) {
-    const res = await import_axios.default.get(`${this.apiURL}/transaction/pending/${msafeAddress}`, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-    return res.data;
-  }
-  async getHistoryTransactions(msafeAddress, paginationOption) {
-    const res = await import_axios.default.get(
-      `${this.apiURL}/transaction/history?address=${msafeAddress}`,
-      {
-        params: {
-          page: paginationOption?.page,
-          limit: paginationOption?.limit
-        },
-        headers: this.headers()
-      }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
-    return res.data;
-  }
-  async getFutureIntentions(msafeAddress, paginationOption) {
-    const res = await import_axios.default.get(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
-      params: {
-        page: paginationOption?.page,
-        limit: paginationOption?.limit
-      },
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
-    return res.data;
-  }
-  async getCurrentSequenceNumber(msafeAddress) {
-    const res = await import_axios.default.get(`${this.apiURL}/transaction/sn/current/${msafeAddress}`, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
-    return res.data;
-  }
-  async getNextSequenceNumber(msafeAddress) {
-    const res = await import_axios.default.get(`${this.apiURL}/transaction/sn/next/${msafeAddress}`, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getNextSequenceNumber return: ${res}`);
-    }
-    return res.data;
-  }
-  async createMSafeAccount(input) {
-    const res = await import_axios.default.post(`${this.apiURL}/account`, input, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid createMSafeAccount return: ${res}`);
-    }
-  }
-  async proposeIntention(input) {
-    try {
-      const res = await import_axios.default.post(
-        `${this.apiURL}/transaction/intention`,
-        {
-          intention: input.intention,
-          sequenceNumber: input.sequenceNumber,
-          address: input.msafeAddress,
-          signature: input.signature,
-          application: input.application,
-          txType: input.txType,
-          txSubType: input.txSubType
-        },
-        { headers: this.headers() }
-      );
-      if (res.status !== 200 && res.status !== 201) {
-        throw new Error(`invalid proposeIntention return: ${res}`);
-      }
-    } catch (e) {
-      console.log(e);
-    }
-  }
-  // TODO later
-  async proposePendingTransaction(input) {
-  }
-  async rejectCurrentTx(input) {
-    try {
-      const res = await import_axios.default.post(
-        `${this.apiURL}/transaction/pending/reject`,
-        {
-          address: input.msafeAddress,
-          digest: input.digest,
-          signature: input.signature
-        },
-        {
-          headers: this.headers()
-        }
-      );
-      if (res.status !== 200 && res.status !== 201) {
-        throw new Error(`invalid voteForTransaction return: ${res}`);
-      }
-    } catch (e) {
-      console.log("e:", e);
-    }
-  }
-  async voteForTransaction(input) {
-    const res = await import_axios.default.post(
-      `${this.apiURL}/transaction/pending/vote`,
-      {
-        address: input.msafeAddress,
-        digest: input.txDigest,
-        signature: input.signature
-      },
-      {
-        headers: this.headers()
-      }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid voteForTransaction return: ${res}`);
-    }
-  }
-  async buildNextIntentionAndAddToPending(input) {
-    const res = await import_axios.default.post(
-      `${this.apiURL}/transaction/pending/build`,
-      {
-        address: input.msafeAddress
-      },
-      { headers: this.headers() }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid buildNextIntentionAndAddToPending return: ${res}`);
-    }
-  }
-  async skipNextFailedIntention(input) {
-    const res = await import_axios.default.post(
-      `${this.apiURL}/transaction/pending/skip`,
-      {
-        msafeAddress: input.msafeAddress
-      },
-      { headers: this.headers() }
-    );
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid skipNextFailedIntention return: ${res}`);
-    }
-  }
-  async getAddressBookEntries(pagination) {
-    const res = await import_axios.default.get(`${this.apiURL}/address-book`, {
-      headers: this.headers(),
-      params: pagination
-    });
-    if (res.status !== 200) {
-      throw new Error(`Invalid address-book return: ${res}`);
-    }
-    return res.data;
-  }
-  async updateAddressBook(input) {
-    const res = await import_axios.default.post(`${this.apiURL}/address-book`, input, { headers: this.headers() });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid updateAddressBook return: ${res}`);
-    }
-  }
-  async processExecutedTransaction(digest) {
-  }
-  headers(token) {
-    return { Authorization: `Bearer ${token || this._token}` };
-  }
-};
-
-// 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 = new BackendImpl(config.apiURL);
-    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;
+  static async verifyTransactionSignature(input) {
+    return this.verifySignature({
+      messageType: "TransactionBlock",
+      message: input.payload,
+      signature: input.signature,
+      targetAddress: input.targetAddress
+    });
   }
 };
 
@@ -1129,21 +643,29 @@ var OwnedObjectRequester = class {
 };
 
 // src/core/MSafeAccount.ts
-var MSafeAccount = class {
+var MSafeAccount = class _MSafeAccount {
   constructor(globals, info) {
     this.globals = globals;
     this.info = info;
-    this.multisigManager = new import_sui3_utils2.MultisigAccountManager({
+    this.multiSig = new import_sui3_utils4.MultiSigAccount({
       threshold: info.threshold,
-      ownersWithWeight: info.ownersWithWeightPK,
+      ownersWithWeight: info.owners.map((owner) => ({
+        address: owner.address,
+        weight: owner.weight,
+        publicKey: import_sui3_utils4.PublicKeySerde.de({ publicKeyEncoded: owner.publicKeyEncoded, schema: owner.schema })
+      })),
       creationNonce: info.creationNonce
     });
     this.coinHelper = new CoinHelper(this.suiClient);
   }
-  multisigManager;
+  multiSig;
   coinHelper;
-  static async new(globals, address) {
-    return globals.backend.getMSafeAccountInfo(address);
+  static async New(globals, address) {
+    const info = await globals.backend.getMSafeAccountInfo(address);
+    const ms = new _MSafeAccount(globals, info);
+    if (ms.address !== address) {
+      throw new Error("Invalid msafe config with address");
+    }
   }
   async ownedCoins() {
     const balances = await this.suiClient.getAllBalances({ owner: this.address });
@@ -1152,7 +674,7 @@ var MSafeAccount = class {
         const meta = await this.coinHelper.getCoinMeta(balance.coinType);
         const unlockedBalance = balance.lockedBalance.number ? BigInt(balance.totalBalance) - BigInt(balance.lockedBalance.number) : BigInt(balance.totalBalance);
         return {
-          type: (0, import_utils5.normalizeStructTag)(balance.coinType),
+          type: (0, import_utils3.normalizeStructTag)(balance.coinType),
           balance: BigInt(unlockedBalance),
           metadata: meta
         };
@@ -1196,25 +718,20 @@ var MSafeAccount = class {
   async nextSequenceNumber() {
     return this.backend.getNextSequenceNumber(this.address);
   }
-  async proposeIntention(intention, sequenceNumber) {
-    const message = MessageHelper.proposeIntentionMessage({
-      intention,
-      sn: sequenceNumber,
-      msafeAddress: this.address
+  async proposeIntention(input) {
+    const message = import_sui3_utils4.SigningMessageHelper.proposeIntentionMessage({
+      msafeAddress: this.address,
+      intention: input.intention,
+      sn: input.sequenceNumber
     });
     const signature = await this.wallet.signPersonalMessage({
       messageStr: message
     });
-    const txType = (0, import_sui3_utils2.getIntentionType)(intention);
     await this.backend.proposeIntention({
-      intention,
-      sequenceNumber,
+      ...input,
       msafeAddress: this.address,
       userAddress: await this.userAddress(),
-      signature: signature.signature,
-      application: MSAFE_APPLICATION,
-      txType: txType.txType,
-      txSubType: txType.txSubType
+      signature: signature.signature
     });
   }
   async voteForTransaction(digest, payload) {
@@ -1281,7 +798,7 @@ var MSafeAccount = class {
     return this.backend.skipNextFailedIntention({ msafeAddress: this.address, userAddress: await this.userAddress() });
   }
   async simulateIntention(intention) {
-    const txb = await (0, import_sui3_utils2.buildIntentionTransaction)(this.suiClient, intention, this.address);
+    const txb = await (0, import_sui3_utils4.buildIntentionTransaction)(this.suiClient, intention, this.address);
     if (!txb.blockData.gasConfig.price) {
       const refGas = await this.suiClient.getReferenceGasPrice();
       txb.setGasPrice(refGas);
@@ -1312,101 +829,457 @@ var MSafeAccount = class {
     } else {
       throw new Error("Not enough signatures");
     }
-    const sigs = [];
-    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 sigs = [];
+    for (let i = 0; i < this.info.owners.length; i++) {
+      const owner = this.info.owners[i];
+      const signature = gotSigs.get(owner.address);
+      if (signature) {
+        sigs.push(signature);
+      }
+    }
+    const multiSignature = this.multiSig.combinePartialSignatures(sigs);
+    return this.suiClient.executeTransactionBlock({
+      transactionBlock: HexToUint8Array(payload),
+      signature: multiSignature,
+      options: { showEffects: true }
+    });
+  }
+  get address() {
+    return this.multiSig.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);
+    if (emptyIndexes.length === 0) {
+      return results;
+    }
+    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/BackendImpl.ts
+var import_sui3_utils5 = require("@msafe/sui3-utils");
+var import_axios = __toESM(require("axios"), 1);
+var BackendImpl = class {
+  constructor(apiURL) {
+    this.apiURL = apiURL;
+  }
+  _token;
+  async authSign(input) {
+    const res = await import_axios.default.post(`${this.apiURL}/auth/login`, input);
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid authSign return: ${res}`);
+    }
+    this._token = res.data.accessToken;
+    return this._token;
+  }
+  async verifyToken(jwt) {
+    try {
+      const res = await import_axios.default.get(`${this.apiURL}/auth`, { headers: this.headers(jwt) });
+      return res.status === 200;
+    } catch (_) {
+      return false;
+    }
+  }
+  setJWTToken(token) {
+    this._token = token;
+  }
+  async getPublicKey(address) {
+    return (await this.getPublicKeyBatch([address]))[0];
+  }
+  async getPublicKeyBatch(addresses) {
+    const query = {
+      userAddressList: addresses
+    };
+    const res = await import_axios.default.get(`${this.apiURL}/user/public-keys`, {
+      params: query,
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+    }
+    return res.data?.map(
+      (publicKeyWithSchema) => publicKeyWithSchema ? import_sui3_utils5.PublicKeySerde.de(publicKeyWithSchema) : void 0
+    );
+  }
+  async getMSafeAccountInfo(msafeAddress) {
+    const q = {
+      msafeAddress
+    };
+    const res = await import_axios.default.get(`${this.apiURL}/msafe`, {
+      params: q,
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+    }
+    return res.data;
+  }
+  async getUserInfo() {
+    const userRes = await import_axios.default.get(`${this.apiURL}/user`, {
+      headers: this.headers()
+    });
+    if (userRes.status !== 200 && userRes.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${userRes}`);
+    }
+    return userRes.data;
+  }
+  async getOwnedMSafeByStatus(input) {
+    const q = {
+      status: input.status ?? import_sui3_utils5.UserMSafeStatus.active,
+      ...input.pagination ? {
+        page: input.pagination.page.toString(),
+        limit: input.pagination.limit.toString()
+      } : {}
+    };
+    const res = await import_axios.default.get(`${this.apiURL}/msafe/owned`, {
+      params: q,
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getOwnedMSafeByStatus return: ${res}`);
+    }
+    return res.data;
+  }
+  async updateMSafeStatus(input) {
+    const p = input;
+    const res = await import_axios.default.post(`${this.apiURL}/msafe/status`, p, { headers: this.headers() });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`Invalid updateMSafeStatus return: ${res}`);
+    }
+  }
+  async getPendingTransactions(msafeAddress) {
+    const res = await import_axios.default.get(`${this.apiURL}/transaction/pending/${msafeAddress}`, {
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+    }
+    return res.data;
+  }
+  async getHistoryTransactions(msafeAddress, paginationOption) {
+    const res = await import_axios.default.get(
+      `${this.apiURL}/transaction/history?address=${msafeAddress}`,
+      {
+        params: {
+          page: paginationOption?.page,
+          limit: paginationOption?.limit
+        },
+        headers: this.headers()
+      }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
+    }
+    return res.data;
+  }
+  async getFutureIntentions(msafeAddress, paginationOption) {
+    const res = await import_axios.default.get(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
+      params: {
+        page: paginationOption?.page,
+        limit: paginationOption?.limit
+      },
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
+    }
+    return res.data;
+  }
+  async getCurrentSequenceNumber(msafeAddress) {
+    const res = await import_axios.default.get(`${this.apiURL}/transaction/sn/current/${msafeAddress}`, {
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
     }
-    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
-    return this.suiClient.executeTransactionBlock({
-      transactionBlock: HexToUint8Array(payload),
-      signature: multiSignature,
-      options: { showEffects: true }
+    return res.data;
+  }
+  async getNextSequenceNumber(msafeAddress) {
+    const res = await import_axios.default.get(`${this.apiURL}/transaction/sn/next/${msafeAddress}`, {
+      headers: this.headers()
     });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getNextSequenceNumber return: ${res}`);
+    }
+    return res.data;
   }
-  get address() {
-    return this.info.address;
+  async createMSafeAccount(input) {
+    const res = await import_axios.default.post(`${this.apiURL}/msafe/create`, input, {
+      headers: this.headers()
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid createMSafeAccount return: ${res}`);
+    }
   }
-  get backend() {
-    return this.globals.backend;
+  async proposeIntention(input) {
+    const res = await import_axios.default.post(`${this.apiURL}/transaction/intention`, input, { headers: this.headers() });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid proposeIntention return: ${res}`);
+    }
   }
-  get wallet() {
-    return this.globals.wallet;
+  // TODO later
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async proposePendingTransaction(_input) {
+    return void 0;
   }
-  async userAddress() {
-    return this.globals.wallet.address();
+  async rejectCurrentTx(input) {
+    const res = await import_axios.default.post(
+      `${this.apiURL}/transaction/pending/reject`,
+      {
+        address: input.msafeAddress,
+        digest: input.digest,
+        signature: input.signature
+      },
+      {
+        headers: this.headers()
+      }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid voteForTransaction return: ${res}`);
+    }
   }
-  get suiClient() {
-    return this.globals.suiClient;
+  async voteForTransaction(input) {
+    const res = await import_axios.default.post(
+      `${this.apiURL}/transaction/pending/vote`,
+      {
+        address: input.msafeAddress,
+        digest: input.txDigest,
+        signature: input.signature
+      },
+      {
+        headers: this.headers()
+      }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid voteForTransaction return: ${res}`);
+    }
   }
-};
-
-// src/core/PublicKeyHelper.ts
-var PublicKeyHelper = class {
-  constructor(globals) {
-    this.globals = globals;
-    this.knownPublicKeys = /* @__PURE__ */ new Map();
+  async buildNextIntentionAndAddToPending(input) {
+    const res = await import_axios.default.post(
+      `${this.apiURL}/transaction/pending/build`,
+      {
+        address: input.msafeAddress
+      },
+      { headers: this.headers() }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid buildNextIntentionAndAddToPending return: ${res}`);
+    }
   }
-  knownPublicKeys;
-  async getPublicKey(address) {
-    const cached = this.knownPublicKeys.get(address);
-    if (cached) {
-      return cached;
+  async skipNextFailedIntention(input) {
+    const res = await import_axios.default.post(
+      `${this.apiURL}/transaction/pending/skip`,
+      {
+        msafeAddress: input.msafeAddress
+      },
+      { headers: this.headers() }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid skipNextFailedIntention return: ${res}`);
     }
-    const pk = await this._getPublicKey(address);
-    if (pk) {
-      this.knownPublicKeys.set(address, pk);
+  }
+  async getAddressBookEntries(pagination) {
+    const res = await import_axios.default.get(`${this.apiURL}/address-book`, {
+      headers: this.headers(),
+      params: pagination
+    });
+    if (res.status !== 200) {
+      throw new Error(`Invalid address-book return: ${res}`);
     }
-    return pk;
+    return res.data;
   }
-  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);
+  async updateAddressBook(input) {
+    const res = await import_axios.default.post(`${this.apiURL}/address-book`, input, { headers: this.headers() });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid updateAddressBook return: ${res}`);
     }
-    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];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async processExecutedTransaction(_digest) {
+    return void 0;
+  }
+  headers(token) {
+    return { Authorization: `Bearer ${token || this._token}` };
+  }
+};
+
+// 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 MSAFE_APPLICATION = "msafe";
+var TESTNET_RPC_URL = "https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD";
+var MAINNET_RPC_URL = "https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7";
+var LOCAL_API_URL = "http://127.0.0.1:3000";
+var LOCAL_SYNCING_URL = "http://127.0.0.1:3001";
+var DEV_API_URL = "http://13.56.226.148";
+var DEV_SYNCING_URL = "http://52.53.228.20";
+var ENV_CONFIGS = /* @__PURE__ */ new Map([
+  [
+    "unit" /* unit */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: {
+        url: LOCAL_API_URL
+      },
+      syncingURL: LOCAL_SYNCING_URL
     }
-    for (let i = 0; i < results.length; i++) {
-      if (results[i] === void 0) {
-        results[i] = await this.getPublicKeyFromChain(addresses[i]);
-      }
+  ],
+  [
+    "local" /* local */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: {
+        url: LOCAL_API_URL
+      },
+      syncingURL: LOCAL_SYNCING_URL
     }
-    for (let i = 0; i < addresses.length; i++) {
-      if (results[i]) {
-        this.knownPublicKeys.set(addresses[i], results[i]);
-      }
+  ],
+  [
+    "dev" /* dev */,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL
+      },
+      backend: {
+        url: DEV_API_URL
+      },
+      syncingURL: DEV_SYNCING_URL
     }
-    return results;
+  ]
+]);
+function getMSafeConfig(env, options) {
+  const config = ENV_CONFIGS.get(env);
+  if (!config) {
+    throw new Error("Unknown environment");
   }
-  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;
+  if (options?.suiClient?.url) {
+    config.suiClient.url = options.suiClient.url;
   }
-  async getPublicKeyFromBackend(address) {
-    try {
-      const pk = await this.globals.backend.getPublicKey(address);
-      return pk;
-    } catch (_) {
-      return void 0;
+  if (options?.backend?.url) {
+    config.backend.url = options.backend.url;
+  }
+  return config;
+}
+
+// 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 = new BackendImpl(config.backend.url);
+    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;
   }
-  async getPublicKeyFromChain(address) {
-    return getPublicKeyFromChain(this.globals.suiClient, address);
+  set wallet(val) {
+    this._wallet = val;
   }
 };
 
@@ -1436,7 +1309,7 @@ var MSafeClient = class _MSafeClient {
     return jwt;
   }
   async authSign(wallet) {
-    const messageStr = MessageHelper.welcomeMessage((/* @__PURE__ */ new Date()).toUTCString());
+    const messageStr = import_sui3_utils6.SigningMessageHelper.loginMessageWithTimestamp((/* @__PURE__ */ new Date()).toUTCString());
     const sig = await wallet.signPersonalMessage({
       messageStr
     });
@@ -1448,7 +1321,10 @@ var MSafeClient = class _MSafeClient {
     });
   }
   async userInfo() {
-    return this.globals.backend.getUserInfo(await this.walletAddress());
+    return this.globals.backend.getUserInfo();
+  }
+  async ownedMSafe(pagination) {
+    return this.globals.backend.getOwnedMSafeByStatus({ status: import_sui3_utils6.UserMSafeStatus.active, pagination });
   }
   async createAccount(info) {
     return this.creationHelper.submitMSafeCreation(info);
@@ -1486,34 +1362,27 @@ var MSafeClient = class _MSafeClient {
   get AddressBook() {
     return new AddressBookSDK(this.globals);
   }
+  get Invitation() {
+    return new InvitationSDK(this.globals);
+  }
   async walletAddress() {
     return this.wallet.address();
   }
 };
-
-// src/types/address-book.ts
-var OpAddressBookType = /* @__PURE__ */ ((OpAddressBookType2) => {
-  OpAddressBookType2["Delete"] = "delete";
-  OpAddressBookType2["Upsert"] = "upsert";
-  return OpAddressBookType2;
-})(OpAddressBookType || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AUTH_SIGN_MESSAGE,
   AddressBookSDK,
   COIN_TYPE_ARG_REGEX,
   Coin,
   CoinHelper,
   CreateHelper,
   DEV_API_URL,
-  DEV_DATABASE_CONFIG,
   DEV_SYNCING_URL,
   ENV_CONFIGS,
   Formatter,
   HexToUint8Array,
   IntentionHelper,
   LOCAL_API_URL,
-  LOCAL_DATABASE_CONFIG,
   LOCAL_SYNCING_URL,
   MAINNET_RPC_URL,
   MSAFE_APPLICATION,
@@ -1521,13 +1390,9 @@ var OpAddressBookType = /* @__PURE__ */ ((OpAddressBookType2) => {
   MSafeClient,
   MSafeEnv,
   MSafeGlobals,
-  MessageHelper,
-  OpAddressBookType,
-  PublicKeySerde,
   SUI_COIN,
   SignatureVerifier,
   TESTNET_RPC_URL,
-  UNIT_DATABASE_CONFIG,
   Uint8ArrayToHex,
   getAllCoins,
   getMSafeConfig,