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

package/test/unit/core/msafe.test.ts

@@ -0,0 +1,298 @@
+import { SuiClient } from '@mysten/sui.js/client';
+
+import { PseudoBackend } from '@/backend/PseudoBackend';
+import { MSafeAccount } from '@/core/MSafeAccount';
+import { MSafeClient } from '@/core/MSafeClient';
+import { MSafeEnv } from '@/globals/const';
+import { MSafeGlobals } from '@/globals/MSafeGlobals';
+import { IntentionCoinTransfer } from '@/transactions/coin-transfer';
+import { IWallet } from '@/types/wallet';
+import { SUI_COIN } from '@/utils/sui';
+
+import { LocalWallet } from '../../lib/account';
+import { TestHelper } from '../../lib/TestHelper';
+
+describe('MSafe integration', () => {
+  let testHelper: TestHelper;
+  let suiClient: SuiClient;
+  const wallets: IWallet[] = [];
+  const clients: MSafeClient[] = [];
+  let backend: PseudoBackend;
+  const userAddresses: string[] = [];
+
+  beforeAll(async () => {
+    const globals = await MSafeGlobals.New(MSafeEnv.unit);
+    suiClient = globals.suiClient;
+    testHelper = new TestHelper(globals);
+    await testHelper.init();
+    for (let i = 0; i !== 3; i++) {
+      const userGlobals = await MSafeGlobals.New(MSafeEnv.unit);
+      const wallet = new LocalWallet(userGlobals.suiClient);
+      const client = new MSafeClient(userGlobals);
+      await client.connectWallet({ wallet });
+      clients.push(client);
+      wallets.push(wallet);
+      userAddresses.push(await wallet.address());
+    }
+    backend = globals.backend as PseudoBackend;
+  });
+
+  afterAll(async () => {
+    (testHelper.globals.backend as PseudoBackend).db.coreModel.close();
+    for (let i = 0; i < clients.length; i++) {
+      await (clients[i].globals.backend as PseudoBackend).db.coreModel.close();
+    }
+  });
+
+  async function createMSafe() {
+    return clients[0].creationHelper.submitMSafeCreation({
+      ownerWithWeight: userAddresses.map((addr) => ({
+        address: addr,
+        weight: 1,
+      })),
+      threshold: wallets.length,
+      name: 'Test MSafe',
+      description: 'Some description',
+      creationNonce: 0,
+    });
+  }
+
+  async function getMSafeAccountForTest() {
+    const userInfo = await clients[0].userInfo();
+    let msafe: MSafeAccount;
+    if (userInfo.ownedMSafe.length > 0) {
+      msafe = clients[0].getMSafeAccount(userInfo.ownedMSafe[0]);
+    } else {
+      const msafeAddress = await createMSafe();
+      msafe = await clients[0].getMSafeAccountFromAddress(msafeAddress);
+    }
+    await faucetAccount(msafe.info.address);
+    return msafe;
+  }
+
+  async function faucetAccount(addr: string) {
+    const bal = await suiClient.getBalance({ owner: addr });
+    if (bal.totalBalance === '0') {
+      await testHelper.faucetWallet(addr, 40000000n);
+    }
+  }
+
+  it('create MSafe', async () => {
+    await createMSafe();
+
+    for (let i = 0; i !== clients.length; i++) {
+      const userInfo = await clients[i].userInfo();
+      expect(userInfo.creationNonce).toBe(i === 0 ? 1 : 0);
+      expect(userInfo.ownedMSafe.length).toBe(1);
+      expect(userInfo.address).toBe(userAddresses[i]);
+      expect(userInfo.ownedMSafe.length).toBe(1);
+      expect(userInfo.ownedMSafe[0].threshold).toBe(userAddresses.length);
+      expect(userInfo.ownedMSafe[0].creationNonce).toBe(0);
+    }
+  });
+
+  it('Propose and execute one transaction', async () => {
+    const msafeAccount = await getMSafeAccountForTest();
+
+    const initBal = await suiClient.getBalance({ owner: userAddresses[0] });
+
+    const intention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: userAddresses[0],
+      amount: '100',
+      coinType: SUI_COIN,
+    };
+    const sn = await msafeAccount.currentSequenceNumber();
+    await msafeAccount.proposeIntention(intention, sn);
+
+    const futureIntentions = await msafeAccount.futureIntentions();
+    expect(futureIntentions.length).toBe(1);
+    expect(futureIntentions[0].sequenceNumber).toBe(0);
+    expect(futureIntentions[0].txType).toBe('CoinTransfer');
+    expect(futureIntentions[0].creator).toBe(userAddresses[0]);
+
+    const pendings0 = await msafeAccount.pendingTransactions();
+    expect(pendings0.length).toBe(0);
+
+    await msafeAccount.buildNextIntentionAndAddToPending();
+    const pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(1);
+
+    for (let i = 0; i < userAddresses.length; i++) {
+      const msafe = clients[i].getMSafeAccount(msafeAccount.info);
+      await msafe.voteForTransaction(pendings[0].digest, pendings[0].payload);
+    }
+
+    const votedPendings = await msafeAccount.pendingTransactions();
+    expect(votedPendings.length).toBe(1);
+    expect(votedPendings[0].votes.length).toBe(userAddresses.length);
+
+    const res = await msafeAccount.executePendingTx(votedPendings[0]);
+    expect(res.effects?.status.status).toBe('success');
+
+    await backend.processExecutedTransaction(pendings[0].digest);
+    const pendingsExecuted = await msafeAccount.pendingTransactions();
+    expect(pendingsExecuted.length).toBe(0);
+
+    const history = await msafeAccount.historyTransaction();
+    const relatedHistory = history.find(
+      (tx) => tx.msafeAddress === msafeAccount.info.address && tx.digest === votedPendings[0].digest,
+    );
+    expect(relatedHistory).toBeDefined();
+    expect(relatedHistory?.status).toBe('success');
+
+    // Check execution result
+    const bal = await suiClient.getBalance({ owner: userAddresses[0] });
+    expect(bal.totalBalance).not.toBe(initBal.totalBalance);
+  });
+
+  it('proposePendingTransaction and reject transaction', async () => {
+    const msafeAccount = await getMSafeAccountForTest();
+
+    const initBal = await suiClient.getBalance({ owner: userAddresses[0] });
+
+    const intention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: userAddresses[0],
+      amount: '200',
+      coinType: SUI_COIN,
+    };
+    await msafeAccount.proposePendingTransaction(intention);
+
+    let pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(1);
+    expect(pendings[0].creator).toBe(userAddresses[0]);
+    expect(pendings[0].votes.length).toBe(1);
+    expect(pendings[0].votes[0].userAddress).toBe(userAddresses[0]);
+
+    // Reject the transaction
+    await msafeAccount.rejectCurrentTx();
+
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(2);
+    const approvePending = pendings.find((pending) => !pending.isRejectTx);
+    const rejectPending = pendings.find((pending) => pending.isRejectTx);
+    expect(approvePending).toBeDefined();
+    expect(approvePending?.intention?.txType).toBe('CoinTransfer');
+    expect(approvePending?.votes.length).toBe(0);
+
+    expect(rejectPending).toBeDefined();
+    expect(rejectPending?.intention).toBeUndefined();
+    expect(rejectPending?.votes.length).toBe(1);
+
+    for (let i = 1; i < clients.length; i++) {
+      const msafe = clients[i].getMSafeAccount(msafeAccount.info);
+      await msafe.voteForTransaction(rejectPending!.digest, rejectPending!.payload!);
+    }
+
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(2);
+    const rejectPending2 = pendings.find((pending) => pending.isRejectTx);
+
+    expect(rejectPending2).toBeDefined();
+    expect(rejectPending2?.intention).toBeUndefined();
+    expect(rejectPending2?.votes.length).toBe(clients.length);
+
+    const res = await msafeAccount.executePendingTx(rejectPending2!);
+    expect(res.effects?.status.status).toBe('success');
+
+    await backend.processExecutedTransaction(rejectPending2!.digest);
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(0);
+
+    const history = await msafeAccount.historyTransaction();
+    const approveHistory = history.find((hs) => hs.digest === approvePending?.digest);
+    expect(approveHistory).toBeDefined();
+    expect(approveHistory?.status).toBe('rejected');
+
+    const rejectHistory = history.find((hs) => hs.digest === rejectPending?.digest);
+    expect(rejectHistory).toBeDefined();
+    expect(rejectHistory?.status).toBe('success');
+
+    const bal = await suiClient.getBalance({ owner: userAddresses[0] });
+    expect(bal.totalBalance).toBe(initBal.totalBalance);
+  });
+
+  it('Propose multiple intentions, and the second intention fails', async () => {
+    const msafeAccount = await getMSafeAccountForTest();
+
+    const intention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: userAddresses[0],
+      amount: '300',
+      coinType: SUI_COIN,
+    };
+    const invalidIntention: IntentionCoinTransfer = {
+      txType: 'CoinTransfer',
+      recipient: userAddresses[0],
+      amount: '18446744073709551614',
+      coinType: SUI_COIN,
+    };
+
+    let pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(0);
+    let futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(0);
+
+    let nextSN = await msafeAccount.nextSequenceNumber();
+    await msafeAccount.proposeIntention(intention, nextSN);
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(0);
+    futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(1);
+
+    // Propose multiple intentions
+    nextSN = await msafeAccount.nextSequenceNumber();
+    await msafeAccount.proposeIntention(invalidIntention, nextSN);
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(0);
+    futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(2);
+
+    // Add the first intention to pendings
+    await msafeAccount.buildNextIntentionAndAddToPending();
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(1);
+
+    for (let i = 0; i < clients.length; i++) {
+      const msafe = clients[i].getMSafeAccount(msafeAccount.info);
+      await msafe.voteForTransaction(pendings[0].digest, pendings[0].payload);
+    }
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(1);
+
+    const res1 = await msafeAccount.executePendingTx(pendings[0]);
+    expect(res1.effects?.status.status).toBe('success');
+
+    // Process the transaction in the backend
+    const tx1Digest = pendings[0].digest;
+    await backend.processExecutedTransaction(pendings[0].digest);
+    pendings = await msafeAccount.pendingTransactions();
+    expect(pendings.length).toBe(0);
+    futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(1);
+    let history = await msafeAccount.historyTransaction();
+    const tx1History = history.find((hs) => hs.digest === tx1Digest);
+    expect(tx1History).toBeDefined();
+    expect(tx1History?.status).toBe('success');
+
+    // Build the next intention will fail. Then user can trigger the skip logic
+    await expect(msafeAccount.buildNextIntentionAndAddToPending()).rejects.toThrow();
+    futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(1);
+    expect(futures[0].status).toBe('failed');
+    expect(futures[0].statusRemark).toBeDefined();
+
+    // Skip the build failed transaction
+    await msafeAccount.skipNextFailedIntention();
+    futures = await msafeAccount.futureIntentions();
+    expect(futures.length).toBe(0);
+    history = await msafeAccount.historyTransaction();
+    const skipped = history.find((hs) => hs.sequenceNumber === nextSN);
+    expect(skipped).toBeDefined();
+    expect(skipped?.status).toBe('build-failed');
+
+    const nextSNAfter = await msafeAccount.nextSequenceNumber();
+    expect(nextSNAfter).toBe(nextSN + 1);
+  });
+});

