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

package/src/utils/multi-sig.ts

@@ -0,0 +1,113 @@
+import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
+import { Ed25519PublicKey } from '@mysten/sui.js/keypairs/ed25519';
+import { MultiSigPublicKey } from '@mysten/sui.js/multisig';
+
+import { MSafeAccountInfo } from '@/types/msafe';
+import { stringToBuffer } from '@/utils/buffer';
+
+export interface PublicKeyWithWeight {
+  publicKey: PublicKey;
+  weight: number;
+}
+
+export interface MultiSigConfig {
+  threshold: number;
+  ownerWithWeight: PublicKeyWithWeight[];
+  creationNonce: number | undefined;
+}
+
+export const NONCE_PK_PREFIX = 'maven';
+export const NONCE_PREFIX_MAX_SIZE = 16;
+export const NONCE_PK_WEIGHT = 1;
+
+export const MAX_WEIGHT = 255;
+export const MIN_WEIGHT = 1;
+export const MAX_OWNER_WITH_NONCE = 9;
+export const MAX_OWNER_WITHOUT_NONCE = 10;
+export const MIN_THRESHOLD = 1;
+
+export class RawMultiSig {
+  rawMsPK: MultiSigPublicKey;
+
+  constructor(public readonly config: MultiSigConfig) {
+    this.rawMsPK = getMultiSigPublicKey(config);
+  }
+
+  static fromMSafeAccountInfo(info: MSafeAccountInfo) {
+    const parsed: MultiSigConfig = {
+      threshold: info.threshold,
+      ownerWithWeight: info.ownersWithWeightPK,
+      creationNonce: info.creationNonce,
+    };
+    return new RawMultiSig(parsed);
+  }
+
+  get suiAddress(): string {
+    return this.rawMsPK.toSuiAddress();
+  }
+
+  get publicKeys(): PublicKeyWithWeight[] {
+    return this.rawMsPK.getPublicKeys();
+  }
+
+  get threshold(): number {
+    return this.config.threshold;
+  }
+
+  combinePartialSignatures(signatures: SerializedSignature[]): SerializedSignature {
+    return this.rawMsPK.combinePartialSignatures(signatures);
+  }
+
+  async verifyPersonalMessage(messageStr: string, multiSigSignature: SerializedSignature): Promise<boolean> {
+    const message = stringToBuffer(messageStr);
+    return this.rawMsPK.verifyPersonalMessage(message, multiSigSignature);
+  }
+}
+
+export function getMultiSigPublicKey(config: MultiSigConfig) {
+  const { ownerWithWeight, threshold, creationNonce } = config;
+  const pks = ownerWithWeight.map((pk) => ({
+    publicKey: pk.publicKey,
+    weight: pk.weight,
+  }));
+  if (creationNonce !== undefined) {
+    pks.push({
+      publicKey: makeNoncePublicKey(creationNonce),
+      weight: NONCE_PK_WEIGHT,
+    });
+  }
+  return MultiSigPublicKey.fromPublicKeys({ threshold, publicKeys: pks });
+}
+
+export function makeNoncePublicKey(nonce: number) {
+  const buffer = new ArrayBuffer(Ed25519PublicKey.SIZE);
+  const textEncoder = new TextEncoder();
+  textEncoder.encodeInto(NONCE_PK_PREFIX, new Uint8Array(buffer, 0, NONCE_PREFIX_MAX_SIZE));
+  const nonceView = new DataView(buffer, NONCE_PREFIX_MAX_SIZE, 4);
+  nonceView.setUint32(0, nonce, true);
+  return new Ed25519PublicKey(new Uint8Array(buffer));
+}
+
+export function validateMultiSigConfig(config: MultiSigConfig) {
+  config.ownerWithWeight.forEach((pk) => {
+    const { weight } = pk;
+    if (weight < MIN_WEIGHT || weight > MAX_WEIGHT) {
+      throw new Error(`Invalid multi-sig weight: ${weight} (1-${MAX_WEIGHT})`);
+    }
+  });
+  const totalWeight = config.ownerWithWeight.reduce((s, pk) => s + pk.weight, 0);
+  if (config.threshold > totalWeight) {
+    throw new Error('Threshold is larger than total weight');
+  }
+  if (config.threshold < MIN_THRESHOLD) {
+    throw new Error('Threshold is smaller than 1');
+  }
+  const maxOwner = config.creationNonce === undefined ? MAX_OWNER_WITHOUT_NONCE : MAX_OWNER_WITH_NONCE;
+  if (config.ownerWithWeight.length > maxOwner) {
+    throw new Error('Owner number bigger than upper cap');
+  }
+  const addressSet = new Set(config.ownerWithWeight.map((pk) => pk.publicKey.toSuiAddress()));
+  if (addressSet.size !== config.ownerWithWeight.length) {
+    throw new Error('Duplicate address detected');
+  }
+}

