@msafe/sui3-sdk 0.0.4-pre-6732d98.0 → 0.0.4

package/src/core/CreateHelper.ts

@@ -1,16 +1,10 @@
-import {
-  createAccountCreationMessage,
-  MultisigAccountManager,
-  MultiSigConfig,
-  OwnerWithWeightPKEncoded,
-  validateCreateAccountRequest,
-} from '@msafe/sui3-utils';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 
+import { MessageHelper } from '@/core/MessageHelper';
 import { PublicKeyHelper } from '@/core/PublicKeyHelper';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
 import { CreateMSafeAccountInfo, CreatePermissionInfo } from '@/types/creation';
-import { PublicKeySerde } from '@/utils/crypto';
+import { MultiSigConfig, RawMultiSig, validateMultiSigConfig } from '@/utils/multi-sig';
 
 export class CreateHelper {
   constructor(
@@ -24,14 +18,14 @@ export class CreateHelper {
 
   async calculateMSafeAddress(info: CreatePermissionInfo) {
     const msConfig = await this.reduceCreationInfoToRawConfig(info);
-    const ms = new MultisigAccountManager(msConfig);
-    return ms.address;
+    const ms = new RawMultiSig(msConfig);
+    return ms.suiAddress;
   }
 
   // Validate the create info and return the msafe address.
   async validateCreateInfo(createInfo: CreateMSafeAccountInfo) {
     const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
-    validateCreateAccountRequest(rawConfig);
+    validateMultiSigConfig(rawConfig);
 
     // Calculate the sui address will check the multi-sig
     return this.calculateMSafeAddress(createInfo);
@@ -40,7 +34,7 @@ export class CreateHelper {
   async submitMSafeCreation(creationInfo: CreateMSafeAccountInfo) {
     const msafeAddress = await this.validateCreateInfo(creationInfo);
 
-    const signingMessage = createAccountCreationMessage(msafeAddress);
+    const signingMessage = MessageHelper.createMSafeMessage(msafeAddress);
     const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
 
     await this.submitToBackend(creationInfo, signature.signature);
@@ -56,7 +50,7 @@ export class CreateHelper {
     });
     return {
       threshold: info.threshold,
-      ownersWithWeight: info.ownerWithWeight.map((owner, i) => ({
+      ownerWithWeight: info.ownerWithWeight.map((owner, i) => ({
         publicKey: publicKeys[i] as PublicKey,
         weight: owner.weight,
       })),
@@ -67,15 +61,11 @@ export class CreateHelper {
   private async submitToBackend(createInfo: CreateMSafeAccountInfo, signature: SerializedSignature) {
     const pks = await this.pkHelper.getPublicKeyBatch(createInfo.ownerWithWeight.map((owner) => owner.address));
     await this.globals.backend.createMSafeAccount({
-      ownersWithWeightPKEncoded: createInfo.ownerWithWeight.map((owner, i): OwnerWithWeightPKEncoded => {
-        const publicKeySer = PublicKeySerde.ser(pks[i] as PublicKey);
-        return {
-          address: owner.address,
-          weight: owner.weight,
-          publicKeyEncoded: publicKeySer.publicKey,
-          schema: publicKeySer.scheme,
-        };
-      }),
+      ownerWithWeight: createInfo.ownerWithWeight.map((owner, i) => ({
+        address: owner.address,
+        weight: owner.weight,
+        publicKey: pks[i] as PublicKey, // PublicKey has been verified.
+      })),
       threshold: createInfo.threshold,
       name: createInfo.name, // name validation is deferred to backend
       description: createInfo.description, // description validation is deferred to backend

package/src/core/MSafeAccount.ts

@@ -1,24 +1,20 @@
-import { MSafeAccountInfo, MultisigAccountManager } from "@msafe/sui3-utils";
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { MessageHelper } from '@/core/MessageHelper';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
 import { IntentionHelper, TxIntention } from '@/transactions/intention';
-import { PendingTx } from '@/types/msafe';
+import { MSafeAccountInfo, PendingTx } from '@/types/msafe';
 import { HexToUint8Array } from '@/utils/buffer';
+import { RawMultiSig } from '@/utils/multi-sig';
 
 export class MSafeAccount {
-  public multisigManager: MultisigAccountManager;
+  public rawMultiSig: RawMultiSig;
 
   constructor(
     public readonly globals: MSafeGlobals,
     public readonly info: MSafeAccountInfo,
   ) {
-    this.multisigManager = new MultisigAccountManager({
-      threshold: info.threshold,
-      ownersWithWeight: info.ownersWithWeightPK,
-      creationNonce: info.creationNonce,
-    });
+    this.rawMultiSig = RawMultiSig.fromMSafeAccountInfo(info);
   }
 
   static async new(globals: MSafeGlobals, address: string) {
@@ -141,7 +137,7 @@ export class MSafeAccount {
         sigs.push(signature);
       }
     }
-    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
+    const multiSignature = this.rawMultiSig.combinePartialSignatures(sigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(pending.payload),
       signature: multiSignature,

package/src/core/MSafeClient.ts

@@ -1,5 +1,3 @@
-import { MSafeAccountInfo } from '@msafe/sui3-utils';
-
 import { JWTToken } from '@/backend/types';
 import { CreateHelper } from '@/core/CreateHelper';
 import { MessageHelper } from '@/core/MessageHelper';
@@ -8,6 +6,7 @@ import { PublicKeyHelper } from '@/core/PublicKeyHelper';
 import { MSafeConfigOptions, MSafeEnv } from '@/globals/const';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
 import { CreateMSafeAccountInfo } from '@/types/creation';
+import { MSafeAccountInfo } from '@/types/msafe';
 import { IWallet } from '@/types/wallet';
 
 export class MSafeClient {
@@ -24,6 +23,11 @@ export class MSafeClient {
 
   async connectWallet(input: { wallet: IWallet; jwtToken?: JWTToken }): Promise<JWTToken> {
     this.globals.wallet = input.wallet;
+    const isValidJWT = input.jwtToken && (await this.backend.isJWTTokenValid(input.jwtToken));
+    if (isValidJWT) {
+      this.backend.setJWTToken(input.jwtToken as JWTToken);
+      return input.jwtToken as JWTToken;
+    }
     const messageStr = MessageHelper.welcomeMessage(new Date().toUTCString());
     const sig = await input.wallet.signPersonalMessage({
       messageStr,

package/src/globals/MSafeGlobals.ts

@@ -4,7 +4,6 @@ import { IBackend } from '@/backend/interface';
 import { PseudoBackend } from '@/backend/PseudoBackend';
 import { getMSafeConfig, MSafeConfig, MSafeConfigOptions, MSafeEnv } from '@/globals/const';
 import { IWallet } from '@/types/wallet';
-import { BackendImpl } from "@/backend/BackendImpl";
 
 export class MSafeGlobals {
   public readonly backend: IBackend;
@@ -24,7 +23,7 @@ export class MSafeGlobals {
   static async New(env: MSafeEnv, options?: MSafeConfigOptions) {
     const config = getMSafeConfig(env, options);
     const suiClient = new SuiClient(config.suiClient);
-    const backend = new BackendImpl(config.apiURL);
+    const backend = await PseudoBackend.New(config.backend, suiClient);
     return new MSafeGlobals({
       backend,
       suiClient,

package/src/globals/const.ts

@@ -13,7 +13,6 @@ export interface MSafeConfig {
     url: string;
   };
   backend: DBConfig;
-  apiURL: string;
 }
 
 export interface MSafeConfigOptions {
@@ -55,9 +54,6 @@ export const DEV_DATABASE_CONFIG: DBConfig = {
 export const TESTNET_RPC_URL = 'https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
 export const MAINNET_RPC_URL = 'https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7';
 
-export const LOCAL_API_URL = 'http://127.0.0.1:3000';
-export const DEV_API_URL = 'http://13.56.226.148';
-
 export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
   [
     MSafeEnv.unit,
@@ -65,8 +61,7 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
       suiClient: {
         url: TESTNET_RPC_URL,
       },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
+      backend: UNIT_DATABASE_CONFIG,
     },
   ],
   [
@@ -76,7 +71,6 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
         url: TESTNET_RPC_URL,
       },
       backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
     },
   ],
   [
@@ -86,7 +80,6 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
         url: TESTNET_RPC_URL,
       },
       backend: DEV_DATABASE_CONFIG,
-      apiURL: DEV_API_URL,
     },
   ],
 ]);

package/src/types/msafe.ts

@@ -1,5 +1,25 @@
+import { PublicKey } from '@mysten/sui.js/src/cryptography';
+
 import { TxIntention } from '@/transactions/intention';
 
+export interface MSafeAccountInfo {
+  address: string;
+  ownersWithWeightPK: OwnerWithWeightPK[];
+  threshold: number;
+  name: string;
+  description?: string;
+  creationNonce: number;
+}
+
+export type OwnerWithWeightPK = OwnerWithWeight & {
+  publicKey: PublicKey;
+};
+
+export interface OwnerWithWeight {
+  address: string;
+  weight: number;
+}
+
 export interface PendingTx {
   digest: string;
   payload: string;

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './buffer';
 export * from './crypto';
 export * from './format';
+export * from './multi-sig';
 export * from './sui';
 export * from './coin';

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/backend/BackendImpl.ts

@@ -1,196 +0,0 @@
-import {
-  AuthLoginRequest,
-  AuthLoginResponse,
-  CreateMSafeAccountInfoRequest,
-  GetMSafeAccountInfoResponse,
-  MSafeAccountInfo,
-  OwnerWithWeightPK,
-  PublicKeyWithScheme,
-  UserWithOwnedMSafe,
-  UserWithOwnedMSafeResponse,
-} from '@msafe/sui3-utils';
-import { SerializedSignature } from '@mysten/sui.js/cryptography';
-import { PublicKey } from '@mysten/sui.js/src/cryptography';
-import axios from 'axios';
-
-import { IBackend } from '@/backend/interface';
-import { JWTToken } from '@/backend/types';
-import { TxIntention } from '@/transactions/intention';
-import { FutureIntention, HistorySendTx, PendingTx } from '@/types/msafe';
-import { PublicKeySerde } from '@/utils/crypto';
-
-export class BackendImpl implements IBackend {
-  private _token: JWTToken;
-
-  constructor(private readonly apiURL: string) {}
-
-  async authSign(input: AuthLoginRequest): Promise<JWTToken> {
-    const res = await axios.post<AuthLoginResponse>(`${this.apiURL}/auth/login`, input);
-    // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid authSign return: ${res}`);
-    }
-    this._token = res.data.accessToken;
-    return this._token;
-  }
-
-  setJWTToken(token: JWTToken) {
-    this._token = token;
-  }
-
-  async getPublicKey(address: string): Promise<PublicKey | undefined> {
-    return (await this.getPublicKeyBatch([address]))[0];
-  }
-
-  async getPublicKeyBatch(addresses: string[]): Promise<(PublicKey | undefined)[]> {
-    const res = await axios.post<(PublicKeyWithScheme | undefined)[]>(
-      `${this.apiURL}/account/getPublicKeyBatch`,
-      addresses,
-      {
-        headers: this.headers(),
-      },
-    );
-    // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-
-    return res.data?.map((publicKeyWithSchema) =>
-      publicKeyWithSchema ? PublicKeySerde.de({ ...publicKeyWithSchema }) : undefined,
-    );
-  }
-
-  async getMSafeAccountInfo(msafeAddress: string): Promise<MSafeAccountInfo> {
-    const res = await axios.get<GetMSafeAccountInfoResponse>(
-      `${this.apiURL}/account/getMSafeAccountInfo/${msafeAddress}`,
-      {
-        headers: this.headers(),
-      },
-    );
-
-    // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-
-    const msafeResp = res.data;
-    return {
-      address: msafeResp.address,
-      ownersWithWeightPK: msafeResp.ownersWithWeightPKEncoded.map(
-        (owner): OwnerWithWeightPK => ({
-          publicKey: PublicKeySerde.de({ publicKey: owner.publicKeyEncoded, scheme: owner.schema }),
-          address: owner.address,
-          weight: owner.weight,
-        }),
-      ),
-      threshold: msafeResp.threshold,
-      name: msafeResp.name,
-      description: msafeResp.description,
-      creationNonce: msafeResp.creationNonce,
-    };
-  }
-
-  async getUserInfo(userAddress: string): Promise<UserWithOwnedMSafe> {
-    const res = await axios.get<UserWithOwnedMSafeResponse>(`${this.apiURL}/account/user/${userAddress}`, {
-      headers: this.headers(),
-    });
-
-    // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
-
-    return {
-      address: res.data.address,
-      publicKey: res.data.publicKey,
-      schema: res.data.schema,
-      creationNonce: res.data.creationNonce,
-      ownedMSafe: res.data.ownedMSafe.map(
-        (msafe): MSafeAccountInfo => ({
-          address: msafe.address,
-          ownersWithWeightPK: msafe.ownersWithWeightPKEncoded.map(
-            (owner): OwnerWithWeightPK => ({
-              publicKey: PublicKeySerde.de({ publicKey: owner.publicKeyEncoded, scheme: owner.schema }),
-              address: owner.address,
-              weight: owner.weight,
-            }),
-          ),
-          threshold: msafe.threshold,
-          name: msafe.name,
-          description: msafe.description,
-          creationNonce: msafe.creationNonce,
-        }),
-      ),
-    };
-  }
-
-  async getPendingTransactions(msafeAddress: string): Promise<PendingTx[]> {
-    return [];
-  }
-
-  async getHistoryTransactions(msafeAddress: string): Promise<HistorySendTx[]> {
-    return [];
-  }
-
-  async getFutureIntentions(msafeAddress: string): Promise<FutureIntention[]> {
-    return [];
-  }
-
-  async getCurrentSequenceNumber(msafeAddress: string): Promise<number> {
-    return 0;
-  }
-
-  async getNextSequenceNumber(msafeAddress: string): Promise<number> {
-    return 0;
-  }
-
-  async createMSafeAccount(input: CreateMSafeAccountInfoRequest): Promise<void> {
-    const res = await axios.post(`${this.apiURL}/account`, input, {
-      headers: this.headers(),
-    });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid createMSafeAccount return: ${res}`);
-    }
-  }
-
-  async proposeIntention(input: {
-    intention: TxIntention;
-    sequenceNumber: number;
-    userAddress: string;
-    msafeAddress: string;
-    signature: SerializedSignature;
-  }): Promise<void> {
-  }
-
-  async proposePendingTransaction(input: {
-    intention: TxIntention;
-    userAddress: string;
-    msafeAddress: string;
-    digest: string;
-    signature: SerializedSignature;
-  }): Promise<void> {}
-
-  async rejectCurrentTx(input: {
-    userAddress: string;
-    msafeAddress: string;
-    digest: string;
-    signature: SerializedSignature;
-  }) {}
-
-  async voteForTransaction(input: {
-    txDigest: string;
-    msafeAddress: string;
-    userAddress: string;
-    signature: SerializedSignature;
-  }) {}
-
-  async buildNextIntentionAndAddToPending(input: { msafeAddress: string }) {}
-
-  async skipNextFailedIntention(input: { msafeAddress: string; userAddress: string }) {}
-
-  async processExecutedTransaction(digest: string) {}
-
-  private headers() {
-    return { Authorization: `Bearer ${this._token}` };
-  }
-}