package/test/unit/utils/buffer.test.ts

@@ -0,0 +1,17 @@
+import { Uint8ArrayToHex, HexToUint8Array } from '@/utils/buffer';
+
+describe('Hex Buffer conversion', () => {
+  it('should convert forth and back', () => {
+    const hex = '0x01020304050607080910aaff';
+    const buf = HexToUint8Array(hex);
+    const got = Uint8ArrayToHex(buf);
+    expect(hex).toEqual(got);
+  });
+
+  it('should convert back and forth', () => {
+    const buf = new Uint8Array([0x12, 0x34, 0x56]);
+    const hexValue = Uint8ArrayToHex(buf);
+    const got = new Uint8Array(HexToUint8Array(hexValue));
+    expect(got).toEqual(buf);
+  });
+});

package/test/unit/utils/crypto.test.ts

@@ -0,0 +1,32 @@
+import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
+
+import { PublicKeySerde, SignatureVerifier } from '@/utils/crypto';
+
+import { LocalWallet } from '../../lib/account';
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+
+describe('verify', () => {
+  it('message', async () => {
+    const wallet = new LocalWallet(TESTNET_SUI_CLIENT);
+    const message = 'User login';
+    const sig = await wallet.signPersonalMessage({
+      messageStr: message,
+    });
+
+    const result = await SignatureVerifier.verifyPersonalSignature({
+      messageStr: message,
+      signature: sig.signature,
+      targetAddress: await wallet.address(),
+    });
+    expect(result).toBeTruthy();
+  });
+});
+
+describe('public key', () => {
+  it('ed25519', () => {
+    const publicKey = new Ed25519Keypair().getPublicKey();
+    const ser = PublicKeySerde.ser(publicKey);
+    const de = PublicKeySerde.de(ser);
+    expect(de.toSuiAddress()).toEqual(publicKey.toSuiAddress());
+  });
+});

