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

package/test/unit/backend/backend.test.ts

@@ -0,0 +1,367 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import 'reflect-metadata';
+
+import { CoreModel, PendingTransaction } from '@msafe/sui3-model/core';
+
+import { WALLET_TYPE_KEY } from '@/backend/CoreDatabase';
+import { PseudoBackend } from '@/backend/PseudoBackend';
+import { MessageHelper } from '@/core/MessageHelper';
+import { MSafeEnv } from '@/globals/const';
+import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { IntentionCoinTransfer } from '@/transactions/coin-transfer';
+import { IntentionHelper, TxIntention } from '@/transactions/intention';
+import { HexToUint8Array } from '@/utils/buffer';
+import { SUI_COIN } from '@/utils/sui';
+
+import { LocalWallet } from '../../lib/account';
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+import { TestHelper } from '../../lib/TestHelper';
+
+// TODO: Move these tests cases to backend code.
+describe('PseudoBackend', () => {
+  let backend: PseudoBackend;
+  let globals: MSafeGlobals;
+  let testHelper: TestHelper;
+  const testWallet = new LocalWallet(TESTNET_SUI_CLIENT);
+
+  beforeAll(async () => {
+    globals = await MSafeGlobals.New(MSafeEnv.unit);
+    testHelper = new TestHelper(globals);
+    backend = globals.backend as PseudoBackend;
+    await testHelper.init();
+  });
+
+  afterAll(async () => {
+    await testHelper.close();
+  });
+
+  it('authSign success', async () => {
+    const message = MessageHelper.welcomeMessage(new Date().toUTCString());
+    const sig = await testWallet.signPersonalMessage({
+      messageStr: message,
+    });
+    await backend.authSign({
+      address: await testWallet.address(),
+      message,
+      signature: sig.signature,
+      walletType: 'Unknown',
+    });
+
+    const userSetting = await backend.db.coreModel.userSetting.findOneBy({
+      userAddress: await testWallet.address(),
+      key: WALLET_TYPE_KEY,
+    });
+    expect(userSetting).not.toBeNull();
+    expect(userSetting?.value).toBe('Unknown');
+  });
+
+  it('Invalid welcome message', async () => {
+    const message = 'User Sign';
+    const sig = await testWallet.signPersonalMessage({
+      messageStr: message,
+    });
+    await expect(
+      backend.authSign({
+        address: await testWallet.address(),
+        message: 'User sign',
+        signature: sig.signature,
+        walletType: 'Unknown',
+      }),
+    ).rejects.toThrow('Invalid welcome message');
+  });
+
+  it('user info no wallet', async () => {
+    const user = await backend.getUserInfo(await testWallet.address());
+    expect(user).toBeDefined();
+    expect(user.address).toBe(await testWallet.address());
+  });
+
+  it('public key', async () => {
+    const got = await backend.getPublicKey(await testWallet.address());
+    expect(got!.toSuiAddress()).toEqual(await testWallet.address());
+  });
+
+  it('public key not found', async () => {
+    expect(await backend.getPublicKey('0x1234')).toBeUndefined();
+  });
+
+  it('create MSafe', async () => {
+    const wallets = [new LocalWallet(globals.suiClient), new LocalWallet(globals.suiClient)];
+    const msafeAddr = await testHelper.createMSafe(wallets);
+    const msafe = await backend.db.coreModel.msafe.findOneBy({ address: msafeAddr });
+    expect(msafe !== null).toBeTruthy();
+
+    const userInfo = await backend.getUserInfo(await wallets[0].address());
+    expect(userInfo.ownedMSafe.length).toBe(1);
+    expect(userInfo.creationNonce).toBe(1);
+  });
+});
+
+describe('PseudoBackend transaction related', () => {
+  let globals: MSafeGlobals;
+  let backend: PseudoBackend;
+  let testHelper: TestHelper;
+  let testWallets: LocalWallet[];
+  let msafeAddress: string;
+  let coreModel: CoreModel;
+  let userAddress: string;
+  let userWallet: LocalWallet;
+
+  beforeAll(async () => {
+    globals = await MSafeGlobals.New(MSafeEnv.unit);
+    testHelper = new TestHelper(globals);
+    backend = globals.backend as PseudoBackend;
+
+    testWallets = Array.from({ length: 3 }, () => new LocalWallet(globals.suiClient));
+    await testHelper.init(testWallets[0]);
+    msafeAddress = await testHelper.createMSafe(testWallets);
+
+    await testHelper.faucetWallet(msafeAddress, 100000n);
+
+    coreModel = backend.db.coreModel;
+    userAddress = await testWallets[0].address();
+    [userWallet] = testWallets;
+  });
+
+  afterAll(async () => {
+    await testHelper.close();
+  });
+
+  it('Initialization status check', async () => {
+    const histories = await coreModel.historyTransaction.findBy({ msafeAddress });
+    expect(histories.length).toBe(0);
+
+    const pendings = await coreModel.pendingTransaction.findBy({ msafeAddress });
+    expect(pendings.length).toBe(0);
+
+    const intentions = await coreModel.transactionIntention.findBy({ msafeAddress });
+    expect(intentions.length).toBe(0);
+
+    const votes = await coreModel.userVote.findBy({ msafeAddress });
+    expect(votes.length).toBe(0);
+  });
+
+  it('Propose an intention', async () => {
+    const testIntention: TxIntention = {
+      txType: 'CoinTransfer',
+      recipient: await testWallets[0].address(),
+      amount: '100',
+      coinType: SUI_COIN,
+    };
+    const message = MessageHelper.proposeIntentionMessage({ intention: testIntention, sn: 0 });
+    const signature = await testWallets[0].signPersonalMessage({ messageStr: message });
+    await backend.proposeIntention({
+      intention: testIntention,
+      sequenceNumber: 0,
+      userAddress,
+      msafeAddress,
+      signature: signature.signature,
+    });
+
+    await backend.buildNextIntentionAndAddToPending({ msafeAddress });
+
+    const pendings = await coreModel.pendingTransaction.findBy({ msafeAddress });
+    expect(pendings.length).toBe(1);
+    const intentions = await coreModel.transactionIntention.findBy({ msafeAddress });
+    expect(intentions.length).toBe(1);
+  });
+
+  it('Propose more intention will add to intention not pendings', async () => {
+    const testIntention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: await testWallets[0].address(),
+      amount: '200',
+      coinType: SUI_COIN,
+    };
+    const message2 = MessageHelper.proposeIntentionMessage({ intention: testIntention, sn: 1 });
+    const signature2 = await testWallets[0].signPersonalMessage({ messageStr: message2 });
+    await backend.proposeIntention({
+      intention: testIntention,
+      sequenceNumber: 1,
+      userAddress,
+      msafeAddress,
+      signature: signature2.signature,
+    });
+
+    const intentions = await coreModel.transactionIntention.findBy({ msafeAddress });
+    expect(intentions.length).toBe(2);
+    const pendings = await coreModel.pendingTransaction.findBy({ msafeAddress });
+    expect(pendings.length).toBe(1);
+  });
+
+  it('Vote for transaction', async () => {
+    const pending = await coreModel.pendingTransaction.findOneBy({ msafeAddress });
+    if (pending === null) {
+      throw new Error('Null pending');
+    }
+    const payload = HexToUint8Array(pending.payload);
+    const signature = await testWallets[0].signTransactionBlock({ transactionBlock: payload });
+    await backend.voteForTransaction({
+      msafeAddress,
+      userAddress,
+      txDigest: pending.digest,
+      signature: signature.signature,
+    });
+
+    // Check votes, user shall have 1 valid vote.
+    const userVotes = await coreModel.userVote.findBy({
+      userAddress,
+      msafeAddress,
+      isValid: true,
+    });
+    expect(userVotes.length).toBe(1);
+    expect(userVotes[0].msafeAddress).toBe(msafeAddress);
+  });
+
+  it('rejectCurrentTx', async () => {
+    const pendingsTxs = await backend.getPendingTransactions(msafeAddress);
+    const payloadToReject = pendingsTxs[0].payload;
+    const txb = await IntentionHelper.buildRejectTransaction({ msafeAddress, payloadToReject });
+    const digest = await txb.getDigest({ client: globals.suiClient });
+    const signature = await testWallets[0].signTransactionBlock({ transactionBlock: txb });
+    await backend.rejectCurrentTx({
+      msafeAddress,
+      userAddress,
+      digest,
+      signature: signature.signature,
+    });
+    const pendings = await coreModel.pendingTransaction.findBy({ msafeAddress });
+    expect(pendings.length).toBe(2);
+    expect(pendings.find((pending) => pending.isRejectTx)).toBeDefined();
+    expect(pendings.find((pending) => !pending.isRejectTx)).toBeDefined();
+
+    const rejectTx = pendings.find((pending) => pending.isRejectTx) as PendingTransaction;
+    const rejectVote = await coreModel.userVote.findOneBy({
+      userAddress,
+      msafeAddress,
+      txDigest: rejectTx.digest,
+      isValid: true,
+    });
+    expect(rejectVote === null).toBeFalsy();
+
+    // Approve vote need to be invalid
+    const approveTx = pendings.find((pending) => !pending.isRejectTx) as PendingTransaction;
+    const invalidApprove = await coreModel.userVote.findOneBy({
+      txDigest: approveTx.digest,
+      userAddress,
+      msafeAddress,
+    });
+    expect(invalidApprove === null).toBeFalsy();
+  });
+
+  it('vote overwrite', async () => {
+    const pending = await coreModel.pendingTransaction.findOneBy({
+      msafeAddress,
+      isRejectTx: false,
+    });
+    if (pending === null) {
+      throw new Error('pending tx not exist');
+    }
+    const { signature } = await userWallet.signTransactionBlock({ transactionBlock: HexToUint8Array(pending.payload) });
+    await backend.voteForTransaction({
+      txDigest: pending.digest,
+      msafeAddress,
+      userAddress,
+      signature,
+    });
+
+    const vote = await coreModel.userVote.findOneBy({
+      msafeAddress,
+      txDigest: pending.digest,
+    });
+    expect(vote).not.toBeNull();
+    expect(vote!.isValid).toBeTruthy();
+
+    // Another pending transaction with isRejectTx = true, shall have
+    // user vote with isValid = false.
+    const rejectPending = await coreModel.pendingTransaction.findOneBy({
+      msafeAddress,
+      isRejectTx: true,
+    });
+    if (rejectPending === null) {
+      throw new Error('Test cases must execute in sequence');
+    }
+    const userVote = await coreModel.userVote.findOneBy({
+      msafeAddress,
+      userAddress,
+      txDigest: rejectPending.digest,
+    });
+    expect(userVote).not.toBeNull();
+    expect(userVote!.isValid).toBeFalsy();
+  });
+
+  it('processExecutedTransaction', async () => {
+    const oldPendings = await coreModel.pendingTransaction.findBy({
+      msafeAddress,
+    });
+    expect(oldPendings.length).toBe(2);
+
+    const executedPending = oldPendings.find((pending) => pending.isRejectTx);
+    const rejectedPending = oldPendings.find((pending) => !pending.isRejectTx);
+    expect(executedPending).toBeDefined();
+    expect(rejectedPending).toBeDefined();
+    if (!executedPending || !rejectedPending) {
+      throw new Error('pendings not found');
+    }
+
+    // Process one transaction.
+    await backend.processExecutedTransaction(executedPending.digest);
+    await backend.buildNextIntentionAndAddToPending({ msafeAddress });
+
+    // Transaction has been added to history
+    const histories = await coreModel.historyTransaction.findBy({ msafeAddress });
+    expect(histories.length).toBe(2);
+    expect(
+      histories.find((history) => history.status === 'success' && history.digest === executedPending.digest),
+    ).toBeDefined();
+    expect(
+      histories.find((history) => history.status === 'rejected' && history.digest === rejectedPending.digest),
+    ).toBeDefined();
+
+    // Intentions has been updated
+    const intentions = await coreModel.transactionIntention.findBy({
+      msafeAddress,
+      sequenceNumber: executedPending.sequenceNumber,
+    });
+    expect(intentions.length).toBe(1);
+    expect(intentions[0].status).toBe('processed');
+  });
+
+  it('proposePendingTransaction', async () => {
+    const testIntention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: await testWallets[0].address(),
+      amount: '300',
+      coinType: SUI_COIN,
+    };
+    const pendings = await coreModel.pendingTransaction.findBy({ msafeAddress });
+    expect(pendings.length).toBe(1);
+    await backend.processExecutedTransaction(pendings[0].digest);
+    const txb = await IntentionHelper.buildTxb({
+      suiClient: globals.suiClient,
+      intention: testIntention,
+      sender: msafeAddress,
+    });
+    const digest = await txb.getDigest({ client: globals.suiClient });
+    const signature = await userWallet.signTransactionBlock({ transactionBlock: txb });
+    await backend.proposePendingTransaction({
+      intention: testIntention,
+      userAddress,
+      msafeAddress,
+      digest,
+      signature: signature.signature,
+    });
+
+    const intentions = await coreModel.transactionIntention.findBy({
+      msafeAddress,
+      sequenceNumber: pendings[0].sequenceNumber + 1,
+    });
+    expect(intentions.length).toBe(1);
+
+    const newPendings = await coreModel.pendingTransaction.findBy({
+      msafeAddress,
+    });
+    expect(newPendings.length).toBe(1);
+    expect(newPendings[0].sequenceNumber).toBe(pendings[0].sequenceNumber + 1);
+  });
+});

