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

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

@@ -1,121 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

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

@@ -1,298 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/tsup.config.ts

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