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

package/test/lib/TestHelper.ts

@@ -1,94 +0,0 @@
-import { PseudoBackend } from '@/backend/PseudoBackend';
-import { CreateHelper } from '@/core/CreateHelper';
-import { MessageHelper } from '@/core/MessageHelper';
-import { PublicKeyHelper } from '@/core/PublicKeyHelper';
-import { MSafeGlobals } from '@/globals/MSafeGlobals';
-import { buildCoinTransferTxb } from '@/transactions/coin-transfer';
-import { SUI_COIN } from '@/utils/sui';
-
-import { getWalletWithBalance, LocalWallet } from './account';
-
-export class TestHelper {
-  // Note the connected wallet in globals is written by TestHelper as needed
-  constructor(public readonly globals: MSafeGlobals) {}
-
-  async registerWallet(localWallet: LocalWallet) {
-    const message = MessageHelper.welcomeMessage(new Date().toUTCString());
-    const signature = await localWallet.signPersonalMessage({ messageStr: message });
-    await this.backend.authSign({
-      address: await localWallet.address(),
-      message,
-      signature: signature.signature,
-      walletType: 'LocalWallet',
-    });
-  }
-
-  async init(wallet?: LocalWallet) {
-    await this.backend.db.coreModel.synchronize(true);
-    if (wallet) {
-      this.globals.connectWallet(wallet);
-      await this.registerWallet(wallet);
-    }
-  }
-
-  async close() {
-    this.backend.db.coreModel.close();
-  }
-
-  connectWallet(wallet: LocalWallet) {
-    this.globals.connectWallet(wallet);
-  }
-
-  async createMSafe(owners: LocalWallet[]) {
-    let creationNonce: number | undefined;
-    if (owners.length === 0) {
-      throw new Error('empty owners');
-    }
-    for (let i = 0; i < owners.length; i++) {
-      const owner = owners[i];
-      try {
-        const userInfo = await this.backend.getUserInfo(await owner.address());
-        if (i === 0) {
-          creationNonce = userInfo.creationNonce;
-        }
-      } catch (_) {
-        await this.registerWallet(owner);
-        if (i === 0) {
-          creationNonce = 0;
-        }
-      }
-    }
-    this.globals.connectWallet(owners[0]);
-    const ownerAddresses = await Promise.all(owners.map((owner) => owner.address()));
-
-    const createHelper = new CreateHelper(this.globals, new PublicKeyHelper(this.globals));
-    return createHelper.submitMSafeCreation({
-      ownerWithWeight: owners.map((owner, i) => ({
-        address: ownerAddresses[i],
-        weight: 1,
-      })),
-      threshold: owners.length,
-      name: 'test msafe',
-      creationNonce: creationNonce || 0,
-    });
-  }
-
-  async faucetWallet(recipient: string, amount: bigint) {
-    const fromWallet = await getWalletWithBalance();
-    const txb = await buildCoinTransferTxb({
-      suiClient: this.globals.suiClient,
-      sender: await fromWallet.address(),
-      intention: {
-        txType: 'CoinTransfer',
-        recipient,
-        coinType: SUI_COIN,
-        amount: amount.toString(),
-      },
-    });
-    await fromWallet.signAndExecuteTransactionBlock({ transactionBlock: txb });
-  }
-
-  private get backend() {
-    return this.globals.backend as PseudoBackend;
-  }
-}

package/test/lib/account.ts