package/test/unit/core/CreateHelper.test.ts

@@ -0,0 +1,121 @@
+import { PseudoBackend } from '@/backend/PseudoBackend';
+import { CreateHelper } from '@/core/CreateHelper';
+import { PublicKeyHelper } from '@/core/PublicKeyHelper';
+import { MSafeEnv } from '@/globals/const';
+import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { CreateMSafeAccountInfo } from '@/types/creation';
+
+import { LocalWallet } from '../../lib/account';
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+import { TestHelper } from '../../lib/TestHelper';
+
+describe('MSafeCreationHelper', () => {
+  let createHelper: CreateHelper;
+  let testHelper: TestHelper;
+
+  const localWallet = new LocalWallet(TESTNET_SUI_CLIENT);
+  const coManagerAddress = '0x6e78327c80f18968c5227af0dc1a7637822f2f76cb78adbdc0454e8abe66b235';
+
+  beforeAll(async () => {
+    const globals = await MSafeGlobals.New(MSafeEnv.unit);
+    testHelper = new TestHelper(globals);
+    await testHelper.init(localWallet);
+
+    const pkHelper = new PublicKeyHelper(globals);
+    createHelper = new CreateHelper(globals, pkHelper);
+  });
+
+  afterAll(async () => {
+    await testHelper.close();
+  });
+
+  it('validate success', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [
+        { address: await localWallet.address(), weight: 2 },
+        { address: coManagerAddress, weight: 1 },
+      ],
+      threshold: 2,
+      name: 'test wallet',
+      creationNonce: 1,
+    };
+    await createHelper.validateCreateInfo(info);
+  });
+
+  it('unknown public key', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [{ address: '0x123123123', weight: 1 }],
+      threshold: 1,
+      name: 'test wallet',
+      creationNonce: 1,
+    };
+    await expect(createHelper.validateCreateInfo(info)).rejects.toThrow('Unknown public key for address');
+  });
+
+  it('duplicate address', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [
+        { address: await localWallet.address(), weight: 1 },
+        { address: await localWallet.address(), weight: 3 },
+      ],
+      threshold: 1,
+      name: 'test wallet',
+      creationNonce: 1,
+    };
+    await expect(createHelper.validateCreateInfo(info)).rejects.toThrow('Duplicate address detected');
+  });
+
+  it('invalid weight', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [
+        { address: await localWallet.address(), weight: 256 },
+        { address: coManagerAddress, weight: 1 },
+      ],
+      threshold: 2,
+      name: 'test wallet',
+      creationNonce: 1,
+    };
+    await expect(createHelper.validateCreateInfo(info)).rejects.toThrow('Invalid multi-sig weight: 256 (1-255)');
+  });
+
+  it('invalid threshold', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [
+        { address: await localWallet.address(), weight: 2 },
+        { address: coManagerAddress, weight: 1 },
+      ],
+      threshold: 5,
+      name: 'test wallet',
+      creationNonce: 1,
+    };
+    await expect(createHelper.validateCreateInfo(info)).rejects.toThrow('Threshold is larger than total weight');
+  });
+
+  it('submit creation', async () => {
+    const info: CreateMSafeAccountInfo = {
+      ownerWithWeight: [
+        { address: await localWallet.address(), weight: 2 },
+        { address: coManagerAddress, weight: 1 },
+      ],
+      threshold: 2,
+      name: 'test wallet',
+      creationNonce: 0,
+    };
+    await createHelper.submitMSafeCreation(info);
+
+    const msafeAddress = await createHelper.calculateMSafeAddress(info);
+    const db = createHelper.globals.backend as PseudoBackend;
+    const msafeAccountInfo = await db.getMSafeAccountInfo(msafeAddress);
+    expect(msafeAccountInfo).toBeDefined();
+    expect(msafeAccountInfo?.name).toBe(info.name);
+    expect(msafeAccountInfo?.threshold).toBe(info.threshold);
+    expect(msafeAccountInfo?.ownersWithWeightPK.length).toBe(info.ownerWithWeight.length);
+    expect(msafeAccountInfo?.ownersWithWeightPK[0].address).toBe(await localWallet.address());
+    expect(msafeAccountInfo?.ownersWithWeightPK[0].weight).toBe(2);
+    expect(msafeAccountInfo?.ownersWithWeightPK[1].address).toBe(coManagerAddress);
+    expect(msafeAccountInfo?.ownersWithWeightPK[1].weight).toBe(1);
+
+    const res = await db.getUserInfo(await localWallet.address());
+    expect(res.creationNonce).toBe(1);
+  });
+});

