@msafe/sui3-sdk 0.0.12 → 0.0.14

package/src/core/MSafeAccount.ts

@@ -1,44 +1,51 @@
 import {
   buildIntentionTransaction,
-  getIntentionType,
-  MSafeAccountInfo,
-  MultisigAccountManager,
+  IMSafeConfig,
+  IPageOptions,
+  MultiSigAccount,
+  PublicKeySerde,
+  SigningMessageHelper,
 } from '@msafe/sui3-utils';
 import { SuiObjectData } from '@mysten/sui.js/client';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 import { SuiObjectResponse } from '@mysten/sui.js/src/client';
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 
-import { MessageHelper } from '@/core/MessageHelper';
-import { MSAFE_APPLICATION } from '@/globals';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
 import { IntentionHelper, TxIntention } from '@/transactions/intention';
 import { OwnedCoin } from '@/types/assets';
-import { PaginationOption } from '@/types/backend';
 import { PendingTx, SimulationResult } from '@/types/msafe';
 import { CoinHelper } from '@/utils';
 import { HexToUint8Array } from '@/utils/buffer';
 import { BatchObjectOptions, getAllOwnedObjects } from '@/utils/iter/object';
 
 export class MSafeAccount {
-  public multisigManager: MultisigAccountManager;
+  public multiSig: MultiSigAccount;
 
   private coinHelper: CoinHelper;
 
   constructor(
     public readonly globals: MSafeGlobals,
-    public readonly info: MSafeAccountInfo,
+    public readonly info: IMSafeConfig,
   ) {
-    this.multisigManager = new MultisigAccountManager({
+    this.multiSig = new MultiSigAccount({
       threshold: info.threshold,
-      ownersWithWeight: info.ownersWithWeightPK,
+      ownersWithWeight: info.owners.map((owner) => ({
+        address: owner.address,
+        weight: owner.weight,
+        publicKey: PublicKeySerde.de({ publicKeyEncoded: owner.publicKeyEncoded, schema: owner.schema }),
+      })),
       creationNonce: info.creationNonce,
     });
     this.coinHelper = new CoinHelper(this.suiClient);
   }
 
-  static async new(globals: MSafeGlobals, address: string) {
-    return globals.backend.getMSafeAccountInfo(address);
+  static async New(globals: MSafeGlobals, address: string) {
+    const info = await globals.backend.getMSafeAccountInfo(address);
+    const ms = new MSafeAccount(globals, info);
+    if (ms.address !== address) {
+      throw new Error('Invalid msafe config with address');
+    }
   }
 
   async ownedCoins(): Promise<OwnedCoin[]> {
@@ -87,11 +94,11 @@ export class MSafeAccount {
     };
   }
 
-  async historyTransaction(paginationOption?: PaginationOption) {
+  async historyTransaction(paginationOption?: IPageOptions) {
     return this.backend.getHistoryTransactions(this.address, paginationOption);
   }
 
-  async futureIntentions(paginationOption?: PaginationOption) {
+  async futureIntentions(paginationOption?: IPageOptions) {
     const paginatedIntentions = await this.backend.getFutureIntentions(this.address, paginationOption);
     return paginatedIntentions.data;
   }
@@ -104,27 +111,28 @@ export class MSafeAccount {
     return this.backend.getNextSequenceNumber(this.address);
   }
 
-  async proposeIntention(intention: TxIntention, sequenceNumber: number) {
-    const message = MessageHelper.proposeIntentionMessage({
-      intention,
-      sn: sequenceNumber,
+  async proposeIntention(input: {
+    application: string;
+    txType: string;
+    txSubType: string;
+    intention: TxIntention;
+    sequenceNumber: number;
+  }) {
+    const message = SigningMessageHelper.proposeIntentionMessage({
       msafeAddress: this.address,
+      intention: input.intention,
+      sn: input.sequenceNumber,
     });
     const signature = await this.wallet.signPersonalMessage({
       messageStr: message,
     });
 
-    const txType = getIntentionType(intention);
     // TODO get application from common utils
     await this.backend.proposeIntention({
-      intention,
-      sequenceNumber,
+      ...input,
       msafeAddress: this.address,
       userAddress: await this.userAddress(),
       signature: signature.signature,
-      application: MSAFE_APPLICATION,
-      txType: txType.txType,
-      txSubType: txType.txSubType,
     });
   }
 
@@ -234,14 +242,14 @@ export class MSafeAccount {
     }
 
     const sigs: SerializedSignature[] = [];
-    for (let i = 0; i < this.info.ownersWithWeightPK.length; i++) {
-      const owner = this.info.ownersWithWeightPK[i];
-      const signature = gotSigs.get(owner.publicKey.toSuiAddress());
+    for (let i = 0; i < this.info.owners.length; i++) {
+      const owner = this.info.owners[i];
+      const signature = gotSigs.get(owner.address);
       if (signature) {
         sigs.push(signature);
       }
     }
-    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
+    const multiSignature = this.multiSig.combinePartialSignatures(sigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(payload),
       signature: multiSignature,
@@ -250,7 +258,7 @@ export class MSafeAccount {
   }
 
   get address() {
-    return this.info.address;
+    return this.multiSig.address;
   }
 
   private get backend() {

package/src/core/MSafeClient.ts

@@ -1,14 +1,13 @@
-import { MSafeAccountInfo } from '@msafe/sui3-utils';
+import { IMSafeConfig, IPageOptions, JWTToken, SigningMessageHelper, UserMSafeStatus } from '@msafe/sui3-utils';
 
 import { AddressBookSDK } from '@/core/AddressBookSDK';
 import { CreateHelper } from '@/core/CreateHelper';
-import { MessageHelper } from '@/core/MessageHelper';
+import { InvitationSDK } from '@/core/InvitationSDK';
 import { MSafeAccount } from '@/core/MSafeAccount';
 import { PublicKeyHelper } from '@/core/PublicKeyHelper';
 import { MSafeConfigOptions, MSafeEnv } from '@/globals/const';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
-import { JWTToken } from '@/types/backend';
-import { CreateMSafeAccountInfo } from '@/types/creation';
+import { CreateMSafeInfo } from '@/types';
 import { IWallet } from '@/types/wallet';
 
 export class MSafeClient {
@@ -39,7 +38,7 @@ export class MSafeClient {
   }
 
   private async authSign(wallet: IWallet): Promise<JWTToken> {
-    const messageStr = MessageHelper.welcomeMessage(new Date().toUTCString());
+    const messageStr = SigningMessageHelper.loginMessageWithTimestamp(new Date().toUTCString());
     const sig = await wallet.signPersonalMessage({
       messageStr,
     });
@@ -52,14 +51,18 @@ export class MSafeClient {
   }
 
   async userInfo() {
-    return this.globals.backend.getUserInfo(await this.walletAddress());
+    return this.globals.backend.getUserInfo();
   }
 
-  async createAccount(info: CreateMSafeAccountInfo) {
+  async ownedMSafe(pagination?: IPageOptions) {
+    return this.globals.backend.getOwnedMSafeByStatus({ status: UserMSafeStatus.active, pagination });
+  }
+
+  async createAccount(info: CreateMSafeInfo) {
     return this.creationHelper.submitMSafeCreation(info);
   }
 
-  getMSafeAccount(info: MSafeAccountInfo) {
+  getMSafeAccount(info: IMSafeConfig) {
     return new MSafeAccount(this.globals, info);
   }
 
@@ -100,6 +103,10 @@ export class MSafeClient {
     return new AddressBookSDK(this.globals);
   }
 
+  get Invitation(): InvitationSDK {
+    return new InvitationSDK(this.globals);
+  }
+
   private async walletAddress() {
     return this.wallet.address();
   }

package/src/core/PublicKeyHelper.ts

@@ -39,6 +39,9 @@ export class PublicKeyHelper {
     const emptyIndexes = results
       .map((elem, index) => (elem === undefined ? index : -1))
       .filter((index) => index !== -1);
+    if (emptyIndexes.length === 0) {
+      return results;
+    }
     const backendResult = await this.globals.backend.getPublicKeyBatch(emptyIndexes.map((index) => addresses[index]));
     for (let i = 0; i < emptyIndexes.length; i++) {
       const index = emptyIndexes[i];

package/src/core/index.ts

@@ -1,5 +1,4 @@
 export { CreateHelper } from './CreateHelper';
-export { MessageHelper } from './MessageHelper';
 export { MSafeClient } from './MSafeClient';
 export { MSafeAccount } from './MSafeAccount';
 export { AddressBookSDK } from './AddressBookSDK';

package/src/globals/MSafeGlobals.ts

@@ -23,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 = new BackendImpl(config.backend.url);
     return new MSafeGlobals({
       backend,
       suiClient,

package/src/globals/const.ts

@@ -1,5 +1,3 @@
-import { ModelConfig } from '@msafe/sui3-model/common';
-
 export enum MSafeEnv {
   local = 'local',
   unit = 'unit',
@@ -12,8 +10,9 @@ export interface MSafeConfig {
   suiClient: {
     url: string;
   };
-  backend: DBConfig;
-  apiURL: string;
+  backend: {
+    url: string;
+  };
   syncingURL: string;
 }
 
@@ -21,38 +20,10 @@ export interface MSafeConfigOptions {
   suiClient?: {
     url?: string;
   };
-  backend?: DBConfig;
+  backend?: {
+    url?: string;
+  };
 }
-
-// Use pseudo backend for now.
-export type DBConfig = ModelConfig;
-
-export const UNIT_DATABASE_CONFIG: DBConfig = {
-  type: 'sqlite',
-  database: ':memory:',
-  logging: false,
-};
-
-export const LOCAL_DATABASE_CONFIG: DBConfig = {
-  type: 'mysql',
-  host: '127.0.0.1',
-  port: 3306,
-  username: 'msafe',
-  password: 'msafe',
-  database: 'msafe_sui_local',
-  logging: false,
-};
-
-export const DEV_DATABASE_CONFIG: DBConfig = {
-  type: 'mysql',
-  host: 'msafe-dev-database.cluster-caos3ssocrx6.us-west-1.rds.amazonaws.com',
-  port: 3306,
-  username: 'msafe',
-  password: 'Momentum.Safe2022',
-  database: 'msafe_sui_dev',
-  logging: false,
-};
-
 export const MSAFE_APPLICATION = 'msafe';
 
 export const TESTNET_RPC_URL = 'https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
@@ -71,8 +42,9 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
       suiClient: {
         url: TESTNET_RPC_URL,
       },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
+      backend: {
+        url: LOCAL_API_URL,
+      },
       syncingURL: LOCAL_SYNCING_URL,
     },
   ],
@@ -82,8 +54,9 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
       suiClient: {
         url: TESTNET_RPC_URL,
       },
-      backend: LOCAL_DATABASE_CONFIG,
-      apiURL: LOCAL_API_URL,
+      backend: {
+        url: LOCAL_API_URL,
+      },
       syncingURL: LOCAL_SYNCING_URL,
     },
   ],
@@ -93,8 +66,9 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
       suiClient: {
         url: TESTNET_RPC_URL,
       },
-      backend: DEV_DATABASE_CONFIG,
-      apiURL: DEV_API_URL,
+      backend: {
+        url: DEV_API_URL,
+      },
       syncingURL: DEV_SYNCING_URL,
     },
   ],
@@ -108,10 +82,8 @@ export function getMSafeConfig(env: MSafeEnv, options?: MSafeConfigOptions) {
   if (options?.suiClient?.url) {
     config.suiClient.url = options.suiClient.url;
   }
-  if (options?.backend) {
-    config.backend = options.backend;
+  if (options?.backend?.url) {
+    config.backend.url = options.backend.url;
   }
   return config;
 }
-
-export const AUTH_SIGN_MESSAGE = 'Welcome to MSafe';

package/src/types/create.ts

@@ -0,0 +1,11 @@
+// TODO: Create a class and helper to deal with all the nasty stuff
+export interface CreateMSafeInfo {
+  name: string;
+  description?: string;
+  owners: {
+    address: string;
+    weight: number;
+  }[];
+  creationNonce: number;
+  threshold: number;
+}

package/src/types/index.ts

@@ -1,6 +1,3 @@
-export * from './creation';
 export * from './msafe';
 export * from './wallet';
-export * from './pagination';
-export * from './address-book';
-export * from './backend';
+export * from './create';

package/src/types/msafe.ts

@@ -1,4 +1,5 @@
 import { GasCostSummary, DryRunTransactionBlockResponse } from '@mysten/sui.js/client';
+import { SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { TxIntention } from '@/transactions/intention';
 
@@ -65,6 +66,17 @@ export interface FutureIntention {
   createdAt: Date;
 }
 
+export interface ProposeIntention {
+  application: string;
+  txType: string;
+  txSubType: string;
+  intention: TxIntention;
+  sequenceNumber: number;
+  userAddress: string;
+  msafeAddress: string;
+  signature: SerializedSignature;
+}
+
 export interface SimulationResult {
   success: boolean;
   errorMsg?: string;

package/src/utils/crypto.ts

@@ -1,13 +1,4 @@
-import {
-  PublicKey,
-  SerializedSignature,
-  SIGNATURE_FLAG_TO_SCHEME,
-  SignatureFlag,
-  SignatureScheme,
-} from '@mysten/sui.js/cryptography';
-import { Ed25519PublicKey } from '@mysten/sui.js/keypairs/ed25519';
-import { Secp256k1PublicKey } from '@mysten/sui.js/keypairs/secp256k1';
-import { Secp256r1PublicKey } from '@mysten/sui.js/keypairs/secp256r1';
+import { SerializedSignature } from '@mysten/sui.js/cryptography';
 import { verifyPersonalMessage, verifyTransactionBlock } from '@mysten/sui.js/verify';
 
 import { stringToBuffer } from '@/utils/buffer';
@@ -71,25 +62,3 @@ export class SignatureVerifier {
     });
   }
 }
-
-export class PublicKeySerde {
-  static ser(publicKey: PublicKey) {
-    return {
-      publicKey: publicKey.toBase64(),
-      scheme: SIGNATURE_FLAG_TO_SCHEME[publicKey.flag() as SignatureFlag],
-    };
-  }
-
-  static de(input: { publicKey: string | Uint8Array; scheme: SignatureScheme }): PublicKey {
-    switch (input.scheme) {
-      case 'ED25519':
-        return new Ed25519PublicKey(input.publicKey);
-      case 'Secp256k1':
-        return new Secp256k1PublicKey(input.publicKey);
-      case 'Secp256r1':
-        return new Secp256r1PublicKey(input.publicKey);
-      default:
-        throw new Error('Unsupported signature scheme: $input.scheme');
-    }
-  }
-}

package/src/utils/sui.ts

@@ -1,8 +1,8 @@
+import { PublicKeySerde } from '@msafe/sui3-utils';
 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';
@@ -60,7 +60,7 @@ function getAddressFromSignatures(serializedSig: SerializedSignature, targetAddr
     case 'ED25519':
     case 'Secp256k1':
     case 'Secp256r1': {
-      const pk = PublicKeySerde.de({ publicKey: decoded.publicKey, scheme: decoded.signatureScheme });
+      const pk = PublicKeySerde.de({ publicKeyEncoded: decoded.publicKey, schema: decoded.signatureScheme });
       if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
         return pk;
       }

package/src/backend/CoreDatabase.ts

@@ -1,55 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import 'reflect-metadata';
-
-import { CoreModel, User, UserSetting } from '@msafe/sui3-model/core';
-import { PublicKey } from '@mysten/sui.js/cryptography';
-
-import { DBConfig } from '@/globals/const';
-import { PublicKeySerde } from '@/utils/crypto';
-
-export const WALLET_TYPE_KEY = 'wallet_type';
-
-export class CoreDB {
-  private constructor(public readonly coreModel: CoreModel) {}
-
-  static async New(dbConfig: DBConfig) {
-    const core = await CoreModel.New(dbConfig);
-    return new CoreDB(core);
-  }
-
-  async upsertUser(input: { address: string; publicKey: PublicKey; lastLogin: Date }) {
-    const currentUser = await this.coreModel.user.findOneBy({
-      address: input.address,
-    });
-    if (currentUser !== null) {
-      currentUser.lastLogin = input.lastLogin;
-      await this.coreModel.user.save(currentUser);
-    } else {
-      const serializedPublicKey = PublicKeySerde.ser(input.publicKey);
-      const user: User = {
-        address: input.address,
-        publicKey: serializedPublicKey.publicKey,
-        schema: serializedPublicKey.scheme,
-        nonce: 0,
-        lastLogin: new Date(),
-      };
-      await this.coreModel.user.save(user);
-    }
-  }
-
-  async updateUserWalletType(input: { address: string; walletType: string }) {
-    const exist = await this.coreModel.userSetting.findOneBy({
-      userAddress: input.address,
-      key: WALLET_TYPE_KEY,
-    });
-    const walletType = input.walletType.trim();
-    if (exist === null || exist.value !== walletType) {
-      const userSetting: UserSetting = {
-        userAddress: input.address,
-        key: WALLET_TYPE_KEY,
-        value: walletType,
-      };
-      await this.coreModel.userSetting.save(userSetting);
-    }
-  }
-}