package/test/unit/utils/multi-sig.test.ts

@@ -0,0 +1,47 @@
+import { SignatureWithBytes } from '@mysten/sui.js/cryptography';
+
+import { RawMultiSig } from '@/utils/multi-sig';
+
+import { LocalWallet } from '../../lib/account';
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+
+describe('RawMultiSig', () => {
+  it('9/9 wallet', async () => {
+    const wallets = LocalWallet.createBatch(TESTNET_SUI_CLIENT, 9);
+    const ms = await createTestMultiSig(wallets, 9);
+
+    const message = 'Hello world';
+    const signatures = await Promise.all(wallets.map((wallet) => wallet.signPersonalMessage({ messageStr: message })));
+    const combinedSig = ms.combinePartialSignatures(signatures.map((sig) => sig.signature));
+    const result = await ms.verifyPersonalMessage(message, combinedSig);
+    expect(result).toBeTruthy();
+  });
+
+  it('4/9 wallet', async () => {
+    const wallets = LocalWallet.createBatch(TESTNET_SUI_CLIENT, 9);
+    const ms = await createTestMultiSig(wallets, 4);
+
+    const message = 'Hello world';
+    const signatures: SignatureWithBytes[] = await Promise.all(
+      [wallets[1], wallets[3], wallets[5], wallets[7]].map((wallet) =>
+        wallet.signPersonalMessage({ messageStr: message }),
+      ),
+    );
+    const combinedSig = ms.combinePartialSignatures(signatures.map((sig) => sig.signature));
+    const result = await ms.verifyPersonalMessage(message, combinedSig);
+    expect(result).toBeTruthy();
+  });
+});
+
+export async function createTestMultiSig(wallets: LocalWallet[], threshold: number) {
+  const publicKeys = await Promise.all(wallets.map((wallet) => wallet.publicKey()));
+  const msConfig = {
+    threshold,
+    ownerWithWeight: publicKeys.map((pk) => ({
+      publicKey: pk,
+      weight: 1,
+    })),
+    creationNonce: 0,
+  };
+  return new RawMultiSig(msConfig);
+}