package/src/utils/sui.ts

@@ -0,0 +1,90 @@
+import { SuiClient, PaginatedTransactionResponse, PaginatedCoins, CoinStruct } from '@mysten/sui.js/client';
+import { parseSerializedSignature, PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
+import { MultiSigPublicKey } from '@mysten/sui.js/multisig';
+
+import { PublicKeySerde } from '@/utils/crypto';
+import { Formatter } from '@/utils/format';
+
+export const SUI_COIN = '0x2::sui::SUI';
+
+export async function getPublicKeyFromChain(suiClient: SuiClient, address: string): Promise<PublicKey | undefined> {
+  let txs: PaginatedTransactionResponse;
+  try {
+    txs = await suiClient.queryTransactionBlocks({
+      // Disable naming rule since the variable is defined by Mysten
+      filter: { FromAddress: address },
+      options: { showInput: true },
+      limit: 2,
+    });
+  } catch (e) {
+    // Currently when there is no history transaction, will report an error:
+    // Error: byte deserialization failed, cause by: Odd number of digits
+    // TODO: remove the catch logic when sui part is fixed;
+    return undefined;
+  }
+
+  if (txs.data.length === 0 || !txs.data[0].transaction?.txSignatures) {
+    return undefined;
+  }
+  const tx = txs.data[0];
+  const signatures = tx.transaction?.txSignatures as string[];
+
+  for (let i = 0; i !== signatures.length; i++) {
+    const serializedSig = signatures[i];
+    const pk = getAddressFromSignatures(serializedSig, address);
+    if (!pk) {
+      continue;
+    }
+    return pk;
+  }
+  return undefined;
+}
+
+function getAddressFromSignatures(serializedSig: SerializedSignature, targetAddress: string) {
+  const decoded = parseSerializedSignature(serializedSig);
+  switch (decoded.signatureScheme) {
+    case 'MultiSig': {
+      const multiSigAddress = new MultiSigPublicKey(decoded.multisig.multisig_pk).toSuiAddress();
+      if (Formatter.isSuiAddressEqual(multiSigAddress, targetAddress)) {
+        throw new Error('multi-sig wallet cannot be owner');
+      }
+      return undefined;
+    }
+    case 'ZkLogin': {
+      if (Formatter.isSuiAddressEqual(decoded.zkLogin.address, targetAddress)) {
+        throw new Error('ZkLogin wallet cannot be owner');
+      }
+      return undefined;
+    }
+
+    case 'ED25519':
+    case 'Secp256k1':
+    case 'Secp256r1': {
+      const pk = PublicKeySerde.de({ publicKey: decoded.publicKey, scheme: decoded.signatureScheme });
+      if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
+        return pk;
+      }
+      return undefined;
+    }
+
+    default:
+      throw new Error('Unknown schema');
+  }
+}
+
+export async function getAllCoins(input: { suiClient: SuiClient; owner: string; coinType: string | undefined }) {
+  let hasNext = true;
+  let cursor: string | undefined | null;
+  const res: CoinStruct[] = [];
+  while (hasNext) {
+    const currentPage: PaginatedCoins = await input.suiClient.getCoins({
+      owner: input.owner,
+      coinType: input.coinType,
+      cursor,
+    });
+    res.push(...currentPage.data);
+    hasNext = currentPage.hasNextPage;
+    cursor = currentPage.nextCursor;
+  }
+  return res;
+}

package/temp_package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@msafe/sui3-sdk",
+  "version": "0.0.1",
+  "description": "SDK for MSafe SUI V3",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": "git@github.com:Momentum-Safe/msafe-sui3-sdk.git",
+  "author": "MSafe <admin@m-safe.io>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "@types/node": "^20.9.2",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "eslint": "^8.48.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^17.1.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-alias": "^1.1.2",
+    "eslint-import-resolver-typescript": "^3.6.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "exponential-backoff": "^3.1.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "test": "jest",
+    "unit-ci": "TEST_ENV=UNIT jest",
+    "clean": "rm -rf ./dist",
+    "lint": "eslint . --ext .ts,.tsx",
+    "build": "yarn clean && yarn _build:node",
+    "_build:node": "tsup --format cjs,esm --dts",
+    "prerelease": "yarn build && chmod +x ./scripts/prerelease.sh && ./scripts/prerelease.sh"
+  },
+  "dependencies": {
+    "@msafe/sui3-model": "^1.0.9-pre-5a4e334.0",
+    "@mysten/sui.js": "0.46.1",
+    "reflect-metadata": "^0.1.13",
+    "typeorm": "0.3.17"
+  }
+}

package/test/lib/TestHelper.ts

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

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

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

@@ -0,0 +1,49 @@
+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}"
+    }
+}'`;
+}