@msafe/sui3-sdk 0.0.5 → 0.0.6-pre-fdcc3ff.0

package/src/backend/BackendImpl.ts

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

package/src/backend/PseudoBackend.ts

@@ -8,6 +8,14 @@ import {
   UserVote,
   PendingTransaction,
 } from '@msafe/sui3-model/core';
+import {
+  CreateMSafeAccountInfoRequest,
+  deserializePublicKey,
+  MSafeAccountInfo,
+  MultisigAccountManager,
+  OwnerWithWeightPK,
+  UserWithOwnedMSafe,
+} from '@msafe/sui3-utils';
 import { SuiClient } from '@mysten/sui.js/client';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 import { SignatureScheme } from '@mysten/sui.js/src/cryptography/signature-scheme';
@@ -15,15 +23,14 @@ import { MoreThanOrEqual } from 'typeorm';
 
 import { CoreDB } from '@/backend/CoreDatabase';
 import { IBackend } from '@/backend/interface';
-import { CreateMSafeParams, JWTToken, UserWithOwnedMSafe } from '@/backend/types';
+import { JWTToken } from '@/backend/types';
 import { MessageHelper } from '@/core/MessageHelper';
 import { DBConfig } from '@/globals/const';
 import { IntentionHelper, TxIntention } from '@/transactions/intention';
-import { FutureIntention, HistorySendTx, MSafeAccountInfo, PendingTx } from '@/types/msafe';
+import { FutureIntention, HistorySendTx, PendingTx } from '@/types/msafe';
 import { Uint8ArrayToHex, HexToUint8Array } from '@/utils/buffer';
 import { PublicKeySerde, SignatureVerifier } from '@/utils/crypto';
 import { Formatter } from '@/utils/format';