package/test/unit/utils/sui.test.ts

@@ -0,0 +1,25 @@
+import { getPublicKeyFromChain } from '@/utils/sui';
+
+import { TESTNET_SUI_CLIENT } from '../../lib/config';
+
+describe('getPublicKeyFromChain', () => {
+  it('single signer', async () => {
+    const address = '0x25404f7631419c291644218c198af7e2599a8dbbeee248c82781db889534141b';
+    const pk = await getPublicKeyFromChain(TESTNET_SUI_CLIENT, address);
+    expect(pk).toBeDefined();
+    expect(pk?.toSuiAddress()).toBe(address);
+  });
+
+  it('not found', async () => {
+    const address = '0x123123123';
+    const pk = await getPublicKeyFromChain(TESTNET_SUI_CLIENT, address);
+    expect(pk).toBeUndefined();
+  });
+
+  it('multi-sig', async () => {
+    const address = '0xeabab6aa83af760fec754acbab0f10cf878651ac8705c295c88171b7a4260e36';
+    await expect(getPublicKeyFromChain(TESTNET_SUI_CLIENT, address)).rejects.toThrow(
+      'multi-sig wallet cannot be owner',
+    );
+  });
+});

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["ES2022", "esnext"],                   /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    "module": "ES2022",                                /* Specify what module code is generated. */
+    "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    "paths": { "@/*": ["./src/*"] },                     /* Specify a set of entries that re-map imports to additional lookup locations. */
+    "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    "allowSyntheticDefaultImports": true,               /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "strictPropertyInitialization": false,               /* Check for class properties that are declared but not set in the constructor. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "ts-node": {
+    "esm": true,
+    "experimentalSpecifierResolution": "node",
+  },
+  "include": [
+    "src/**/*",
+    "test/**/*",
+    "scripts/**/*",
+    "./tsconfig.json",
+    "./jest.config.ts",
+    "./tsup.config.ts"
+  ]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  splitting: false,
+  sourcemap: true,
+  target: 'es2022',
+});