@@ -1,87 +0,0 @@
-import {
-  ExecuteTransactionRequestType,
-  SuiClient,
-  SuiTransactionBlockResponse,
-  SuiTransactionBlockResponseOptions,
-} from '@mysten/sui.js/client';
-import { Keypair, PublicKey } from '@mysten/sui.js/cryptography';
-import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
-import { SignatureWithBytes } from '@mysten/sui.js/src/cryptography/keypair';
-import { TransactionBlock } from '@mysten/sui.js/transactions';
-
-import { IWallet } from '@/types/wallet';
-import { stringToBuffer } from '@/utils/buffer';
-
-import { TESTNET_SUI_CLIENT } from './config';
-import { requestFaucetForTestnet } from './faucet';
-
-// The implementation of LocalWallet is referenced from RawSigner
-// By mysten. The interface is not exported thus we need another
-// implementation here.
-export class LocalWallet implements IWallet {
-  private readonly account: Keypair;
-
-  public readonly walletType = 'LocalWallet';
-
-  constructor(
-    public readonly suiClient: SuiClient,
-    privateKey?: string,
-  ) {
-    this.account = privateKey ? Ed25519Keypair.fromSecretKey(Buffer.from(privateKey, 'hex')) : new Ed25519Keypair();
-  }
-
-  async address(): Promise<string> {
-    return this.account.getPublicKey().toSuiAddress();
-  }
-
-  async publicKey(): Promise<PublicKey> {
-    return this.account.getPublicKey();
-  }
-
-  async signTransactionBlock(input: { transactionBlock: TransactionBlock | Uint8Array }): Promise<SignatureWithBytes> {
-    if (input.transactionBlock instanceof Uint8Array) {
-      return this.account.signTransactionBlock(input.transactionBlock);
-    }
-    const tbData = await input.transactionBlock.build({ client: this.suiClient });
-    return this.account.signTransactionBlock(tbData);
-  }
-
-  async signAndExecuteTransactionBlock(input: {
-    transactionBlock: Uint8Array | TransactionBlock;
-    requestType?: ExecuteTransactionRequestType;
-    options?: SuiTransactionBlockResponseOptions;
-  }): Promise<SuiTransactionBlockResponse> {
-    return this.suiClient.signAndExecuteTransactionBlock({
-      ...input,
-      signer: this.account,
-    });
-  }
-
-  async signPersonalMessage(input: { messageStr: string }): Promise<SignatureWithBytes> {
-    const message = stringToBuffer(input.messageStr);
-    return this.account.signPersonalMessage(message);
-  }
-
-  exportPrivateKey(): string {
-    return Buffer.from(this.account.export().privateKey, 'base64').toString('hex');
-  }
-
-  static createBatch(suiClient: SuiClient, numWallets: number) {
-    const wallets: LocalWallet[] = [];
-    for (let i = 0; i !== numWallets; i++) {
-      wallets.push(new LocalWallet(suiClient));
-    }
-    return wallets;
-  }
-}
-
-const FAUCET_WALLET = new LocalWallet(TESTNET_SUI_CLIENT);
-let HAS_FAUCET: boolean = false;
-
-export async function getWalletWithBalance() {
-  if (!HAS_FAUCET) {
-    await requestFaucetForTestnet(await FAUCET_WALLET.address());
-  }
-  HAS_FAUCET = true;
-  return FAUCET_WALLET;
-}

package/test/lib/config.ts

@@ -1,9 +0,0 @@
-import { SuiClient } from '@mysten/sui.js/client';
-
-export const TESTNET_SUI_CLIENT_URL = 'https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
-
-export const TESTNET_SUI_CLIENT = new SuiClient({ url: TESTNET_SUI_CLIENT_URL });
-
-export const MAINNET_SUI_CLIENT_URL = 'https://sui-mainnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
-
-export const MAINNET_SUI_CLIENT = new SuiClient({ url: MAINNET_SUI_CLIENT_URL });

package/test/lib/faucet.ts

@@ -1,49 +0,0 @@
-import { exec } from 'child_process';
-
-import { SuiClient } from '@mysten/sui.js/client';
-import { backOff } from 'exponential-backoff';
-
-import { TESTNET_SUI_CLIENT } from './config';
-
-export async function requestFaucetForTestnet(recipient: string) {
-  await executeFaucet(recipient);
-  await waitForFaucet(TESTNET_SUI_CLIENT, recipient);
-}
-
-async function executeFaucet(recipient: string) {
-  return new Promise((resolve, reject) => {
-    const curlCommand = getFaucetCurlCommand(recipient);
-    exec(curlCommand, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      }
-      const res = JSON.parse(stdout);
-      if (res.error !== null) {
-        reject(new Error(`Unexpected response: ${res}`));
-      }
-      resolve(res);
-    });
-  });
-}
-
-async function waitForFaucet(client: SuiClient, recipient: string) {
-  return backOff(async () => {
-    const coins = await client.getCoins({
-      owner: recipient,
-    });
-    if (coins.data.length === 0) {
-      throw new Error('Address not faucet yet');
-    }
-    return coins;
-  });
-}
-
-function getFaucetCurlCommand(recipient: string) {
-  return `curl --location --request POST 'https://faucet.testnet.sui.io/v1/gas' \
---header 'Content-Type: application/json' \
---data-raw '{
-    "FixedAmountRequest": {
-        "recipient": "${recipient}"
-    }
-}'`;
-}

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

@@ -1,367 +0,0 @@
-// 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);
-  });
-});