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

package/src/backend/PseudoBackend.ts

@@ -0,0 +1,851 @@
+import 'reflect-metadata';
+import {
+  User,
+  UserMSafe,
+  HistoryTransaction,
+  MSafe,
+  TransactionIntention,
+  UserVote,
+  PendingTransaction,
+} from '@msafe/sui3-model/core';
+import { SuiClient } from '@mysten/sui.js/client';
+import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
+import { SignatureScheme } from '@mysten/sui.js/src/cryptography/signature-scheme';
+import { MoreThanOrEqual } from 'typeorm';
+
+import { CoreDB } from '@/backend/CoreDatabase';
+import { IBackend } from '@/backend/interface';
+import { CreateMSafeParams, JWTToken, UserWithOwnedMSafe } from '@/backend/types';
+import { MessageHelper } from '@/core/MessageHelper';
+import { DBConfig } from '@/globals/const';
+import { IntentionHelper, TxIntention } from '@/transactions/intention';
+import { FutureIntention, HistorySendTx, MSafeAccountInfo, PendingTx } from '@/types/msafe';
+import { Uint8ArrayToHex, HexToUint8Array } from '@/utils/buffer';
+import { PublicKeySerde, SignatureVerifier } from '@/utils/crypto';
+import { Formatter } from '@/utils/format';
+import { RawMultiSig } from '@/utils/multi-sig';
+
+/**
+ * Represents a PseudoBackend class that implements the IBackend interface.
+ * This class is responsible for interacting with a database and performing various operations.
+ * Notice: For backend production code, all DB errors need to be handled correctly
+ * TODO: Use QueryRunner to make all db operations atomic.
+ * TODO: Permission validation for each request.
+ * TODO: More input validation and normalization.
+ */
+export class PseudoBackend implements IBackend {
+  private _token: JWTToken;
+
+  private constructor(
+    public readonly db: CoreDB,
+    private readonly _suiClient: SuiClient,
+  ) {}
+
+  static async New(dbConfig: DBConfig, suiClient: 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: JWTToken): Promise<boolean> {
+    return true;
+  }
+
+  async authSign(input: {
+    address: string;
+    message: string;
+    signature: SerializedSignature;
+    walletType: string;
+  }): Promise<JWTToken> {
+    const timestamp = MessageHelper.deWelcomeMessage(input.message);
+    if (!timestamp) {
+      throw new Error('Invalid welcome message');
+    }
+    // Check if the signing message has expired
+    const date = Date.parse(timestamp);
+    if (new Date().getTime() - date < 0) {
+      throw new Error('Invalid timestamp');
+    }
+    if (new Date().getTime() - date > 10 * 1000) {
+      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');
+    }
+    // Add user data to database
+    await this.db.upsertUser({
+      address: input.address,
+      publicKey,
+      lastLogin: new Date(),
+    });
+
+    // Add wallet type
+    await this.db.updateUserWalletType({
+      address: input.address,
+      walletType: input.walletType,
+    });
+
+    this._token = '';
+    return this._token;
+  }
+
+  setJWTToken(token: JWTToken) {
+    this._token = token;
+  }
+
+  async getPublicKey(address: string) {
+    const user = await this.model.user.findOneBy({
+      address,
+    });
+    if (user === null) {
+      return undefined;
+    }
+    return PublicKeySerde.de({
+      publicKey: user.publicKey,
+      scheme: user.schema as SignatureScheme,
+    });
+  }
+
+  async getPublicKeyBatch(addresses: string[]): Promise<(PublicKey | undefined)[]> {
+    const res: (PublicKey | undefined)[] = [];
+    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 as SignatureScheme,
+            })
+          : undefined,
+      );
+    }
+    return res;
+  }
+
+  async createMSafeAccount(input: CreateMSafeParams) {
+    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');
+    }
+    // TODO: In production, we will also need to verify whether the
+    //   JWT token align with the creator (targetAddr)
+    // Check and verify the creation message.
+    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 each manager, add user info if not exist. Add userMSafe entry.
+    for (let i = 0; i !== input.ownerWithWeight.length; i++) {
+      const ownerInfo = input.ownerWithWeight[i];
+      // Creator has been verified and already exist in database
+      if (i !== 0) {
+        const coManager = await this.getUser(ownerInfo.address);
+        const serPK = PublicKeySerde.ser(ownerInfo.publicKey);
+        // Add user with public key if not exist
+        if (coManager === null) {
+          const user: User = {
+            address: ownerInfo.address,
+            publicKey: serPK.publicKey,
+            schema: serPK.scheme,
+            nonce: 0,
+            lastLogin: new Date(),
+          };
+          await this.model.user.save(user);
+        }
+      }
+
+      // Add userMSafe record
+      const userMSafe: UserMSafe = {
+        userAddress: ownerInfo.address,
+        msafeAddress: msafeAddr,
+        index: i,
+        weight: ownerInfo.weight,
+        status: i === 0 ? 'active' : 'pending',
+      };
+      await this.model.userMSafe.save(userMSafe);
+    }
+
+    // Increment the creator nonce
+    const creationNonce = creator.nonce;
+    creator.nonce++;
+    await this.model.user.save(creator);
+
+    // Add MSafe record
+    const msafe: MSafe = {
+      address: msafeAddr,
+      creationNonce,
+      creator: creatorAddress,
+      name: input.name,
+      description: input.description,
+      threshold: input.threshold,
+    };
+    await this.model.msafe.save(msafe);
+  }
+
+  async getMSafeAccountInfo(msafeAddress: string): Promise<MSafeAccountInfo> {
+    // TODO: In production, we need verify whether the msafe
+    //  account belongs to the single signer from JWT token.
+
+    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 as SignatureScheme }),
+    }));
+    return {
+      address: msafeAddress,
+      ownersWithWeightPK,
+      threshold: msafe.threshold,
+      name: msafe.name,
+      description: msafe.description,
+      creationNonce: msafe.creationNonce,
+    };
+  }
+
+  async getUserInfo(userAddress: string): Promise<UserWithOwnedMSafe> {
+    // TODO: Do permission check on user JWT token.
+    const user = await this.getUser(userAddress);
+    if (user === null) {
+      throw new Error('404: user not found');
+    }
+    // TODO: Add invitation status as well.
+    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: string): Promise<PendingTx[]> {
+    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 as Date,
+      votes: votes[i].map((vote) => ({
+        userAddress: vote.userAddress,
+        signature: vote.signature,
+        timestamp: vote.updatedAt as Date,
+      })),
+      sequenceNumber: pending.sequenceNumber,
+      intention: pending.isRejectTx ? undefined : intent,
+    }));
+  }
+
+  async getCurrentSequenceNumber(msafeAddress: string): Promise<number> {
+    // TODO: validate user permission
+    const maxSNHistory = await this.model.historyTransaction.findOne({
+      where: { msafeAddress },
+      order: { sequenceNumber: 'desc' },
+    });
+    return maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
+  }
+
+  async getNextSequenceNumber(msafeAddress: string): Promise<number> {
+    // TODO: validate user permission
+    const maxSNIntention = await this.model.transactionIntention.findOne({
+      where: { msafeAddress },
+      order: { sequenceNumber: 'desc' },
+    });
+    return maxSNIntention === null ? 0 : maxSNIntention.sequenceNumber + 1;
+  }
+
+  async getHistoryTransactions(msafeAddress: string): Promise<HistorySendTx[]> {
+    // TODO: Add pagination options. Filter by sequence number based
+    //  on pagination options.
+    //  Notice there can be multiple transactions with the same sequence
+    //  number.
+    // TODO: Add permission validation
+    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 as Date,
+      sequenceNumber: tx.sequenceNumber,
+      votes: votes[i].map((vote) => ({
+        userAddress: vote.userAddress,
+        timestamp: vote.updatedAt as Date,
+      })),
+    }));
+  }
+
+  async getFutureIntentions(msafeAddress: string): Promise<FutureIntention[]> {
+    // TODO: Add pagination options, add user permission validation
+    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,
+      status: tx.status,
+      statusRemark: tx.statusRemark,
+      creator: tx.creator,
+      createdAt: tx.createdAt as Date,
+    }));
+  }
+
+  async proposeIntention(input: {
+    intention: TxIntention;
+    sequenceNumber: number;
+    userAddress: string;
+    msafeAddress: string;
+    signature: SerializedSignature;
+  }) {
+    // Validation:
+    // 1. Whether the current wallet have permission
+    // 2. Verify signature
+    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: TransactionIntention = {
+      msafeAddress: input.msafeAddress,
+      sequenceNumber,
+      ...IntentionHelper.getTxType(input.intention),
+      data: IntentionHelper.ser(input.intention),
+      status: 'future',
+      creator: input.userAddress,
+    };
+    await this.model.transactionIntention.save(intention);
+  }
+
+  // Propose a pending transaction. Require the msafe account
+  // Does not have any pending transactions.
+  async proposePendingTransaction(input: {
+    intention: TxIntention;
+    userAddress: string;
+    msafeAddress: string;
+    digest: string;
+    signature: SerializedSignature;
+  }) {
+    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');
+    }
+
+    // Write intention
+    const maxSNHistory = await this.model.historyTransaction.findOne({
+      where: { msafeAddress: input.msafeAddress },
+      order: { sequenceNumber: 'desc' },
+    });
+    const sequenceNumber = maxSNHistory === null ? 0 : maxSNHistory.sequenceNumber + 1;
+    const intention: TransactionIntention = {
+      msafeAddress: input.msafeAddress,
+      sequenceNumber,
+      ...IntentionHelper.getTxType(input.intention),
+      data: IntentionHelper.ser(input.intention),
+      status: 'future',
+      creator: input.userAddress,
+    };
+    await this.model.transactionIntention.save(intention);
+
+    // Write pending transaction
+    const pendingTx: PendingTransaction = {
+      digest: txDigest,
+      msafeAddress: input.msafeAddress,
+      payload: Uint8ArrayToHex(payload),
+      sequenceNumber,
+      isRejectTx: false,
+      creator: input.userAddress,
+    };
+    await this.model.pendingTransaction.save(pendingTx);
+
+    // Write user vote
+    const userVote: 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: {
+    userAddress: string;
+    msafeAddress: string;
+    digest: string;
+    signature: SerializedSignature;
+  }) {
+    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: PendingTransaction = {
+      msafeAddress: input.msafeAddress,
+      digest: rejectDigest,
+      payload: rejectPayloadStr,
+      sequenceNumber: currentPending.sequenceNumber,
+      isRejectTx: true,
+      creator: input.userAddress,
+    };
+    await this.model.pendingTransaction.save(rejectPending);
+
+    // Vote for the transaction
+    const rejectVote: UserVote = {
+      userAddress: input.userAddress,
+      msafeAddress: input.msafeAddress,
+      txDigest: rejectDigest,
+      signature: input.signature,
+      isValid: true,
+    };
+    await this.model.userVote.save(rejectVote);
+
+    // If user has previously voted in the other way, revoke the vote
+    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: {
+    txDigest: string;
+    msafeAddress: string;
+    userAddress: string;
+    signature: SerializedSignature;
+  }) {
+    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');
+    }
+
+    // Ensure user owns the msafe address
+    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})`);
+    }
+
+    // Verify the signature
+    const payload = HexToUint8Array(pendingTx.payload);
+    const verified = await SignatureVerifier.verifyTransactionSignature({
+      payload,
+      targetAddress: input.userAddress,
+      signature: input.signature,
+    });
+    if (!verified) {
+      throw new Error('Invalid signature');
+    }
+
+    // If user has other vote on the reject transaction, Add the user vote.
+    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: 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: string) {
+    // TODO: Process the transaction result from blockchain.
+    const historyTx = await this.model.historyTransaction.findOneBy({ digest });
+    if (historyTx) {
+      // Already processed, directly return
+      const allHistories = await this.model.historyTransaction.findBy({
+        msafeAddress: (historyTx as HistoryTransaction).msafeAddress,
+      });
+      console.log(allHistories);
+      return;
+    }
+    const pendingTx = await this.model.pendingTransaction.findOneBy({ digest });
+    if (!pendingTx) {
+      throw new Error('Transaction digest not found');
+    }
+    // Mark the intention as processed.
+    await this.model.transactionIntention.update(
+      { msafeAddress: pendingTx.msafeAddress, sequenceNumber: pendingTx.sequenceNumber },
+      { status: 'processed' },
+    );
+    // Delete the current pending transaction.
+    // There can be multiple transactions. mark one as executed, other as rejected
+    const pendings = await this.model.pendingTransaction.findBy({
+      msafeAddress: pendingTx.msafeAddress,
+      sequenceNumber: pendingTx.sequenceNumber,
+    });
+    if (pendings.length === 0) {
+      throw new Error('Pending transaction not found');
+    }
+    // Add to transaction history and delete the pending transaction.
+    const executionResult: 'success' | 'failed' = 'success';
+    for (let i = 0; i !== pendings.length; i++) {
+      const pending = pendings[i];
+      const history: HistoryTransaction = {
+        digest: pending.digest,
+        payload: pending.payload,
+        msafeAddress: pending.msafeAddress,
+        sequenceNumber: pending.sequenceNumber,
+        isRejectTx: pending.isRejectTx,
+        creator: pending.creator,
+        createdAt: pending.createdAt as Date,
+        // 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: { msafeAddress: string }) {
+    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: PendingTransaction = {
+        digest: newDigest,
+        payload: Uint8ArrayToHex(payload),
+        msafeAddress: input.msafeAddress,
+        sequenceNumber: nextTx.sequenceNumber,
+        isRejectTx: false,
+        creator: nextTx.creator,
+      };
+      await this.model.pendingTransaction.save(newPending);
+    } catch (e: unknown) {
+      // Build failed. Mark the intention as failed.
+      await this.model.transactionIntention.update(
+        {
+          msafeAddress: input.msafeAddress,
+          sequenceNumber: nextSequenceNumber,
+        },
+        {
+          status: 'failed',
+          statusRemark: (e as any).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: { msafeAddress: string; userAddress: string }) {
+    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: HistoryTransaction = {
+      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);
+  }
+
+  private async getUser(address: string): Promise<User | null> {
+    return this.model.user.findOneBy({ address });
+  }
+
+  private get model() {
+    return this.db.coreModel;
+  }
+}