@msafe/sui3-sdk 0.0.13 → 0.0.14

package/src/backend/PseudoBackend.ts

@@ -1,936 +0,0 @@
-import 'reflect-metadata';
-import {
-  User,
-  UserMSafe,
-  HistoryTransaction,
-  MSafe,
-  TransactionIntention,
-  UserVote,
-  PendingTransaction,
-} from '@msafe/sui3-model/core';
-import {
-  CreateMSafeAccountInfoRequest,
-  deserializePublicKey,
-  MSafeAccountInfo,
-  MultisigAccountManager,
-  OwnerWithWeightPK,
-  UserWithOwnedMSafe,
-  HistoryTransaction as HistoryTx,
-} from '@msafe/sui3-utils';
-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 { MessageHelper } from '@/core/MessageHelper';
-import { DBConfig } from '@/globals/const';
-import { IntentionHelper, TxIntention } from '@/transactions/intention';
-import {
-  GetAddressBookResult,
-  UpdateAddressBookEntry,
-  JWTToken,
-  PaginationOption,
-  PaginationResponse,
-  PagedResult,
-} from '@/types';
-import { FutureIntention, PendingTx } from '@/types/msafe';
-import { Uint8ArrayToHex, HexToUint8Array } from '@/utils/buffer';
-import { PublicKeySerde, SignatureVerifier } from '@/utils/crypto';
-import { Formatter } from '@/utils/format';
-
-/**
- * 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);
-  }
-
-  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;
-  }
-
-  async verifyToken(jwt?: JWTToken): Promise<boolean> {
-    return true;
-  }
-
-  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: CreateMSafeAccountInfoRequest) {
-    const ownersWithWeightPK: OwnerWithWeightPK[] = input.ownersWithWeightPKEncoded.map((owner) => ({
-      address: owner.address,
-      weight: owner.weight,
-      publicKey: deserializePublicKey(owner.publicKeyEncoded, owner.schema),
-    }));
-    const multisigManager = new MultisigAccountManager({
-      threshold: input.threshold,
-      creationNonce: input.creationNonce,
-      ownersWithWeight: ownersWithWeightPK,
-    });
-    const msafeAddr = multisigManager.address;
-
-    const signingMsg = MessageHelper.createMSafeMessage(msafeAddr);
-    const targetAddr = input.ownersWithWeightPKEncoded[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.ownersWithWeightPKEncoded[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.ownersWithWeightPKEncoded.forEach((ownerInfo) => {
-      if (
-        !Formatter.isSuiAddressEqual(
-          ownerInfo.address,
-          PublicKeySerde.de({ publicKey: ownerInfo.publicKeyEncoded, scheme: ownerInfo.schema }).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.ownersWithWeightPKEncoded.length; i++) {
-      const ownerInfo = input.ownersWithWeightPKEncoded[i];
-      // Creator has been verified and already exist in database
-      if (i !== 0) {
-        const coManager = await this.getUser(ownerInfo.address);
-        // Add user with public key if not exist
-        if (coManager === null) {
-          const user: User = {
-            address: ownerInfo.address,
-            publicKey: ownerInfo.publicKeyEncoded,
-            schema: ownerInfo.schema,
-            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,
-    paginationOption?: PaginationOption,
-  ): Promise<PagedResult<HistoryTx>> {
-    // 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 {
-      items: 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,
-        })),
-      })),
-      meta: {
-        totalItems: 0,
-        itemCount: 0,
-        itemsPerPage: 0,
-        totalPages: 0,
-        currentPage: 0,
-      },
-    };
-  }
-
-  async getFutureIntentions(
-    msafeAddress: string,
-    paginationOption?: PaginationOption,
-  ): Promise<PagedResult<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 {
-      items: 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 as Date,
-      })),
-      meta: {
-        totalItems: 0,
-        itemCount: 0,
-        itemsPerPage: 0,
-        totalPages: 0,
-        currentPage: 0,
-      },
-    };
-  }
-
-  async proposeIntention(input: {
-    intention: TxIntention;
-    sequenceNumber: number;
-    userAddress: string;
-    msafeAddress: string;
-    signature: SerializedSignature;
-    application: string;
-    txType: string;
-    txSubType: string;
-  }) {
-    // 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,
-      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: {
-    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,
-      processed: false,
-      ...IntentionHelper.getTxType(input.intention),
-      data: IntentionHelper.ser(input.intention),
-      status: 'SUCCESS',
-      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
-      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 },
-      { processed: true },
-    );
-    // 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);
-      await this.model.transactionIntention.update(
-        {
-          msafeAddress: input.msafeAddress,
-          sequenceNumber: nextSequenceNumber,
-        },
-        {
-          status: 'SUCCESS',
-        },
-      );
-    } 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);
-
-    await this.model.transactionIntention.update(
-      { msafeAddress: input.msafeAddress, sequenceNumber: nextSequenceNumber },
-      { processed: true },
-    );
-  }
-
-  async getAddressBookEntries(pagination?: PaginationOption): Promise<GetAddressBookResult> {
-    return {
-      data: [],
-      meta: {
-        total: 0,
-        page: 0,
-        limit: 0,
-        hasNext: false,
-      },
-    };
-  }
-
-  async updateAddressBook(input: {
-    updates: UpdateAddressBookEntry[];
-    signature: SerializedSignature;
-  }): Promise<void> {}
-
-  private async getUser(address: string): Promise<User | null> {
-    return this.model.user.findOneBy({ address });
-  }
-
-  private get model() {
-    return this.db.coreModel;
-  }
-}