@msafe/sui3-sdk 0.0.4-pre-113020e.0 → 0.0.4

package/dist/index.js

@@ -1,29 +1,5 @@
-// 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/transactions/coin-transfer.ts
+import { TransactionBlock } from "@mysten/sui.js/transactions";
 
 // src/utils/format.ts
 import { normalizeSuiAddress, normalizeStructTag as normalizeStructTag2 } from "@mysten/sui.js/utils";
@@ -99,6 +75,30 @@ 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,78 +158,7 @@ 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;
@@ -497,19 +426,165 @@ 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.multisigManager = new MultisigAccountManager2({
-      threshold: info.threshold,
-      ownersWithWeight: info.ownersWithWeightPK,
-      creationNonce: info.creationNonce
-    });
+    this.rawMultiSig = RawMultiSig.fromMSafeAccountInfo(info);
   }
-  multisigManager;
+  rawMultiSig;
   static async new(globals, address) {
     const info = await globals.backend.getMSafeAccountInfo(address);
     return new _MSafeAccount(globals, info);
@@ -618,7 +693,7 @@ var MSafeAccount = class _MSafeAccount {
         sigs.push(signature);
       }
     }
-    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
+    const multiSignature = this.rawMultiSig.combinePartialSignatures(sigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(pending.payload),
       signature: multiSignature,
@@ -711,6 +786,762 @@ 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";
@@ -745,8 +1576,6 @@ 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 */,
@@ -754,8 +1583,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL
+      backend: UNIT_DATABASE_CONFIG
     }
   ],
   [
@@ -764,8 +1592,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL
+      backend: LOCAL_DATABASE_CONFIG
     }
   ],
   [
@@ -774,8 +1601,7 @@ var ENV_CONFIGS = /* @__PURE__ */ new Map([
       suiClient: {
         url: TESTNET_RPC_URL
       },
-      backend: DEV_DATABASE_CONFIG,
-      apiURL: DEV_API_URL
+      backend: DEV_DATABASE_CONFIG
     }
   ]
 ]);
@@ -794,140 +1620,6 @@ 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;
@@ -942,7 +1634,7 @@ var MSafeGlobals = class _MSafeGlobals {
   static async New(env, options) {
     const config = getMSafeConfig(env, options);
     const suiClient = new SuiClient(config.suiClient);
-    const backend = new BackendImpl(config.apiURL);
+    const backend = await PseudoBackend.New(config.backend, suiClient);
     return new _MSafeGlobals({
       backend,
       suiClient,
@@ -976,6 +1668,11 @@ 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
@@ -1033,21 +1730,28 @@ 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,
@@ -1055,7 +1759,10 @@ export {
   Uint8ArrayToHex,
   getAllCoins,
   getMSafeConfig,
+  getMultiSigPublicKey,
   getPublicKeyFromChain,
-  stringToBuffer
+  makeNoncePublicKey,
+  stringToBuffer,
+  validateMultiSigConfig
 };
 //# sourceMappingURL=index.js.map