@msafe/sui3-sdk 0.0.5 → 0.0.6-pre-fdcc3ff.0

package/dist/index.js

@@ -1,5 +1,29 @@
-// src/transactions/coin-transfer.ts
-import { TransactionBlock } from "@mysten/sui.js/transactions";
+// src/core/CreateHelper.ts
+import {
+  createAccountCreationMessage,
+  MultisigAccountManager,
+  validateCreateAccountRequest
+} from "@msafe/sui3-utils";
+
+// src/utils/crypto.ts
+import {
+  SIGNATURE_FLAG_TO_SCHEME
+} from "@mysten/sui.js/cryptography";
+import { Ed25519PublicKey } from "@mysten/sui.js/keypairs/ed25519";
+import { Secp256k1PublicKey } from "@mysten/sui.js/keypairs/secp256k1";
+import { Secp256r1PublicKey } from "@mysten/sui.js/keypairs/secp256r1";
+import { verifyPersonalMessage, verifyTransactionBlock } from "@mysten/sui.js/verify";
+
+// src/utils/buffer.ts
+function stringToBuffer(s) {
+  return Buffer.from(s, "utf-8");
+}
+function Uint8ArrayToHex(b) {
+  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
+}
+function HexToUint8Array(hex) {
+  return Uint8Array.from(Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
+}
 
 // src/utils/format.ts
 import { normalizeSuiAddress, normalizeStructTag as normalizeStructTag2 } from "@mysten/sui.js/utils";
@@ -75,30 +99,6 @@ var Formatter = class {
   }
 };
 