-import { RawMultiSig } from '@/utils/multi-sig';
 
 /**
  * Represents a PseudoBackend class that implements the IBackend interface.
@@ -46,11 +53,6 @@ export class PseudoBackend implements IBackend {
     return new PseudoBackend(db, suiClient);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
-  async isJWTTokenValid(_jwt: JWTToken): Promise<boolean> {
-    return true;
-  }
-
   async authSign(input: {
     address: string;
     message: string;
@@ -128,12 +130,21 @@ export class PseudoBackend implements IBackend {
     return res;
   }
 
-  async createMSafeAccount(input: CreateMSafeParams) {
-    const ms = new RawMultiSig(input);
-    const msafeAddr = ms.suiAddress;
+  async createMSafeAccount(input: CreateMSafeAccountInfoRequest) {
+    const ownersWithWeightPK: OwnerWithWeightPK[] = input.ownersWithWeightPKEncoded.map((owner) => ({
+      address: owner.address,
+      weight: owner.weight,
+      publicKey: deserializePublicKey(owner.publicKeyEncoded, owner.schema),
+    }));
+    const multisigManager = new MultisigAccountManager({
+      threshold: input.threshold,
+      creationNonce: input.creationNonce,
+      ownersWithWeight: ownersWithWeightPK,
+    });
+    const msafeAddr = multisigManager.address;
 
     const signingMsg = MessageHelper.createMSafeMessage(msafeAddr);
-    const targetAddr = input.ownerWithWeight[0].address;
+    const targetAddr = input.ownersWithWeightPKEncoded[0].address;
     const verifyResult = await SignatureVerifier.verifyPersonalSignature({
       messageStr: signingMsg,
       signature: input.signature,
@@ -151,7 +162,7 @@ export class PseudoBackend implements IBackend {
     if (input.description && input.description.length > 512) {
       throw new Error('Description too long');
     }
-    const creatorAddress = input.ownerWithWeight[0].address;
+    const creatorAddress = input.ownersWithWeightPKEncoded[0].address;
     const creator = await this.getUser(creatorAddress);
     if (creator === null) {
       throw new Error('Creator not found');
@@ -165,7 +176,7 @@ export class PseudoBackend implements IBackend {
     if (msafeExistCheck !== null) {
       throw new Error('MSafe already exist in database');
     }
-    input.ownerWithWeight.forEach((ownerInfo) => {
+    input.ownersWithWeightPKEncoded.forEach((ownerInfo) => {
       if (!Formatter.isSuiAddressEqual(ownerInfo.address, ownerInfo.publicKey.toSuiAddress())) {
         throw new Error('Sui address public key not match');
       }

package/src/backend/interface.ts

@@ -1,17 +1,17 @@
+import {
+  AuthLoginRequest,
+  CreateMSafeAccountInfoRequest,
+  MSafeAccountInfo,
+  UserWithOwnedMSafe,
+} from '@msafe/sui3-utils';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 
-import { CreateMSafeParams, JWTToken, UserWithOwnedMSafe } from '@/backend/types';
+import { JWTToken } from '@/backend/types';
 import { TxIntention } from '@/transactions/intention';
-import { FutureIntention, HistorySendTx, MSafeAccountInfo, PendingTx } from '@/types/msafe';
+import { FutureIntention, HistorySendTx, PendingTx } from '@/types/msafe';
 
 export interface IBackend {
-  isJWTTokenValid(jwt: JWTToken): Promise<boolean>;
-  authSign(input: {
-    address: string;
-    message: string;
-    signature: SerializedSignature;
-    walletType: string;
-  }): Promise<JWTToken>;
+  authSign(input: AuthLoginRequest): Promise<JWTToken>;
   setJWTToken(token: JWTToken): void;
 
   getPublicKey(address: string): Promise<PublicKey | undefined>;
@@ -24,7 +24,7 @@ export interface IBackend {
   getCurrentSequenceNumber(msafeAddress: string): Promise<number>;
   getNextSequenceNumber(msafeAddress: string): Promise<number>;
 
-  createMSafeAccount(input: CreateMSafeParams): Promise<void>;
+  createMSafeAccount(input: CreateMSafeAccountInfoRequest): Promise<void>;
   proposeIntention(input: {
     intention: TxIntention;
     sequenceNumber: number;

package/src/backend/types.ts

@@ -1,22 +1 @@
-import { SerializedSignature } from '@mysten/sui.js/cryptography';
-
-import { MSafeAccountInfo, OwnerWithWeightPK } from '@/types/msafe';
-
 export type JWTToken = string;
-
-export interface CreateMSafeParams {
-  ownerWithWeight: OwnerWithWeightPK[];
-  threshold: number;
-  name: string;
-  description?: string;
-  creationNonce: number;
-  signature: SerializedSignature;
-}
-
-export interface UserWithOwnedMSafe {
-  address: string;
-  publicKey: string;
-  schema: string;
-  creationNonce: number;
-  ownedMSafe: MSafeAccountInfo[];
-}

package/src/core/CreateHelper.ts

@@ -1,10 +1,16 @@
+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 { MultiSigConfig, RawMultiSig, validateMultiSigConfig } from '@/utils/multi-sig';
+import { PublicKeySerde } from '@/utils/crypto';
 
 export class CreateHelper {
   constructor(
@@ -18,14 +24,14 @@ export class CreateHelper {
 
   async calculateMSafeAddress(info: CreatePermissionInfo) {
     const msConfig = await this.reduceCreationInfoToRawConfig(info);
-    const ms = new RawMultiSig(msConfig);
-    return ms.suiAddress;
+    const ms = new MultisigAccountManager(msConfig);
+    return ms.address;
   }
 
   // Validate the create info and return the msafe address.
   async validateCreateInfo(createInfo: CreateMSafeAccountInfo) {
     const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
-    validateMultiSigConfig(rawConfig);
+    validateCreateAccountRequest(rawConfig);
 
     // Calculate the sui address will check the multi-sig
     return this.calculateMSafeAddress(createInfo);
@@ -34,7 +40,7 @@ export class CreateHelper {
   async submitMSafeCreation(creationInfo: CreateMSafeAccountInfo) {
     const msafeAddress = await this.validateCreateInfo(creationInfo);
 
-    const signingMessage = MessageHelper.createMSafeMessage(msafeAddress);
+    const signingMessage = createAccountCreationMessage(msafeAddress);
     const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
 
     await this.submitToBackend(creationInfo, signature.signature);
@@ -50,7 +56,7 @@ export class CreateHelper {
     });
     return {
       threshold: info.threshold,
-      ownerWithWeight: info.ownerWithWeight.map((owner, i) => ({
+      ownersWithWeight: info.ownerWithWeight.map((owner, i) => ({
         publicKey: publicKeys[i] as PublicKey,
         weight: owner.weight,
       })),
@@ -61,11 +67,15 @@ 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({
-      ownerWithWeight: createInfo.ownerWithWeight.map((owner, i) => ({
-        address: owner.address,
-        weight: owner.weight,
-        publicKey: pks[i] as PublicKey, // PublicKey has been verified.
-      })),
+      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,
+        };
+      }),
       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,20 +1,24 @@
+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 { MSafeAccountInfo, PendingTx } from '@/types/msafe';
+import { PendingTx } from '@/types/msafe';
 import { HexToUint8Array } from '@/utils/buffer';
-import { RawMultiSig } from '@/utils/multi-sig';
 
 export class MSafeAccount {
-  public rawMultiSig: RawMultiSig;
+  public multisigManager: MultisigAccountManager;
 
   constructor(
     public readonly globals: MSafeGlobals,
     public readonly info: MSafeAccountInfo,
   ) {
-    this.rawMultiSig = RawMultiSig.fromMSafeAccountInfo(info);
+    this.multisigManager = new MultisigAccountManager({
+      threshold: info.threshold,
+      ownersWithWeight: info.ownersWithWeightPK,
+      creationNonce: info.creationNonce,
+    });
   }
 
   static async new(globals: MSafeGlobals, address: string) {
@@ -137,7 +141,7 @@ export class MSafeAccount {
         sigs.push(signature);
       }
     }
-    const multiSignature = this.rawMultiSig.combinePartialSignatures(sigs);
+    const multiSignature = this.multisigManager.combinePartialSignatures(sigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(pending.payload),
       signature: multiSignature,

package/src/core/MSafeClient.ts

@@ -1,3 +1,5 @@
+import { MSafeAccountInfo } from '@msafe/sui3-utils';
+
 import { JWTToken } from '@/backend/types';
 import { CreateHelper } from '@/core/CreateHelper';
 import { MessageHelper } from '@/core/MessageHelper';
@@ -6,7 +8,6 @@ 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 {
@@ -23,11 +24,6 @@ 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,6 +4,7 @@ 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;
@@ -23,7 +24,7 @@ export class MSafeGlobals {
   static async New(env: MSafeEnv, options?: MSafeConfigOptions) {
     const config = getMSafeConfig(env, options);
     const suiClient = new SuiClient(config.suiClient);
-    const backend = await PseudoBackend.New(config.backend, suiClient);
+    const backend = new BackendImpl(config.apiURL);
     return new MSafeGlobals({
       backend,
       suiClient,

package/src/globals/const.ts

@@ -13,6 +13,7 @@ export interface MSafeConfig {
     url: string;
   };
   backend: DBConfig;
+  apiURL: string;
 }
 
 export interface MSafeConfigOptions {
@@ -54,6 +55,9 @@ 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,
@@ -61,7 +65,8 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
       suiClient: {
         url: TESTNET_RPC_URL,
       },
-      backend: UNIT_DATABASE_CONFIG,
+      backend: LOCAL_DATABASE_CONFIG,
+      apiURL: LOCAL_API_URL,
     },
   ],
   [
@@ -71,6 +76,7 @@ export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
         url: TESTNET_RPC_URL,
       },
       backend: LOCAL_DATABASE_CONFIG,
+      apiURL: LOCAL_API_URL,
     },
   ],
   [
@@ -80,6 +86,7 @@ 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,25 +1,5 @@
-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,6 +1,5 @@
 export * from './buffer';
 export * from './crypto';
 export * from './format';
-export * from './multi-sig';
 export * from './sui';
 export * from './coin';