package/test/unit/core/MessageHelper.test.ts

@@ -0,0 +1,32 @@
+import { MessageHelper, ProposeIntentionData } from '@/core/MessageHelper';
+
+describe('MessageHelper', () => {
+  it('create message', () => {
+    const addr = '0x123123';
+    const msg = MessageHelper.createMSafeMessage(addr);
+    const got = MessageHelper.deCreateMSafeMessage(msg);
+    expect(addr).toEqual(got);
+  });
+
+  it('welcome message', () => {
+    const timeStr = new Date().toDateString();
+    const msg = MessageHelper.welcomeMessage(timeStr);
+    const got = MessageHelper.deWelcomeMessage(msg);
+    expect(timeStr).toEqual(got);
+  });
+
+  it('proposeIntentMessage', async () => {
+    const proposeData: ProposeIntentionData = {
+      intention: {
+        txType: 'CoinTransfer',
+        recipient: '0x123',
+        coinType: '0x2::sui::Sui',
+        amount: '100',
+      },
+      sn: 100,
+    };
+    const msg = MessageHelper.proposeIntentionMessage(proposeData);
+    const got = MessageHelper.deProposeIntentionMessage(msg);
+    expect(proposeData).toEqual(got);
+  });
+});

package/test/unit/core/PublicKeyHelper.test.ts

