@msafe/sui3-sdk 0.0.11 → 0.0.12-pre-84adfec.0

package/dist/index.js

@@ -480,11 +480,12 @@ var MessageHelper = class {
     return matches ? matches[1] : void 0;
   }
   static proposeIntentionMessage(data) {
-    const { intention, sn } = data;
+    const { msafeAddress, intention, sn } = data;
     const intentionData = IntentionHelper.ser(intention);
     const msg = {
       intentionData,
-      sequenceNumber: sn
+      sequenceNumber: sn,
+      msafeAddress
     };
     return JSON.stringify(msg);
   }
@@ -493,8 +494,9 @@ var MessageHelper = class {
     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;
+    const { msafeAddress, sequenceNumber, intentionData } = de;
     return {
+      msafeAddress,
       sn: sequenceNumber,
       intention: IntentionHelper.de(intentionData)
     };
@@ -534,749 +536,376 @@ var AddressBookSDK = class {
 };
 
 // src/core/MSafeAccount.ts
-import { MultisigAccountManager as MultisigAccountManager2 } from "@msafe/sui3-utils";
+import {
+  buildIntentionTransaction,
+  getIntentionType,
+  MultisigAccountManager as MultisigAccountManager2
+} from "@msafe/sui3-utils";
 import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui.js/utils";
 
-// src/utils/iter/iterator.ts
-var REQUEST_PAGE_SIZE = 25;
-async function getAllFromIterator(it) {
-  const res = [];
-  while (await it.hasNext()) {
-    const val = await it.next();
-    res.push(val);
+// 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 (res && Array.isArray(res[0])) {
-    return res.flat(1);
+  if (options?.suiClient?.url) {
+    config.suiClient.url = options.suiClient.url;
   }
-  return res;
+  if (options?.backend) {
+    config.backend = options.backend;
+  }
+  return config;
 }
-var PagedIterator = class {
-  constructor(requester) {
-    this.requester = requester;
-    this.curPage = void 0;
-    this.init = true;
+var AUTH_SIGN_MESSAGE = "Welcome to MSafe";
+
+// src/globals/MSafeGlobals.ts
+import { SuiClient } from "@mysten/sui.js/client";
+
+// src/backend/BackendImpl.ts
+import axios from "axios";
+var BackendImpl = class {
+  constructor(apiURL) {
+    this.apiURL = apiURL;
   }
-  curPage;
-  init;
-  async hasNext() {
-    if (this.init) {
-      if (!this.curPage) {
-        this.curPage = await this.requester.doNextRequest();
-      }
-      return !!this.curPage.data?.length || this.curPage.hasNext;
-    }
-    if (!this.curPage) {
-      throw new Error("invalid implementation of iterator");
+  _token;
+  async authSign(input) {
+    const res = await axios.post(`${this.apiURL}/auth/login`, input);
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid authSign return: ${res}`);
     }
-    return this.curPage.hasNext;
+    this._token = res.data.accessToken;
+    return this._token;
   }
-  async next() {
-    if (this.init) {
-      this.init = false;
-      if (!this.curPage) {
-        this.curPage = await this.requester.doNextRequest();
-      }
-      return this.curPage.data;
+  async verifyToken(jwt) {
+    try {
+      const res = await axios.get(`${this.apiURL}/auth`, { headers: this.headers(jwt) });
+      return res.status === 200;
+    } catch (_) {
+      return false;
     }
-    this.curPage = await this.requester.doNextRequest();
-    return this.curPage.data;
   }
-};
-var EntryIterator = class {
-  constructor(requester) {
-    this.requester = requester;
-    this.pager = new PagedIterator(requester);
-    this.curData = [];
-    this.cursor = 0;
+  setJWTToken(token) {
+    this._token = token;
   }
-  cursor;
-  pager;
-  curData;
-  async hasNext() {
-    if (this.cursor < this.curData.length - 1) {
-      return true;
-    }
-    return this.pager.hasNext();
+  async getPublicKey(address) {
+    return (await this.getPublicKeyBatch([address]))[0];
   }
-  async next() {
-    this.cursor += 1;
-    while (this.cursor >= this.curData.length) {
-      if (!await this.pager.hasNext()) {
-        throw new Error("not more data");
-      } else {
-        this.curData = await this.pager.next();
-        this.cursor = 0;
+  async getPublicKeyBatch(addresses) {
+    const res = await axios.post(
+      `${this.apiURL}/account/getPublicKeyBatch`,
+      addresses,
+      {
+        headers: this.headers()
       }
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
     }
-    return this.curData[this.cursor];
-  }
-};
-
-// src/utils/iter/object.ts
-async function getAllOwnedObjects(provider, owner, options) {
-  const iter = new OwnedObjectIterator(provider, owner, options);
-  return await getAllFromIterator(iter);
-}
-var OwnedObjectIterator = class extends EntryIterator {
-  constructor(provider, owner, options) {
-    super(new OwnedObjectRequester(provider, owner, options));
-    this.provider = provider;
-    this.owner = owner;
-    this.options = options;
+    return res.data?.map(
+      (publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde.de({ ...publicKeyWithSchema }) : void 0
+    );
   }
-};
-var OwnedObjectRequester = class {
-  constructor(provider, owner, options) {
-    this.provider = provider;
-    this.owner = owner;
-    this.options = options;
-    this.nextCursor = null;
-    this.filter = options?.filter;
-    this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
-    this.objectOptions = options?.objectOptions || {
-      showType: true,
-      showContent: true
+  async getMSafeAccountInfo(msafeAddress) {
+    const res = await axios.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
     };
   }
-  nextCursor;
-  filter;
-  pageSize;
-  objectOptions;
-  async doNextRequest() {
-    const res = await this.provider.getOwnedObjects({
-      owner: this.owner,
-      options: this.objectOptions,
-      cursor: this.nextCursor,
-      limit: this.pageSize
+  async getUserInfo(userAddress) {
+    const res = await axios.get(`${this.apiURL}/account/user/${userAddress}`, {
+      headers: this.headers()
     });
-    this.nextCursor = res.nextCursor;
-    let filtered;
-    if (this.filter) {
-      const { filter } = this;
-      filtered = res.data.filter((obj) => filter?.(obj));
-    } else {
-      filtered = res.data;
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
     }
     return {
-      data: filtered.map((r) => r.data).filter((data) => data),
-      hasNext: res.hasNextPage
+      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
+        })
+      )
     };
   }
-};
-
-// src/core/MSafeAccount.ts
-var MSafeAccount = class {
-  constructor(globals, info) {
-    this.globals = globals;
-    this.info = info;
-    this.multisigManager = new MultisigAccountManager2({
-      threshold: info.threshold,
-      ownersWithWeight: info.ownersWithWeightPK,
-      creationNonce: info.creationNonce
+  async getPendingTransactions(msafeAddress) {
+    const res = await axios.get(`${this.apiURL}/transaction/pending/${msafeAddress}`, {
+      headers: this.headers()
     });
-    this.coinHelper = new CoinHelper(this.suiClient);
-  }
-  multisigManager;
-  coinHelper;
-  static async new(globals, address) {
-    return globals.backend.getMSafeAccountInfo(address);
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+    }
+    return res.data;
   }
-  async ownedCoins() {
-    const balances = await this.suiClient.getAllBalances({ owner: this.address });
-    return Promise.all(
-      balances.map(async (balance) => {
-        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: normalizeStructTag3(balance.coinType),
-          balance: BigInt(unlockedBalance),
-          metadata: meta
-        };
-      })
+  async getHistoryTransactions(msafeAddress, paginationOption) {
+    const res = await axios.get(
+      `${this.apiURL}/transaction/history?address=${msafeAddress}`,
+      {
+        params: {
+          page: paginationOption?.page,
+          limit: paginationOption?.limit
+        },
+        headers: this.headers()
+      }
     );
-  }
-  async ownedObjects(options) {
-    return getAllOwnedObjects(this.suiClient, this.address, options);
-  }
-  async pendingTransactions() {
-    return this.backend.getPendingTransactions(this.address);
-  }
-  async pendingTransaction() {
-    const pendings = await this.backend.getPendingTransactions(this.address);
-    if (pendings.length > 2) {
-      throw new Error(`invalid backend getPendingTransactions resp, length should not > 2: ${pendings}`);
-    }
-    if (pendings.length === 0) {
-      return void 0;
-    }
-    if (pendings.length === 1) {
-      return pendings[0];
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
     }
-    const [rejectPending, pendingTx] = pendings[0].isRejectTx ? [pendings[0], pendings[1]] : [pendings[1], pendings[0]];
-    pendingTx.rejectDigest = rejectPending.digest;
-    pendingTx.rejectPayload = rejectPending.payload;
-    pendingTx.rejectVotes = rejectPending.votes;
-    return pendingTx;
-  }
-  async historyTransaction(paginationOption) {
-    const paginatedHistoryTransactions = await this.backend.getHistoryTransactions(this.address, paginationOption);
-    return paginatedHistoryTransactions.data;
-  }
-  async futureIntentions(paginationOption) {
-    const paginatedIntentions = await this.backend.getFutureIntentions(this.address, paginationOption);
-    return paginatedIntentions.data;
-  }
-  async currentSequenceNumber() {
-    return this.backend.getCurrentSequenceNumber(this.address);
-  }
-  async nextSequenceNumber() {
-    return this.backend.getNextSequenceNumber(this.address);
+    return res.data;
   }
-  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 getFutureIntentions(msafeAddress, paginationOption) {
+    const res = await axios.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 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
+  async getCurrentSequenceNumber(msafeAddress) {
+    const res = await axios.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;
   }
-  // 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
+  async getNextSequenceNumber(msafeAddress) {
+    const res = await axios.get(`${this.apiURL}/transaction/sn/next/${msafeAddress}`, {
+      headers: this.headers()
     });
-    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
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getNextSequenceNumber return: ${res}`);
+    }
+    return res.data;
+  }
+  async createMSafeAccount(input) {
+    const res = await axios.post(`${this.apiURL}/account`, input, {
+      headers: this.headers()
     });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid createMSafeAccount return: ${res}`);
+    }
   }
-  async rejectCurrentTx(pending) {
-    let payloadToReject;
-    if (pending) {
-      if (pending.isRejectTx) {
-        throw new Error("Pending not reject transaction");
-      }
-      payloadToReject = pending.payload;
-    } else {
-      const pendingTx = await this.pendingTransaction();
-      if (!pendingTx || pendingTx?.rejectDigest !== void 0) {
-        throw new Error("Already rejected");
+  async proposeIntention(input) {
+    try {
+      const res = await axios.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}`);
       }
-      payloadToReject = pendingTx.payload;
+    } catch (e) {
+      console.log(e);
     }
-    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() });
+  // TODO later
+  async proposePendingTransaction(input) {
   }
-  async executePendingTx(pending) {
-    let gotSigs;
-    let payload;
-    if (pending.votes.length >= this.info.threshold) {
-      gotSigs = new Map(pending.votes.map((vote) => [vote.userAddress, vote.signature]));
-      payload = pending.payload;
-    } else if (pending.rejectVotes && pending.rejectPayload && pending.rejectVotes?.length >= this.info.threshold) {
-      gotSigs = new Map(pending.rejectVotes.map((vote) => [vote.userAddress, vote.signature]));
-      payload = pending.rejectPayload;
-    } 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);
+  async rejectCurrentTx(input) {
+    try {
+      const res = await axios.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);
     }
-    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
-    return this.suiClient.executeTransactionBlock({
-      transactionBlock: HexToUint8Array(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
-import { SuiClient } from "@mysten/sui.js/client";
-
-// src/backend/BackendImpl.ts
-import axios from "axios";
-var BackendImpl = class {
-  constructor(apiURL) {
-    this.apiURL = apiURL;
-  }
-  _token;
-  async authSign(input) {
-    const res = await axios.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 axios.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) {
+  async voteForTransaction(input) {
     const res = await axios.post(
-      `${this.apiURL}/account/getPublicKeyBatch`,
-      addresses,
+      `${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 getPublicKeyBatch return: ${res}`);
+      throw new Error(`invalid voteForTransaction return: ${res}`);
     }
-    return res.data?.map(
-      (publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde.de({ ...publicKeyWithSchema }) : void 0
-    );
   }
-  async getMSafeAccountInfo(msafeAddress) {
-    const res = await axios.get(
-      `${this.apiURL}/account/getMSafeAccountInfo/${msafeAddress}`,
+  async buildNextIntentionAndAddToPending(input) {
+    const res = await axios.post(
+      `${this.apiURL}/transaction/pending/build`,
       {
-        headers: this.headers()
-      }
+        address: input.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 axios.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 axios.get(`${this.apiURL}/transaction/pending/${msafeAddress}`, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+      throw new Error(`invalid buildNextIntentionAndAddToPending return: ${res}`);
     }
-    return res.data;
   }
-  async getHistoryTransactions(msafeAddress, paginationOption) {
-    const res = await axios.get(
-      `${this.apiURL}/transaction/history?address=${msafeAddress}`,
+  async skipNextFailedIntention(input) {
+    const res = await axios.post(
+      `${this.apiURL}/transaction/pending/skip`,
       {
-        params: {
-          page: paginationOption?.page,
-          limit: paginationOption?.limit
-        },
-        headers: this.headers()
-      }
+        msafeAddress: input.msafeAddress
+      },
+      { headers: this.headers() }
     );
     if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
+      throw new Error(`invalid skipNextFailedIntention return: ${res}`);
     }
-    return res.data;
   }
-  async getFutureIntentions(msafeAddress, paginationOption) {
-    const res = await axios.get(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
-      params: {
-        page: paginationOption?.page,
-        limit: paginationOption?.limit
-      },
-      headers: this.headers()
+  async getAddressBookEntries(pagination) {
+    const res = await axios.get(`${this.apiURL}/address-book`, {
+      headers: this.headers(),
+      params: pagination
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
+    if (res.status !== 200) {
+      throw new Error(`Invalid address-book return: ${res}`);
     }
     return res.data;
   }
-  async getCurrentSequenceNumber(msafeAddress) {
-    const res = await axios.get(`${this.apiURL}/transaction/sn/current/${msafeAddress}`, {
-      headers: this.headers()
-    });
+  async updateAddressBook(input) {
+    const res = await axios.post(`${this.apiURL}/address-book`, input, { headers: this.headers() });
     if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
+      throw new Error(`invalid updateAddressBook return: ${res}`);
     }
-    return res.data;
   }
-  async getNextSequenceNumber(msafeAddress) {
-    const res = await axios.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 processExecutedTransaction(digest) {
   }
-  async createMSafeAccount(input) {
-    const res = await axios.post(`${this.apiURL}/account`, input, {
-      headers: this.headers()
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid createMSafeAccount return: ${res}`);
-    }
+  headers(token) {
+    return { Authorization: `Bearer ${token || this._token}` };
   }
-  async proposeIntention(input) {
-    try {
-      const res = await axios.post(
-        `${this.apiURL}/transaction/intention`,
-        {
-          intention: input.intention,
-          sequenceNumber: input.sequenceNumber,
-          address: input.msafeAddress,
-          signature: input.signature
-        },
-        { 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 axios.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 axios.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 axios.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 axios.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 axios.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 axios.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/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 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 MSafeGlobals = class _MSafeGlobals {
@@ -1313,6 +942,415 @@ var MSafeGlobals = class _MSafeGlobals {
   }
 };
 
+// src/utils/iter/iterator.ts
+var REQUEST_PAGE_SIZE = 25;
+async function getAllFromIterator(it) {
+  const res = [];
+  while (await it.hasNext()) {
+    const val = await it.next();
+    res.push(val);
+  }
+  if (res && Array.isArray(res[0])) {
+    return res.flat(1);
+  }
+  return res;
+}
+var PagedIterator = class {
+  constructor(requester) {
+    this.requester = requester;
+    this.curPage = void 0;
+    this.init = true;
+  }
+  curPage;
+  init;
+  async hasNext() {
+    if (this.init) {
+      if (!this.curPage) {
+        this.curPage = await this.requester.doNextRequest();
+      }
+      return !!this.curPage.data?.length || this.curPage.hasNext;
+    }
+    if (!this.curPage) {
+      throw new Error("invalid implementation of iterator");
+    }
+    return this.curPage.hasNext;
+  }
+  async next() {
+    if (this.init) {
+      this.init = false;
+      if (!this.curPage) {
+        this.curPage = await this.requester.doNextRequest();
+      }
+      return this.curPage.data;
+    }
+    this.curPage = await this.requester.doNextRequest();
+    return this.curPage.data;
+  }
+};
+var EntryIterator = class {
+  constructor(requester) {
+    this.requester = requester;
+    this.pager = new PagedIterator(requester);
+    this.curData = [];
+    this.cursor = 0;
+  }
+  cursor;
+  pager;
+  curData;
+  async hasNext() {
+    if (this.cursor < this.curData.length - 1) {
+      return true;
+    }
+    return this.pager.hasNext();
+  }
+  async next() {
+    this.cursor += 1;
+    while (this.cursor >= this.curData.length) {
+      if (!await this.pager.hasNext()) {
+        throw new Error("not more data");
+      } else {
+        this.curData = await this.pager.next();
+        this.cursor = 0;
+      }
+    }
+    return this.curData[this.cursor];
+  }
+};
+
+// src/utils/iter/object.ts
+async function getAllOwnedObjects(provider, owner, options) {
+  const iter = new OwnedObjectIterator(provider, owner, options);
+  return await getAllFromIterator(iter);
+}
+var OwnedObjectIterator = class extends EntryIterator {
+  constructor(provider, owner, options) {
+    super(new OwnedObjectRequester(provider, owner, options));
+    this.provider = provider;
+    this.owner = owner;
+    this.options = options;
+  }
+};
+var OwnedObjectRequester = class {
+  constructor(provider, owner, options) {
+    this.provider = provider;
+    this.owner = owner;
+    this.options = options;
+    this.nextCursor = null;
+    this.filter = options?.filter;
+    this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
+    this.objectOptions = options?.objectOptions || {
+      showType: true,
+      showContent: true
+    };
+  }
+  nextCursor;
+  filter;
+  pageSize;
+  objectOptions;
+  async doNextRequest() {
+    const res = await this.provider.getOwnedObjects({
+      owner: this.owner,
+      options: this.objectOptions,
+      cursor: this.nextCursor,
+      limit: this.pageSize
+    });
+    this.nextCursor = res.nextCursor;
+    let filtered;
+    if (this.filter) {
+      const { filter } = this;
+      filtered = res.data.filter((obj) => filter?.(obj));
+    } else {
+      filtered = res.data;
+    }
+    return {
+      data: filtered.map((r) => r.data).filter((data) => data),
+      hasNext: res.hasNextPage
+    };
+  }
+};
+
+// src/core/MSafeAccount.ts
+var MSafeAccount = class {
+  constructor(globals, info) {
+    this.globals = globals;
+    this.info = info;
+    this.multisigManager = new MultisigAccountManager2({
+      threshold: info.threshold,
+      ownersWithWeight: info.ownersWithWeightPK,
+      creationNonce: info.creationNonce
+    });
+    this.coinHelper = new CoinHelper(this.suiClient);
+  }
+  multisigManager;
+  coinHelper;
+  static async new(globals, address) {
+    return globals.backend.getMSafeAccountInfo(address);
+  }
+  async ownedCoins() {
+    const balances = await this.suiClient.getAllBalances({ owner: this.address });
+    return Promise.all(
+      balances.map(async (balance) => {
+        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: normalizeStructTag3(balance.coinType),
+          balance: BigInt(unlockedBalance),
+          metadata: meta
+        };
+      })
+    );
+  }
+  async ownedObjects(options) {
+    const filterCoinObjectOptions = {
+      filter: (objRes) => !objRes?.data?.type?.startsWith("0x2::coin::Coin"),
+      ...options
+    };
+    return getAllOwnedObjects(this.suiClient, this.address, filterCoinObjectOptions);
+  }
+  async pendingTransaction() {
+    const pendings = await this.backend.getPendingTransactions(this.address);
+    if (pendings.length > 2) {
+      throw new Error(`invalid backend getPendingTransactions resp, length should not > 2: ${pendings}`);
+    }
+    if (pendings.length === 0) {
+      return void 0;
+    }
+    const pendingTx = pendings.find((tx) => !tx.isRejectTx);
+    const rejectPending = pendings.find((tx) => tx.isRejectTx);
+    return {
+      ...pendingTx,
+      rejectDigest: rejectPending?.digest ?? "",
+      rejectPayload: rejectPending?.payload ?? "",
+      rejectVotes: rejectPending?.votes ?? []
+    };
+  }
+  async historyTransaction(paginationOption) {
+    return this.backend.getHistoryTransactions(this.address, paginationOption);
+  }
+  async futureIntentions(paginationOption) {
+    const paginatedIntentions = await this.backend.getFutureIntentions(this.address, paginationOption);
+    return paginatedIntentions.data;
+  }
+  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,
+      msafeAddress: this.address
+    });
+    const signature = await this.wallet.signPersonalMessage({
+      messageStr: message
+    });
+    const txType = getIntentionType(intention);
+    await this.backend.proposeIntention({
+      intention,
+      sequenceNumber,
+      msafeAddress: this.address,
+      userAddress: await this.userAddress(),
+      signature: signature.signature,
+      application: MSAFE_APPLICATION,
+      txType: txType.txType,
+      txSubType: txType.txSubType
+    });
+  }
+  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 pendingTx = await this.pendingTransaction();
+      if (!pendingTx || pendingTx.rejectDigest !== "") {
+        throw new Error("Already rejected");
+      }
+      payloadToReject = pendingTx.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 simulateIntention(intention) {
+    const txb = await buildIntentionTransaction(this.suiClient, intention, this.address);
+    if (!txb.blockData.gasConfig.price) {
+      const refGas = await this.suiClient.getReferenceGasPrice();
+      txb.setGasPrice(refGas);
+    }
+    const payload = await txb.build({ client: this.suiClient });
+    const dryRunResult = await this.suiClient.dryRunTransactionBlock({ transactionBlock: payload });
+    const success = dryRunResult.effects.status.status === "success";
+    const errorMsg = dryRunResult.effects.status.error;
+    const gasPrice = BigInt(txb.blockData.gasConfig.price);
+    const { gasUsed } = dryRunResult.effects;
+    return {
+      success,
+      errorMsg,
+      gasPrice,
+      gasUsed,
+      dryRunResult
+    };
+  }
+  async executePendingTx(pending) {
+    let gotSigs;
+    let payload;
+    if (pending.votes.length >= this.info.threshold) {
+      gotSigs = new Map(pending.votes.map((vote) => [vote.userAddress, vote.signature]));
+      payload = pending.payload;
+    } else if (pending.rejectVotes && pending.rejectPayload && pending.rejectVotes?.length >= this.info.threshold) {
+      gotSigs = new Map(pending.rejectVotes.map((vote) => [vote.userAddress, vote.signature]));
+      payload = pending.rejectPayload;
+    } 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 multiSignature = this.multisigManager.combinePartialSignatures(sigs);
+    return this.suiClient.executeTransactionBlock({
+      transactionBlock: HexToUint8Array(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/core/MSafeClient.ts
 var MSafeClient = class _MSafeClient {
   constructor(globals) {
@@ -1418,6 +1456,7 @@ export {
   LOCAL_DATABASE_CONFIG,
   LOCAL_SYNCING_URL,
   MAINNET_RPC_URL,
+  MSAFE_APPLICATION,
   MSafeAccount,
   MSafeClient,
   MSafeEnv,