-// src/utils/sui.ts
-import { parseSerializedSignature } from "@mysten/sui.js/cryptography";
-import { MultiSigPublicKey } from "@mysten/sui.js/multisig";
-
-// src/utils/crypto.ts
-import {
-  SIGNATURE_FLAG_TO_SCHEME
-} from "@mysten/sui.js/cryptography";
-import { Ed25519PublicKey } from "@mysten/sui.js/keypairs/ed25519";
-import { Secp256k1PublicKey } from "@mysten/sui.js/keypairs/secp256k1";
-import { Secp256r1PublicKey } from "@mysten/sui.js/keypairs/secp256r1";
-import { verifyPersonalMessage, verifyTransactionBlock } from "@mysten/sui.js/verify";
-
-// src/utils/buffer.ts
-function stringToBuffer(s) {
-  return Buffer.from(s, "utf-8");
-}
-function Uint8ArrayToHex(b) {
-  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join("")}`;
-}
-function HexToUint8Array(hex) {
-  return Uint8Array.from(Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex"));
-}
-
 // src/utils/crypto.ts
 var SignatureVerifier = class _SignatureVerifier {
   static async getPublicKeyFromSignature(input) {
@@ -158,7 +158,78 @@ var PublicKeySerde = class {
   }
 };
 
+// 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 MultisigAccountManager(msConfig);
+    return ms.address;
+  }
+  // Validate the create info and return the msafe address.
+  async validateCreateInfo(createInfo) {
+    const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
+    validateCreateAccountRequest(rawConfig);
+    return this.calculateMSafeAddress(createInfo);
+  }
+  async submitMSafeCreation(creationInfo) {
+    const msafeAddress = await this.validateCreateInfo(creationInfo);
+    const signingMessage = 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/transactions/coin-transfer.ts
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+
 // src/utils/sui.ts
+import { parseSerializedSignature } from "@mysten/sui.js/cryptography";
+import { MultiSigPublicKey } from "@mysten/sui.js/multisig";
 var SUI_COIN = "0x2::sui::SUI";
 async function getPublicKeyFromChain(suiClient, address) {
   let txs;
@@ -426,165 +497,19 @@ var MessageHelper = class {
   }
 };
 
-// src/utils/multi-sig.ts
-import { Ed25519PublicKey as Ed25519PublicKey2 } from "@mysten/sui.js/keypairs/ed25519";
-import { MultiSigPublicKey as MultiSigPublicKey2 } from "@mysten/sui.js/multisig";
-var NONCE_PK_PREFIX = "maven";
-var NONCE_PREFIX_MAX_SIZE = 16;
-var NONCE_PK_WEIGHT = 1;
-var MAX_WEIGHT = 255;
-var MIN_WEIGHT = 1;
-var MAX_OWNER_WITH_NONCE = 9;
-var MAX_OWNER_WITHOUT_NONCE = 10;
-var MIN_THRESHOLD = 1;
-var RawMultiSig = class _RawMultiSig {
-  constructor(config) {
-    this.config = config;
-    this.rawMsPK = getMultiSigPublicKey(config);
-  }
-  rawMsPK;
-  static fromMSafeAccountInfo(info) {
-    const parsed = {
-      threshold: info.threshold,
-      ownerWithWeight: info.ownersWithWeightPK,
-      creationNonce: info.creationNonce
-    };
-    return new _RawMultiSig(parsed);
-  }
-  get suiAddress() {
-    return this.rawMsPK.toSuiAddress();
-  }
-  get publicKeys() {
-    return this.rawMsPK.getPublicKeys();
-  }
-  get threshold() {
-    return this.config.threshold;
-  }
-  combinePartialSignatures(signatures) {
-    return this.rawMsPK.combinePartialSignatures(signatures);
-  }
-  async verifyPersonalMessage(messageStr, multiSigSignature) {
-    const message = stringToBuffer(messageStr);
-    return this.rawMsPK.verifyPersonalMessage(message, multiSigSignature);
-  }
-};
-function getMultiSigPublicKey(config) {
-  const { ownerWithWeight, threshold, creationNonce } = config;
-  const pks = ownerWithWeight.map((pk) => ({
-    publicKey: pk.publicKey,
-    weight: pk.weight
-  }));
-  if (creationNonce !== void 0) {
-    pks.push({
-      publicKey: makeNoncePublicKey(creationNonce),
-      weight: NONCE_PK_WEIGHT
-    });
-  }
-  return MultiSigPublicKey2.fromPublicKeys({ threshold, publicKeys: pks });
-}
-function makeNoncePublicKey(nonce) {
-  const buffer = new ArrayBuffer(Ed25519PublicKey2.SIZE);
-  const textEncoder = new TextEncoder();
-  textEncoder.encodeInto(NONCE_PK_PREFIX, new Uint8Array(buffer, 0, NONCE_PREFIX_MAX_SIZE));
-  const nonceView = new DataView(buffer, NONCE_PREFIX_MAX_SIZE, 4);
-  nonceView.setUint32(0, nonce, true);
-  return new Ed25519PublicKey2(new Uint8Array(buffer));
-}
-function validateMultiSigConfig(config) {
-  config.ownerWithWeight.forEach((pk) => {
-    const { weight } = pk;
-    if (weight < MIN_WEIGHT || weight > MAX_WEIGHT) {
-      throw new Error(`Invalid multi-sig weight: ${weight} (1-${MAX_WEIGHT})`);
-    }
-  });
-  const totalWeight = config.ownerWithWeight.reduce((s, pk) => s + pk.weight, 0);
-  if (config.threshold > totalWeight) {
-    throw new Error("Threshold is larger than total weight");
-  }
-  if (config.threshold < MIN_THRESHOLD) {
-    throw new Error("Threshold is smaller than 1");
-  }
-  const maxOwner = config.creationNonce === void 0 ? MAX_OWNER_WITHOUT_NONCE : MAX_OWNER_WITH_NONCE;
-  if (config.ownerWithWeight.length > maxOwner) {
-    throw new Error("Owner number bigger than upper cap");
-  }
-  const addressSet = new Set(config.ownerWithWeight.map((pk) => pk.publicKey.toSuiAddress()));
-  if (addressSet.size !== config.ownerWithWeight.length) {
-    throw new Error("Duplicate address detected");
-  }
-}
-
-// src/core/CreateHelper.ts
-var CreateHelper = class {
-  constructor(globals, pkHelper) {
-    this.globals = globals;
-    this.pkHelper = pkHelper;
-  }
-  async getPublicKeyBatch(addresses) {
-    return this.pkHelper.getPublicKeyBatch(addresses);
-  }
-  async calculateMSafeAddress(info) {
-    const msConfig = await this.reduceCreationInfoToRawConfig(info);
-    const ms = new RawMultiSig(msConfig);
-    return ms.suiAddress;
-  }
-  // Validate the create info and return the msafe address.
-  async validateCreateInfo(createInfo) {
-    const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
-    validateMultiSigConfig(rawConfig);
-    return this.calculateMSafeAddress(createInfo);
-  }
-  async submitMSafeCreation(creationInfo) {
-    const msafeAddress = await this.validateCreateInfo(creationInfo);
-    const signingMessage = MessageHelper.createMSafeMessage(msafeAddress);
-    const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
-    await this.submitToBackend(creationInfo, signature.signature);
-    return msafeAddress;
-  }
-  async reduceCreationInfoToRawConfig(info) {
-    const publicKeys = await this.getPublicKeyBatch(info.ownerWithWeight.map((oww) => oww.address));
-    publicKeys.forEach((pk, i) => {
-      if (pk === void 0) {
-        throw new Error(`Unknown public key for address: ${info.ownerWithWeight[i].address}`);
-      }
-    });
-    return {
-      threshold: info.threshold,
-      ownerWithWeight: info.ownerWithWeight.map((owner, i) => ({
-        publicKey: publicKeys[i],
-        weight: owner.weight
-      })),
-      creationNonce: info.creationNonce
-    };
-  }
-  async submitToBackend(createInfo, signature) {
-    const pks = await this.pkHelper.getPublicKeyBatch(createInfo.ownerWithWeight.map((owner) => owner.address));
-    await this.globals.backend.createMSafeAccount({
-      ownerWithWeight: createInfo.ownerWithWeight.map((owner, i) => ({
-        address: owner.address,
-        weight: owner.weight,
-        publicKey: pks[i]
-        // PublicKey has been verified.
-      })),
-      threshold: createInfo.threshold,
-      name: createInfo.name,
-      // name validation is deferred to backend
-      description: createInfo.description,
-      // description validation is deferred to backend
-      creationNonce: createInfo.creationNonce,
-      signature
-    });
-  }
-};
-
 // src/core/MSafeAccount.ts
+import { MultisigAccountManager as MultisigAccountManager2 } from "@msafe/sui3-utils";
 var MSafeAccount = class _MSafeAccount {
   constructor(globals, info) {
     this.globals = globals;
     this.info = info;
-    this.rawMultiSig = RawMultiSig.fromMSafeAccountInfo(info);
+    this.multisigManager = new MultisigAccountManager2({
+      threshold: info.threshold,
+      ownersWithWeight: info.ownersWithWeightPK,
+      creationNonce: info.creationNonce
+    });
   }
-  rawMultiSig;
+  multisigManager;
   static async new(globals, address) {
     const info = await globals.backend.getMSafeAccountInfo(address);
     return new _MSafeAccount(globals, info);
@@ -693,7 +618,7 @@ var MSafeAccount = class _MSafeAccount {
         sigs.push(signature);
       }
     }
-    const multiSignature = this.rawMultiSig.combinePartialSignatures(sigs);
+    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(pending.payload),
       signature: multiSignature,
@@ -786,762 +711,6 @@ var PublicKeyHelper = class {
 // src/globals/MSafeGlobals.ts
 import { SuiClient } from "@mysten/sui.js/client";
 
-// src/backend/PseudoBackend.ts
-import "reflect-metadata";
-import { MoreThanOrEqual } from "typeorm";
-
-// src/backend/CoreDatabase.ts
-import "reflect-metadata";
-import { CoreModel } from "@msafe/sui3-model/core";
-var WALLET_TYPE_KEY = "wallet_type";
-var CoreDB = class _CoreDB {
-  constructor(coreModel) {
-    this.coreModel = coreModel;
-  }
-  static async New(dbConfig) {
-    const core = await CoreModel.New(dbConfig);
-    return new _CoreDB(core);
-  }
-  async upsertUser(input) {
-    const currentUser = await this.coreModel.user.findOneBy({
-      address: input.address
-    });
-    if (currentUser !== null) {
-      currentUser.lastLogin = input.lastLogin;
-      await this.coreModel.user.save(currentUser);
-    } else {
-      const serializedPublicKey = PublicKeySerde.ser(input.publicKey);
-      const user = {
-        address: input.address,
-        publicKey: serializedPublicKey.publicKey,
-        schema: serializedPublicKey.scheme,
-        nonce: 0,
-        lastLogin: /* @__PURE__ */ new Date()
-      };
-      await this.coreModel.user.save(user);
-    }
-  }
-  async updateUserWalletType(input) {
-    const exist = await this.coreModel.userSetting.findOneBy({
-      userAddress: input.address,
-      key: WALLET_TYPE_KEY
-    });
-    const walletType = input.walletType.trim();
-    if (exist === null || exist.value !== walletType) {
-      const userSetting = {
-        userAddress: input.address,
-        key: WALLET_TYPE_KEY,
-        value: walletType
-      };
-      await this.coreModel.userSetting.save(userSetting);
-    }
-  }
-};
-
-// src/backend/PseudoBackend.ts
-var PseudoBackend = class _PseudoBackend {
-  constructor(db, _suiClient) {
-    this.db = db;
-    this._suiClient = _suiClient;
-  }
-  _token;
-  static async New(dbConfig, suiClient) {
-    const db = await CoreDB.New(dbConfig);
-    return new _PseudoBackend(db, suiClient);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
-  async isJWTTokenValid(_jwt) {
-    return true;
-  }
-  async authSign(input) {
-    const timestamp = MessageHelper.deWelcomeMessage(input.message);
-    if (!timestamp) {
-      throw new Error("Invalid welcome message");
-    }
-    const date = Date.parse(timestamp);
-    if ((/* @__PURE__ */ new Date()).getTime() - date < 0) {
-      throw new Error("Invalid timestamp");
-    }
-    if ((/* @__PURE__ */ new Date()).getTime() - date > 10 * 1e3) {
-      throw new Error("Signing message expired");
-    }
-    const publicKey = await SignatureVerifier.getPublicKeyFromPersonalSignature({
-      messageStr: input.message,
-      signature: input.signature
-    });
-    if (!Formatter.isSuiAddressEqual(input.address, publicKey.toSuiAddress())) {
-      throw new Error("Invalid signature");
-    }
-    await this.db.upsertUser({
-      address: input.address,
-      publicKey,
-      lastLogin: /* @__PURE__ */ new Date()
-    });
-    await this.db.updateUserWalletType({
-      address: input.address,
-      walletType: input.walletType
-    });
-    this._token = "";
-    return this._token;
-  }
-  setJWTToken(token) {
-    this._token = token;
-  }
-  async getPublicKey(address) {
-    const user = await this.model.user.findOneBy({
-      address
-    });
-    if (user === null) {
-      return void 0;
-    }
-    return PublicKeySerde.de({
-      publicKey: user.publicKey,
-      scheme: user.schema
-    });
-  }
-  async getPublicKeyBatch(addresses) {
-    const res = [];
-    for (let i = 0; i < addresses.length; i++) {
-      const address = addresses[i];
-      const user = await this.getUser(address);
-      res.push(
-        user ? PublicKeySerde.de({
-          publicKey: user.publicKey,
-          scheme: user.schema
-        }) : void 0
-      );
-    }
-    return res;
-  }
-  async createMSafeAccount(input) {
-    const ms = new RawMultiSig(input);
-    const msafeAddr = ms.suiAddress;
-    const signingMsg = MessageHelper.createMSafeMessage(msafeAddr);
-    const targetAddr = input.ownerWithWeight[0].address;
-    const verifyResult = await SignatureVerifier.verifyPersonalSignature({
-      messageStr: signingMsg,
-      signature: input.signature,
-      targetAddress: targetAddr
-    });
-    if (!verifyResult) {
-      throw new Error("Signature verification failed");
-    }
-    if (input.name.length > 128) {
-      throw new Error("Name too long");
-    }
-    if (input.description && input.description.length > 512) {
-      throw new Error("Description too long");
-    }
-    const creatorAddress = input.ownerWithWeight[0].address;
-    const creator = await this.getUser(creatorAddress);
-    if (creator === null) {
-      throw new Error("Creator not found");
-    }
-    if (creator.nonce !== input.creationNonce) {
-      throw new Error("Nonce not match");
-    }
-    const msafeExistCheck = await this.model.msafe.findOneBy({
-      address: msafeAddr
-    });
-    if (msafeExistCheck !== null) {
-      throw new Error("MSafe already exist in database");
-    }
-    input.ownerWithWeight.forEach((ownerInfo) => {
-      if (!Formatter.isSuiAddressEqual(ownerInfo.address, ownerInfo.publicKey.toSuiAddress())) {
-        throw new Error("Sui address public key not match");
-      }
-    });
-    for (let i = 0; i !== input.ownerWithWeight.length; i++) {
-      const ownerInfo = input.ownerWithWeight[i];
-      if (i !== 0) {
-        const coManager = await this.getUser(ownerInfo.address);
-        const serPK = PublicKeySerde.ser(ownerInfo.publicKey);
-        if (coManager === null) {
-          const user = {
-            address: ownerInfo.address,
-            publicKey: serPK.publicKey,
-            schema: serPK.scheme,
-            nonce: 0,
-            lastLogin: /* @__PURE__ */ new Date()
-          };
-          await this.model.user.save(user);
-        }
-      }
-      const userMSafe = {
-        userAddress: ownerInfo.address,
-        msafeAddress: msafeAddr,
-        index: i,
-        weight: ownerInfo.weight,
-        status: i === 0 ? "active" : "pending"
-      };
-      await this.model.userMSafe.save(userMSafe);
-    }
-    const creationNonce = creator.nonce;
-    creator.nonce++;
-    await this.model.user.save(creator);
-    const msafe = {
-      address: msafeAddr,
-      creationNonce,
-      creator: creatorAddress,
-      name: input.name,
-      description: input.description,
-      threshold: input.threshold
-    };
-    await this.model.msafe.save(msafe);
-  }
-  async getMSafeAccountInfo(msafeAddress) {
-    const msafe = await this.model.msafe.findOneBy({ address: msafeAddress });
-    if (msafe === null) {
-      throw new Error("MSafe not found");
-    }
-    const userMSafes = await this.model.userMSafe.find({
-      where: {
-        msafeAddress
-      },
-      order: {
-        index: "asc"
-      }
-    });
-    if (userMSafes.length === 0) {
-      throw new Error("MSafe does not have user info.");
-    }
-    const users = await Promise.all(userMSafes.map((um) => this.getUser(um.userAddress)));
-    users.forEach((user) => {
-      if (user === null) {
-        throw new Error("User not found");
-      }
-    });
-    const ownersWithWeightPK = userMSafes.map((userMSafe, i) => ({
-      address: userMSafe.userAddress,
-      weight: userMSafe.weight,
-      publicKey: PublicKeySerde.de({ publicKey: users[i].publicKey, scheme: users[i].schema })
-    }));
-    return {
-      address: msafeAddress,
-      ownersWithWeightPK,
-      threshold: msafe.threshold,
-      name: msafe.name,
-      description: msafe.description,
-      creationNonce: msafe.creationNonce
-    };
-  }
-  async getUserInfo(userAddress) {
-    const user = await this.getUser(userAddress);
-    if (user === null) {
-      throw new Error("404: user not found");
-    }
-    const msafeAccounts = await this.model.userMSafe.findBy({ userAddress });
-    const ownedMSafe = await Promise.all(
-      msafeAccounts.map(async (msafeAccount) => this.getMSafeAccountInfo(msafeAccount.msafeAddress))
-    );
-    return {
-      address: userAddress,
-      publicKey: user.publicKey,
-      schema: user.schema,
-      creationNonce: user.nonce,
-      ownedMSafe
-    };
-  }
-  async getPendingTransactions(msafeAddress) {
-    const pendings = await this.db.coreModel.pendingTransaction.findBy({
-      msafeAddress
-    });
-    if (pendings.length === 0) {
-      return [];
-    }
-    const votes = await Promise.all(
-      pendings.map((pending) => this.db.coreModel.userVote.findBy({ txDigest: pending.digest, isValid: true }))
-    );
-    const intention = await this.model.transactionIntention.findOneBy({
-      msafeAddress,
-      sequenceNumber: pendings[0].sequenceNumber
-    });
-    if (intention === null) {
-      throw new Error("Intention not found");
-    }
-    const intent = IntentionHelper.de(intention.data);
-    return pendings.map((pending, i) => ({
-      digest: pending.digest,
-      payload: pending.payload,
-      msafeAddress: pending.msafeAddress,
-      isRejectTx: pending.isRejectTx,
-      creator: pending.creator,
-      createdAt: pending.createdAt,
-      votes: votes[i].map((vote) => ({
-        userAddress: vote.userAddress,
-        signature: vote.signature,
-        timestamp: vote.updatedAt
-      })),
-      sequenceNumber: pending.sequenceNumber,
-      intention: pending.isRejectTx ? void 0 : intent
-    }));
-  }
-  async getCurrentSequenceNumber(msafeAddress) {
-    const maxSNHistory = await this.model.historyTransaction.findOne({
-      where: { msafeAddress },
-      order: { sequenceNumber: "desc" }
-    });
-    return maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
-  }
-  async getNextSequenceNumber(msafeAddress) {
-    const maxSNIntention = await this.model.transactionIntention.findOne({
-      where: { msafeAddress },
-      order: { sequenceNumber: "desc" }
-    });
-    return maxSNIntention === null ? 0 : maxSNIntention.sequenceNumber + 1;
-  }
-  async getHistoryTransactions(msafeAddress) {
-    const transactions = await this.db.coreModel.historyTransaction.find({
-      where: {
-        msafeAddress
-      },
-      order: { sequenceNumber: "desc" }
-    });
-    const votes = await Promise.all(
-      transactions.map(
-        (tx) => this.db.coreModel.userVote.findBy({
-          txDigest: tx.digest,
-          isValid: true
-        })
-      )
-    );
-    return transactions.map((tx, i) => ({
-      digest: tx.digest,
-      payload: tx.payload,
-      msafeAddress: tx.msafeAddress,
-      isRejectTx: tx.isRejectTx,
-      status: tx.status,
-      creator: tx.creator,
-      createdAt: tx.createdAt,
-      sequenceNumber: tx.sequenceNumber,
-      votes: votes[i].map((vote) => ({
-        userAddress: vote.userAddress,
-        timestamp: vote.updatedAt
-      }))
-    }));
-  }
-  async getFutureIntentions(msafeAddress) {
-    const currentSequenceNumber = await this.getCurrentSequenceNumber(msafeAddress);
-    const hasPending = await this.model.pendingTransaction.findOneBy({ msafeAddress }) !== null;
-    const futureSNStart = hasPending ? currentSequenceNumber + 1 : currentSequenceNumber;
-    const futureTxs = await this.model.transactionIntention.find({
-      where: { msafeAddress, sequenceNumber: MoreThanOrEqual(futureSNStart) },
-      order: { sequenceNumber: "asc" }
-    });
-    return futureTxs.map((tx) => ({
-      intention: IntentionHelper.de(tx.data),
-      msafeAddress: tx.msafeAddress,
-      sequenceNumber: tx.sequenceNumber,
-      rawData: tx.data,
-      txType: tx.txType,
-      txSubType: tx.txSubType,
-      processed: tx.processed,
-      status: tx.status,
-      statusRemark: tx.statusRemark,
-      creator: tx.creator,
-      createdAt: tx.createdAt
-    }));
-  }
-  async proposeIntention(input) {
-    const userMSafe = await this.model.userMSafe.findOneBy({
-      msafeAddress: input.msafeAddress,
-      userAddress: input.userAddress
-    });
-    if (!userMSafe) {
-      throw new Error("User does not have permission to propose intention");
-    }
-    const verified = await SignatureVerifier.verifyPersonalSignature({
-      messageStr: MessageHelper.proposeIntentionMessage({ intention: input.intention, sn: input.sequenceNumber }),
-      signature: input.signature,
-      targetAddress: input.userAddress
-    });
-    if (!verified) {
-      throw new Error("Invalid signature");
-    }
-    const sequenceNumber = await this.model.transactionIntention.count({
-      where: {
-        msafeAddress: input.msafeAddress
-      }
-    });
-    if (sequenceNumber !== input.sequenceNumber) {
-      throw new Error("Sequence number not expected");
-    }
-    const intention = {
-      msafeAddress: input.msafeAddress,
-      sequenceNumber,
-      processed: false,
-      ...IntentionHelper.getTxType(input.intention),
-      data: IntentionHelper.ser(input.intention),
-      status: "NEW",
-      creator: input.userAddress
-    };
-    await this.model.transactionIntention.save(intention);
-  }
-  // Propose a pending transaction. Require the msafe account
-  // Does not have any pending transactions.
-  async proposePendingTransaction(input) {
-    const userMSafe = await this.model.userMSafe.findOneBy({
-      msafeAddress: input.msafeAddress,
-      userAddress: input.userAddress
-    });
-    if (userMSafe === null) {
-      throw new Error("Unauthorized");
-    }
-    const msafePendings = await this.model.pendingTransaction.findBy({
-      msafeAddress: input.msafeAddress
-    });
-    if (msafePendings.length !== 0) {
-      throw new Error("Still have pending transaction");
-    }
-    const txb = await IntentionHelper.buildTxb({
-      suiClient: this._suiClient,
-      intention: input.intention,
-      sender: input.msafeAddress
-    });
-    const payload = await txb.build({ client: this._suiClient });
-    const txDigest = await txb.getDigest({ client: this._suiClient });
-    if (txDigest !== input.digest) {
-      throw new Error("Transaction digest un-match");
-    }
-    const verified = await SignatureVerifier.verifyTransactionSignature({
-      payload,
-      targetAddress: input.userAddress,
-      signature: input.signature
-    });
-    if (!verified) {
-      throw new Error("Failed to verify signature");
-    }
-    const maxSNHistory = await this.model.historyTransaction.findOne({
-      where: { msafeAddress: input.msafeAddress },
-      order: { sequenceNumber: "desc" }
-    });
-    const sequenceNumber = maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
-    const intention = {
-      msafeAddress: input.msafeAddress,
-      sequenceNumber,
-      processed: false,
-      ...IntentionHelper.getTxType(input.intention),
-      data: IntentionHelper.ser(input.intention),
-      status: "SUCCESS",
-      creator: input.userAddress
-    };
-    await this.model.transactionIntention.save(intention);
-    const pendingTx = {
-      digest: txDigest,
-      msafeAddress: input.msafeAddress,
-      payload: Uint8ArrayToHex(payload),
-      sequenceNumber,
-      isRejectTx: false,
-      creator: input.userAddress
-    };
-    await this.model.pendingTransaction.save(pendingTx);
-    const userVote = {
-      userAddress: input.userAddress,
-      txDigest,
-      msafeAddress: input.msafeAddress,
-      signature: input.signature,
-      isValid: true
-    };
-    await this.model.userVote.save(userVote);
-  }
-  // Calls for the first reject transaction
-  async rejectCurrentTx(input) {
-    const userMSafe = await this.model.userMSafe.findOneBy({
-      userAddress: input.userAddress,
-      msafeAddress: input.msafeAddress
-    });
-    if (userMSafe === null) {
-      throw new Error("User does not have permission to MSafe");
-    }
-    const currentPending = await this.model.pendingTransaction.findOneBy({
-      msafeAddress: input.msafeAddress,
-      isRejectTx: false
-    });
-    if (currentPending === null) {
-      throw new Error("No active pending transaction");
-    }
-    const txb = await IntentionHelper.buildRejectTransaction({
-      msafeAddress: input.msafeAddress,
-      payloadToReject: currentPending.payload
-    });
-    const payload = await txb.build({ client: this._suiClient });
-    const digest = await txb.getDigest({ client: this._suiClient });
-    if (input.digest !== digest) {
-      throw new Error("Digest not match");
-    }
-    const verified = await SignatureVerifier.verifyTransactionSignature({
-      payload,
-      targetAddress: input.userAddress,
-      signature: input.signature
-    });
-    if (!verified) {
-      throw new Error("Signature unverified");
-    }
-    const existPendingReject = await this.model.pendingTransaction.findOneBy({
-      msafeAddress: input.msafeAddress,
-      isRejectTx: true
-    });
-    if (existPendingReject !== null) {
-      await this.voteForTransaction({
-        txDigest: existPendingReject.digest,
-        msafeAddress: input.msafeAddress,
-        userAddress: input.userAddress,
-        signature: input.signature
-      });
-      return;
-    }
-    const rejectPayloadStr = Uint8ArrayToHex(payload);
-    const rejectDigest = await txb.getDigest({ client: this._suiClient });
-    const rejectPending = {
-      msafeAddress: input.msafeAddress,
-      digest: rejectDigest,
-      payload: rejectPayloadStr,
-      sequenceNumber: currentPending.sequenceNumber,
-      isRejectTx: true,
-      creator: input.userAddress
-    };
-    await this.model.pendingTransaction.save(rejectPending);
-    const rejectVote = {
-      userAddress: input.userAddress,
-      msafeAddress: input.msafeAddress,
-      txDigest: rejectDigest,
-      signature: input.signature,
-      isValid: true
-    };
-    await this.model.userVote.save(rejectVote);
-    const existVote = await this.model.userVote.findOneBy({
-      txDigest: currentPending.digest,
-      userAddress: input.userAddress
-    });
-    if (existVote !== null) {
-      await this.model.userVote.update(
-        { userAddress: input.userAddress, txDigest: currentPending.digest },
-        { isValid: false }
-      );
-    }
-  }
-  async voteForTransaction(input) {
-    const pendingTx = await this.model.pendingTransaction.findOneBy({ digest: input.txDigest });
-    if (!pendingTx) {
-      throw new Error(`Pending transaction not found: ${input.txDigest}`);
-    }
-    if (pendingTx.msafeAddress !== input.msafeAddress) {
-      throw new Error("MSafe address not match");
-    }
-    const userMSafe = await this.model.userMSafe.findOneBy({
-      userAddress: input.userAddress,
-      msafeAddress: input.msafeAddress
-    });
-    if (userMSafe === null) {
-      throw new Error(`User (${input.userAddress}) does not have permission on MSafe account (${input.msafeAddress})`);
-    }
-    const payload = HexToUint8Array(pendingTx.payload);
-    const verified = await SignatureVerifier.verifyTransactionSignature({
-      payload,
-      targetAddress: input.userAddress,
-      signature: input.signature
-    });
-    if (!verified) {
-      throw new Error("Invalid signature");
-    }
-    const rejectPendingTx = await this.model.pendingTransaction.findOneBy({
-      msafeAddress: input.msafeAddress,
-      sequenceNumber: pendingTx.sequenceNumber,
-      isRejectTx: !pendingTx.isRejectTx
-    });
-    if (rejectPendingTx !== null) {
-      await this.model.userVote.update(
-        {
-          userAddress: input.userAddress,
-          txDigest: rejectPendingTx.digest,
-          isValid: true
-        },
-        { isValid: false }
-      );
-    }
-    const existVote = await this.model.userVote.exist({
-      where: {
-        txDigest: input.txDigest,
-        userAddress: input.userAddress
-      }
-    });
-    if (!existVote) {
-      const userVote = {
-        txDigest: input.txDigest,
-        userAddress: input.userAddress,
-        msafeAddress: input.msafeAddress,
-        signature: input.signature,
-        isValid: true
-      };
-      await this.model.userVote.save(userVote);
-    } else {
-      await this.model.userVote.update(
-        {
-          txDigest: input.txDigest,
-          userAddress: input.userAddress
-        },
-        { isValid: true }
-      );
-    }
-  }
-  // Mock the process of an executed transaction
-  // Here only the essential logic of transaction processing logic
-  // is implemented. Need more transaction parsing from the fetcher
-  // module.
-  //
-  // TODO: User queryRunner to make the transaction atomic.
-  async processExecutedTransaction(digest) {
-    const historyTx = await this.model.historyTransaction.findOneBy({ digest });
-    if (historyTx) {
-      return;
-    }
-    const pendingTx = await this.model.pendingTransaction.findOneBy({ digest });
-    if (!pendingTx) {
-      throw new Error("Transaction digest not found");
-    }
-    await this.model.transactionIntention.update(
-      { msafeAddress: pendingTx.msafeAddress, sequenceNumber: pendingTx.sequenceNumber },
-      { processed: true }
-    );
-    const pendings = await this.model.pendingTransaction.findBy({
-      msafeAddress: pendingTx.msafeAddress,
-      sequenceNumber: pendingTx.sequenceNumber
-    });
-    if (pendings.length === 0) {
-      throw new Error("Pending transaction not found");
-    }
-    const executionResult = "success";
-    for (let i = 0; i !== pendings.length; i++) {
-      const pending = pendings[i];
-      const history = {
-        digest: pending.digest,
-        payload: pending.payload,
-        msafeAddress: pending.msafeAddress,
-        sequenceNumber: pending.sequenceNumber,
-        isRejectTx: pending.isRejectTx,
-        creator: pending.creator,
-        createdAt: pending.createdAt,
-        // TODO: Fill in this field based on transaction processing result
-        status: pending.digest === digest ? executionResult : "rejected"
-      };
-      await this.model.historyTransaction.save(history);
-      await this.model.pendingTransaction.delete({ digest: pending.digest });
-    }
-  }
-  /**
-   * Build the next transaction intention, and add the built transaction to pendings.
-   * @param input
-   */
-  async buildNextIntentionAndAddToPending(input) {
-    const maxSNHistory = await this.model.historyTransaction.findOne({
-      where: { msafeAddress: input.msafeAddress },
-      order: { sequenceNumber: "desc" }
-    });
-    const nextSequenceNumber = maxSNHistory ? maxSNHistory.sequenceNumber + 1 : 0;
-    const currentPendings = await this.model.pendingTransaction.findBy({
-      msafeAddress: input.msafeAddress
-    });
-    if (currentPendings.length !== 0) {
-      throw new Error("Still have pendings");
-    }
-    const nextTx = await this.model.transactionIntention.findOneBy({
-      msafeAddress: input.msafeAddress,
-      sequenceNumber: nextSequenceNumber
-    });
-    if (nextTx === null) {
-      throw new Error("No future intentions to build");
-    }
-    const nextIntention = IntentionHelper.de(nextTx.data);
-    try {
-      const newTxb = await IntentionHelper.buildTxb({
-        suiClient: this._suiClient,
-        sender: input.msafeAddress,
-        intention: nextIntention
-      });
-      const payload = await newTxb.build({ client: this._suiClient });
-      const newDigest = await newTxb.getDigest({ client: this._suiClient });
-      const newPending = {
-        digest: newDigest,
-        payload: Uint8ArrayToHex(payload),
-        msafeAddress: input.msafeAddress,
-        sequenceNumber: nextTx.sequenceNumber,
-        isRejectTx: false,
-        creator: nextTx.creator
-      };
-      await this.model.pendingTransaction.save(newPending);
-      await this.model.transactionIntention.update(
-        {
-          msafeAddress: input.msafeAddress,
-          sequenceNumber: nextSequenceNumber
-        },
-        {
-          status: "SUCCESS"
-        }
-      );
-    } catch (e) {
-      await this.model.transactionIntention.update(
-        {
-          msafeAddress: input.msafeAddress,
-          sequenceNumber: nextSequenceNumber
-        },
-        {
-          status: "FAILED",
-          statusRemark: e.toString()
-        }
-      );
-      throw new Error(`Intention build failed: {sequenceNumber: ${nextSequenceNumber}}`);
-    }
-  }
-  /**
-   *   Skip next failed transaction if build of the intention has been failed before.
-   */
-  async skipNextFailedIntention(input) {
-    const userMSafe = await this.model.userMSafe.findOneBy({
-      msafeAddress: input.msafeAddress,
-      userAddress: input.userAddress
-    });
-    if (userMSafe === null) {
-      throw new Error("user does not have permission to MSafe");
-    }
-    const curSequenceNumber = await this.model.historyTransaction.findOne({
-      where: { msafeAddress: input.msafeAddress },
-      order: { sequenceNumber: "desc" }
-    });
-    const nextSequenceNumber = curSequenceNumber ? curSequenceNumber.sequenceNumber + 1 : 0;
-    const failedIntention = await this.model.transactionIntention.findOneBy({
-      msafeAddress: input.msafeAddress,
-      sequenceNumber: nextSequenceNumber
-    });
-    if (failedIntention === null) {
-      throw new Error("Next intention not found");
-    }
-    if (failedIntention.status !== "FAILED") {
-      throw new Error("Next intention not failed");
-    }
-    const history = {
-      msafeAddress: input.msafeAddress,
-      digest: "0x0",
-      // Special case for build has been failed,
-      payload: "",
-      sequenceNumber: nextSequenceNumber,
-      creator: failedIntention.creator,
-      isRejectTx: false,
-      status: "build-failed"
-    };
-    await this.model.historyTransaction.save(history);
-    await this.model.transactionIntention.update(
-      { msafeAddress: input.msafeAddress, sequenceNumber: nextSequenceNumber },
-      { processed: true }
-    );
-  }
-  async getUser(address) {
-    return this.model.user.findOneBy({ address });
-  }
-  get model() {
-    return this.db.coreModel;
-  }
-};
-
 // src/globals/const.ts
 var MSafeEnv = /* @__PURE__ */ ((MSafeEnv3) => {
   MSafeEnv3["local"] = "local";
@@ -1576,6 +745,8 @@ var DEV_DATABASE_CONFIG = {
 };
 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 DEV_API_URL = "http://13.56.226.148";
 var ENV_CONFIGS = /* @__PURE__ */ new Map([
   [
     "unit" /* unit */,
@@ -1583,7 +754,8 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: UNIT_DATABASE_CONFIG
+      backend: LOCAL_DATABASE_CONFIG,
+      apiURL: LOCAL_API_URL
     }
   ],
   [
@@ -1592,7 +764,8 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: LOCAL_DATABASE_CONFIG
+      backend: LOCAL_DATABASE_CONFIG,
+      apiURL: LOCAL_API_URL
     }
   ],
   [
@@ -1601,7 +774,8 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: DEV_DATABASE_CONFIG
+      backend: DEV_DATABASE_CONFIG,
+      apiURL: DEV_API_URL
     }
   ]
 ]);
@@ -1620,6 +794,140 @@ function getMSafeConfig(env, options) {
 }
 var AUTH_SIGN_MESSAGE = "Welcome to MSafe";
 
+// 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;
+  }
+  setJWTToken(token) {
+    this._token = token;
+  }
+  async getPublicKey(address) {
+    return (await this.getPublicKeyBatch([address]))[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 res.data?.map(
+      (publicKeyWithSchema) => publicKeyWithSchema ? PublicKeySerde.de({ ...publicKeyWithSchema }) : void 0
+    );
+  }
+  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
+    };
+  }
+  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) {
+    return [];
+  }
+  async getHistoryTransactions(msafeAddress) {
+    return [];
+  }
+  async getFutureIntentions(msafeAddress) {
+    return [];
+  }
+  async getCurrentSequenceNumber(msafeAddress) {
+    return 0;
+  }
+  async getNextSequenceNumber(msafeAddress) {
+    return 0;
+  }
+  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 proposeIntention(input) {
+  }
+  async proposePendingTransaction(input) {
+  }
+  async rejectCurrentTx(input) {
+  }
+  async voteForTransaction(input) {
+  }
+  async buildNextIntentionAndAddToPending(input) {
+  }
+  async skipNextFailedIntention(input) {
+  }
+  async processExecutedTransaction(digest) {
+  }
+  headers() {
+    return { Authorization: `Bearer ${this._token}` };
+  }
+};
+
 // src/globals/MSafeGlobals.ts
 var MSafeGlobals = class _MSafeGlobals {
   backend;
@@ -1634,7 +942,7 @@ var MSafeGlobals = class _MSafeGlobals {
   static async New(env, options) {
     const config = getMSafeConfig(env, options);
     const suiClient = new SuiClient(config.suiClient);
-    const backend = await PseudoBackend.New(config.backend, suiClient);
+    const backend = new BackendImpl(config.apiURL);
     return new _MSafeGlobals({
       backend,
       suiClient,
@@ -1668,11 +976,6 @@ var MSafeClient = class _MSafeClient {
   }
   async connectWallet(input) {
     this.globals.wallet = input.wallet;
-    const isValidJWT = input.jwtToken && await this.backend.isJWTTokenValid(input.jwtToken);
-    if (isValidJWT) {
-      this.backend.setJWTToken(input.jwtToken);
-      return input.jwtToken;
-    }
     const messageStr = MessageHelper.welcomeMessage((/* @__PURE__ */ new Date()).toUTCString());
     const sig = await input.wallet.signPersonalMessage({
       messageStr
@@ -1730,28 +1033,21 @@ export {
   Coin,
   CoinHelper,
   CreateHelper,
+  DEV_API_URL,
   DEV_DATABASE_CONFIG,
   ENV_CONFIGS,
   Formatter,
   HexToUint8Array,
   IntentionHelper,
+  LOCAL_API_URL,
   LOCAL_DATABASE_CONFIG,
   MAINNET_RPC_URL,
-  MAX_OWNER_WITHOUT_NONCE,
-  MAX_OWNER_WITH_NONCE,
-  MAX_WEIGHT,
-  MIN_THRESHOLD,
-  MIN_WEIGHT,
   MSafeAccount,
   MSafeClient,
   MSafeEnv,
   MSafeGlobals,
   MessageHelper,
-  NONCE_PK_PREFIX,
-  NONCE_PK_WEIGHT,
-  NONCE_PREFIX_MAX_SIZE,
   PublicKeySerde,
-  RawMultiSig,
   SUI_COIN,
   SignatureVerifier,
   TESTNET_RPC_URL,
@@ -1759,10 +1055,7 @@ export {
   Uint8ArrayToHex,
   getAllCoins,
   getMSafeConfig,
-  getMultiSigPublicKey,
   getPublicKeyFromChain,
-  makeNoncePublicKey,
-  stringToBuffer,
-  validateMultiSigConfig
+  stringToBuffer
 };
 //# sourceMappingURL=index.js.map