@@ -0,0 +1,80 @@
+import { PublicKeyHelper } from '@/core/PublicKeyHelper';
+import { MSafeEnv } from '@/globals/const';
+import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { Formatter } from '@/utils/format';
+
+import { LocalWallet } from '../../lib/account';
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+import { TestHelper } from '../../lib/TestHelper';
+
+describe('PublicKeyHelper', () => {
+  let globals: MSafeGlobals;
+  let pkHelper: PublicKeyHelper;
+  let testHelper: TestHelper;
+
+  const localWallet = new LocalWallet(TESTNET_SUI_CLIENT);
+  const chainAddress = '0x6e78327c80f18968c5227af0dc1a7637822f2f76cb78adbdc0454e8abe66b235';
+
+  beforeAll(async () => {
+    globals = await MSafeGlobals.New(MSafeEnv.unit);
+    testHelper = new TestHelper(globals);
+    await testHelper.init(localWallet);
+  });
+
+  afterAll(async () => {
+    await testHelper.close();
+  });
+
+  beforeEach(() => {
+    pkHelper = new PublicKeyHelper(globals);
+  });
+
+  it('getPublicKey from blockchain', async () => {
+    const publicKey = await pkHelper.getPublicKey(chainAddress);
+    expect(publicKey).toBeDefined();
+    expect(Formatter.isSuiAddressEqual(publicKey!.toSuiAddress(), chainAddress)).toBeTruthy();
+  });
+
+  it('getPublicKey with wallet', async () => {
+    const publicKey = await pkHelper.getPublicKey(await localWallet.address());
+    expect(publicKey).toBeDefined();
+    expect(Formatter.isSuiAddressEqual(publicKey!.toSuiAddress(), await localWallet.address())).toBeTruthy();
+  });
+
+  it('getPublicKeyBatch', async () => {
+    const pks = await pkHelper.getPublicKeyBatch([await localWallet.address(), chainAddress]);
+    expect(pks.length).toBe(2);
+    for (let i = 0; i < pks.length; i++) {
+      expect(pks[i]).toBeDefined();
+      expect(Formatter.isSuiAddressEqual(pks[i]!.toSuiAddress(), await localWallet.address()));
+    }
+    expect((pkHelper as any).knownPublicKeys.size).toBe(2);
+
+    const pks2 = await pkHelper.getPublicKeyBatch([await localWallet.address(), chainAddress]);
+    expect(pks2.length).toBe(2);
+  });
+
+  it('getPublicKeyBatch with uncached backend values', async () => {
+    await pkHelper.getPublicKey(chainAddress);
+    expect((pkHelper as any).knownPublicKeys.size).toBe(1);
+
+    const pks = await pkHelper.getPublicKeyBatch([await localWallet.address(), chainAddress]);
+    expect(pks.length).toBe(2);
+    expect((pkHelper as any).knownPublicKeys.size).toBe(2);
+
+    expect(Formatter.isSuiAddressEqual(pks[0]?.toSuiAddress() as string, await localWallet.address())).toBeTruthy();
+    expect(Formatter.isSuiAddressEqual(pks[1]?.toSuiAddress() as string, chainAddress)).toBeTruthy();
+  });
+
+  it('getPublicKeyBatch with uncached chain values', async () => {
+    await pkHelper.getPublicKey(await localWallet.address());
+    expect((pkHelper as any).knownPublicKeys.size).toBe(1);
+
+    const pks = await pkHelper.getPublicKeyBatch([chainAddress, await localWallet.address()]);
+    expect(pks.length).toBe(2);
+    expect((pkHelper as any).knownPublicKeys.size).toBe(2);
+
+    expect(Formatter.isSuiAddressEqual(pks[0]?.toSuiAddress() as string, chainAddress)).toBeTruthy();
+    expect(Formatter.isSuiAddressEqual(pks[1]?.toSuiAddress() as string, await localWallet.address())).toBeTruthy();
+  });
+});