@msafe/sui3-sdk 0.0.13 → 0.0.14

package/src/backend/BackendImpl.ts

@@ -1,14 +1,22 @@
 import {
-  AuthLoginRequest,
-  AuthLoginResponse,
-  CreateMSafeAccountInfoRequest,
-  GetMSafeAccountInfoResponse,
   HistoryTransaction,
-  MSafeAccountInfo,
-  OwnerWithWeightPK,
-  PublicKeyWithScheme,
-  UserWithOwnedMSafe,
-  UserWithOwnedMSafeResponse,
+  IAuthLoginReq,
+  IAuthLoginResp,
+  ICreateMSafeReq,
+  IGetMSafeQuery,
+  IGetMSafesQuery,
+  IGetPublicKeyBatchQuery,
+  IGetPublicKeyBatchResp,
+  IMSafeInfoResp,
+  IPagedResult,
+  IPageOptions,
+  IUpdateMSafeStatusReq,
+  IUserInfoResp,
+  JWTToken,
+  PublicKeySerde,
+  UserMSafeStatus,
+  IGetAddressBookResult,
+  UpdateAddressBookEntry,
 } from '@msafe/sui3-utils';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 import { PublicKey } from '@mysten/sui.js/src/cryptography';
@@ -16,19 +24,15 @@ import axios from 'axios';
 
 import { IBackend } from '@/backend/interface';
 import { TxIntention } from '@/transactions/intention';
-import { PagedResult } from '@/types';
-import { GetAddressBookResult, UpdateAddressBookEntry } from '@/types/address-book';
-import { JWTToken, PaginationOption } from '@/types/backend';
 import { FutureIntention, PendingTx, ProposeIntention } 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);
+  async authSign(input: IAuthLoginReq): Promise<JWTToken> {
+    const res = await axios.post<IAuthLoginResp>(`${this.apiURL}/auth/login`, input);
     // TODO unify response struct
     if (res.status !== 200 && res.status !== 201) {
       throw new Error(`invalid authSign return: ${res}`);
@@ -55,85 +59,78 @@ export class BackendImpl implements IBackend {
   }
 
   async getPublicKeyBatch(addresses: string[]): Promise<(PublicKey | undefined)[]> {
-    const res = await axios.post<(PublicKeyWithScheme | undefined)[]>(
-      `${this.apiURL}/account/getPublicKeyBatch`,
-      addresses,
-      {
-        headers: this.headers(),
-      },
-    );
+    const query: IGetPublicKeyBatchQuery = {
+      userAddressList: addresses,
+    };
+    const res = await axios.get<IGetPublicKeyBatchResp>(`${this.apiURL}/user/public-keys`, {
+      params: query,
+      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,
+      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(),
-      },
-    );
-
+  async getMSafeAccountInfo(msafeAddress: string): Promise<IMSafeInfoResp> {
+    const q: IGetMSafeQuery = {
+      msafeAddress,
+    };
+    const res = await axios.get<IMSafeInfoResp>(`${this.apiURL}/msafe`, {
+      params: q,
+      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,
-    };
+    return res.data;
   }
 
-  async getUserInfo(userAddress: string): Promise<UserWithOwnedMSafe> {
-    const res = await axios.get<UserWithOwnedMSafeResponse>(`${this.apiURL}/account/user/${userAddress}`, {
+  async getUserInfo(): Promise<IUserInfoResp> {
+    const userRes = await axios.get<IUserInfoResp>(`${this.apiURL}/user`, {
       headers: this.headers(),
     });
-
     // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
+    if (userRes.status !== 200 && userRes.status !== 201) {
+      throw new Error(`invalid getPublicKeyBatch return: ${userRes}`);
     }
+    return userRes.data;
+  }
 
-    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 getOwnedMSafeByStatus(input: {
+    status?: UserMSafeStatus;
+    pagination?: IPageOptions;
+  }): Promise<IPagedResult<IMSafeInfoResp>> {
+    const q: IGetMSafesQuery = {
+      status: input.status ?? UserMSafeStatus.active,
+      ...(input.pagination
+        ? {
+            page: input.pagination.page.toString(),
+            limit: input.pagination.limit.toString(),
+          }
+        : {}),
     };
+    const res = await axios.get<IPagedResult<IMSafeInfoResp>>(`${this.apiURL}/msafe/owned`, {
+      params: q,
+      headers: this.headers(),
+    });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid getOwnedMSafeByStatus return: ${res}`);
+    }
+    return res.data;
+  }
+
+  async updateMSafeStatus(input: { msafeAddress: string; status: UserMSafeStatus }): Promise<void> {
+    const p: IUpdateMSafeStatusReq = input;
+    const res = await axios.post(`${this.apiURL}/msafe/status`, p, { headers: this.headers() });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`Invalid updateMSafeStatus return: ${res}`);
+    }
   }
 
   async getPendingTransactions(msafeAddress: string): Promise<PendingTx[]> {
@@ -148,9 +145,9 @@ export class BackendImpl implements IBackend {
 
   async getHistoryTransactions(
     msafeAddress: string,
-    paginationOption?: PaginationOption,
-  ): Promise<PagedResult<HistoryTransaction>> {
-    const res = await axios.get<PagedResult<HistoryTransaction>>(
+    paginationOption?: IPageOptions,
+  ): Promise<IPagedResult<HistoryTransaction>> {
+    const res = await axios.get<IPagedResult<HistoryTransaction>>(
       `${this.apiURL}/transaction/history?address=${msafeAddress}`,
       {
         params: {
@@ -168,9 +165,9 @@ export class BackendImpl implements IBackend {
 
   async getFutureIntentions(
     msafeAddress: string,
-    paginationOption?: PaginationOption,
-  ): Promise<PagedResult<FutureIntention>> {
-    const res = await axios.get<PagedResult<FutureIntention>>(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
+    paginationOption?: IPageOptions,
+  ): Promise<IPagedResult<FutureIntention>> {
+    const res = await axios.get<IPagedResult<FutureIntention>>(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
       params: {
         page: paginationOption?.page,
         limit: paginationOption?.limit,
@@ -203,8 +200,8 @@ export class BackendImpl implements IBackend {
     return res.data;
   }
 
-  async createMSafeAccount(input: CreateMSafeAccountInfoRequest): Promise<void> {
-    const res = await axios.post(`${this.apiURL}/account`, input, {
+  async createMSafeAccount(input: ICreateMSafeReq): Promise<void> {
+    const res = await axios.post(`${this.apiURL}/msafe/create`, input, {
       headers: this.headers(),
     });
     if (res.status !== 200 && res.status !== 201) {
@@ -213,24 +210,23 @@ export class BackendImpl implements IBackend {
   }
 
   async proposeIntention(input: ProposeIntention): Promise<void> {
-    try {
-      const res = await axios.post(`${this.apiURL}/transaction/intention`, input, { headers: this.headers() });
-      if (res.status !== 200 && res.status !== 201) {
-        throw new Error(`invalid proposeIntention return: ${res}`);
-      }
-    } catch (e) {
-      console.log(e);
+    const res = await axios.post(`${this.apiURL}/transaction/intention`, input, { headers: this.headers() });
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid proposeIntention return: ${res}`);
     }
   }
 
   // TODO later
-  async proposePendingTransaction(input: {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async proposePendingTransaction(_input: {
     intention: TxIntention;
     userAddress: string;
     msafeAddress: string;
     digest: string;
     signature: SerializedSignature;
-  }): Promise<void> {}
+  }): Promise<void> {
+    return undefined;
+  }
 
   async rejectCurrentTx(input: {
     userAddress: string;
@@ -238,23 +234,19 @@ export class BackendImpl implements IBackend {
     digest: string;
     signature: SerializedSignature;
   }) {
-    try {
-      const res = await axios.post(
-        `${this.apiURL}/transaction/pending/reject`,
-        {
-          address: input.msafeAddress,
-          digest: input.digest,
-          signature: input.signature,
-        },
-        {
-          headers: this.headers(),
-        },
-      );
-      if (res.status !== 200 && res.status !== 201) {
-        throw new Error(`invalid voteForTransaction return: ${res}`);
-      }
-    } catch (e) {
-      console.log('e:', e);
+    const res = await axios.post(
+      `${this.apiURL}/transaction/pending/reject`,
+      {
+        address: input.msafeAddress,
+        digest: input.digest,
+        signature: input.signature,
+      },
+      {
+        headers: this.headers(),
+      },
+    );
+    if (res.status !== 200 && res.status !== 201) {
+      throw new Error(`invalid voteForTransaction return: ${res}`);
     }
   }
 
@@ -306,8 +298,8 @@ export class BackendImpl implements IBackend {
     }
   }
 
-  async getAddressBookEntries(pagination?: PaginationOption): Promise<GetAddressBookResult> {
-    const res = await axios.get<GetAddressBookResult>(`${this.apiURL}/address-book`, {
+  async getAddressBookEntries(pagination?: IPageOptions): Promise<IGetAddressBookResult> {
+    const res = await axios.get<IGetAddressBookResult>(`${this.apiURL}/address-book`, {
       headers: this.headers(),
       params: pagination,
     });
@@ -324,7 +316,10 @@ export class BackendImpl implements IBackend {
     }
   }
 
-  async processExecutedTransaction(digest: string) {}
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async processExecutedTransaction(_digest: string) {
+    return undefined;
+  }
 
   private headers(token?: string) {
     return { Authorization: `Bearer ${token || this._token}` };

package/src/backend/interface.ts

@@ -1,36 +1,46 @@
 import {
-  AuthLoginRequest,
-  CreateMSafeAccountInfoRequest,
   HistoryTransaction,
-  MSafeAccountInfo,
-  UserWithOwnedMSafe,
+  IAuthLoginReq,
+  ICreateMSafeReq,
+  IMSafeInfoResp,
+  IPageOptions,
+  IUserInfoResp,
+  UserMSafeStatus,
+  IGetAddressBookResult,
+  IPagedResult,
+  UpdateAddressBookEntry,
+  JWTToken,
 } from '@msafe/sui3-utils';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { TxIntention } from '@/transactions/intention';
-import { GetAddressBookResult, PagedResult, UpdateAddressBookEntry } from '@/types';
-import { JWTToken, PaginationOption } from '@/types/backend';
 import { FutureIntention, PendingTx, ProposeIntention } from '@/types/msafe';
 
 export interface IBackend {
-  authSign(input: AuthLoginRequest): Promise<JWTToken>;
+  authSign(input: IAuthLoginReq): Promise<JWTToken>;
   verifyToken(jwt?: JWTToken): Promise<boolean>;
   setJWTToken(token: JWTToken): void;
 
   getPublicKey(address: string): Promise<PublicKey | undefined>;
   getPublicKeyBatch(addresses: string[]): Promise<(PublicKey | undefined)[]>;
-  getMSafeAccountInfo(msafeAddress: string): Promise<MSafeAccountInfo>;
-  getUserInfo(userAddress: string): Promise<UserWithOwnedMSafe>;
+  getMSafeAccountInfo(msafeAddress: string): Promise<IMSafeInfoResp>;
+  getUserInfo(): Promise<IUserInfoResp>;
+  getOwnedMSafeByStatus(input: {
+    status?: UserMSafeStatus;
+    pagination?: IPageOptions;
+  }): Promise<IPagedResult<IMSafeInfoResp>>;
+  updateMSafeStatus(input: { msafeAddress: string; status: UserMSafeStatus }): Promise<void>;
+
   getPendingTransactions(msafeAddress: string): Promise<PendingTx[]>;
   getHistoryTransactions(
     msafeAddress: string,
-    paginationOption?: PaginationOption,
-  ): Promise<PagedResult<HistoryTransaction>>;
-  getFutureIntentions(msafeAddress: string, paginationOption?: PaginationOption): Promise<PagedResult<FutureIntention>>;
+    paginationOption?: IPageOptions,
+  ): Promise<IPagedResult<HistoryTransaction>>;
+  getFutureIntentions(msafeAddress: string, paginationOption?: IPageOptions): Promise<IPagedResult<FutureIntention>>;
   getCurrentSequenceNumber(msafeAddress: string): Promise<number>;
   getNextSequenceNumber(msafeAddress: string): Promise<number>;
 
-  createMSafeAccount(input: CreateMSafeAccountInfoRequest): Promise<void>;
+  createMSafeAccount(input: ICreateMSafeReq): Promise<void>;
   proposeIntention(input: ProposeIntention): Promise<void>;
   proposePendingTransaction(input: {
     intention: TxIntention;
@@ -55,6 +65,6 @@ export interface IBackend {
   skipNextFailedIntention(input: { msafeAddress: string; userAddress: string }): Promise<void>;
   processExecutedTransaction(digest: string): Promise<void>;
 
-  getAddressBookEntries(pagination?: PaginationOption): Promise<GetAddressBookResult>;
+  getAddressBookEntries(pagination?: IPageOptions): Promise<IGetAddressBookResult>;
   updateAddressBook(input: { updates: UpdateAddressBookEntry[]; signature: SerializedSignature }): Promise<void>;
 }

package/src/core/AddressBookSDK.ts

@@ -1,17 +1,16 @@
-import { MessageHelper } from '@/core/MessageHelper';
+import { IPageOptions, SigningMessageHelper, UpdateAddressBookEntry } from '@msafe/sui3-utils';
+
 import { MSafeGlobals } from '@/globals';
-import { UpdateAddressBookEntry } from '@/types';
-import { PaginationOption } from '@/types/backend';
 
 export class AddressBookSDK {
   constructor(public readonly globals: MSafeGlobals) {}
 
-  async getEntries(pagination?: PaginationOption) {
+  async getEntries(pagination?: IPageOptions) {
     return this.globals.backend.getAddressBookEntries(pagination);
   }
 
   async update(updates: UpdateAddressBookEntry[]) {
-    const messageStr = MessageHelper.updateAddressBookMessage(updates);
+    const messageStr = SigningMessageHelper.updateAddressBookMessage(updates);
     const sig = await this.globals.wallet.signPersonalMessage({ messageStr });
     return this.globals.backend.updateAddressBook({ updates, signature: sig.signature });
   }

package/src/core/CreateHelper.ts

@@ -1,16 +1,9 @@
-import {
-  createAccountCreationMessage,
-  MultisigAccountManager,
-  MultiSigConfig,
-  OwnerWithWeightPKEncoded,
-  validateCreateAccountRequest,
-} from '@msafe/sui3-utils';
+import { MultiSigAccount, MultiSigConfig, PublicKeySerde, SigningMessageHelper } from '@msafe/sui3-utils';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { PublicKeyHelper } from '@/core/PublicKeyHelper';
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
-import { CreateMSafeAccountInfo, CreatePermissionInfo } from '@/types/creation';
-import { PublicKeySerde } from '@/utils/crypto';
+import { CreateMSafeInfo } from '@/types';
 
 export class CreateHelper {
   constructor(
@@ -22,41 +15,38 @@ export class CreateHelper {
     return this.pkHelper.getPublicKeyBatch(addresses);
   }
 
-  async calculateMSafeAddress(info: CreatePermissionInfo) {
+  async calculateMSafeAddress(info: CreateMSafeInfo) {
     const msConfig = await this.reduceCreationInfoToRawConfig(info);
-    const ms = new MultisigAccountManager(msConfig);
+    const ms = new MultiSigAccount(msConfig);
     return ms.address;
   }
 
   // Validate the create info and return the msafe address.
-  async validateCreateInfo(createInfo: CreateMSafeAccountInfo) {
-    const rawConfig = await this.reduceCreationInfoToRawConfig(createInfo);
-    validateCreateAccountRequest(rawConfig);
-
+  async validateCreateInfo(createInfo: CreateMSafeInfo) {
     // Calculate the sui address will check the multi-sig
     return this.calculateMSafeAddress(createInfo);
   }
 
-  async submitMSafeCreation(creationInfo: CreateMSafeAccountInfo) {
+  async submitMSafeCreation(creationInfo: CreateMSafeInfo) {
     const msafeAddress = await this.validateCreateInfo(creationInfo);
 
-    const signingMessage = createAccountCreationMessage(msafeAddress);
+    const signingMessage = SigningMessageHelper.createMSafeMessage(msafeAddress);
     const signature = await this.globals.wallet.signPersonalMessage({ messageStr: signingMessage });
 
     await this.submitToBackend(creationInfo, signature.signature);
     return msafeAddress;
   }
 
-  private async reduceCreationInfoToRawConfig(info: CreatePermissionInfo): Promise<MultiSigConfig> {
-    const publicKeys = await this.getPublicKeyBatch(info.ownerWithWeight.map((oww) => oww.address));
+  private async reduceCreationInfoToRawConfig(info: CreateMSafeInfo): Promise<MultiSigConfig> {
+    const publicKeys = await this.getPublicKeyBatch(info.owners.map((owner) => owner.address));
     publicKeys.forEach((pk, i) => {
       if (pk === undefined) {
-        throw new Error(`Unknown public key for address: ${info.ownerWithWeight[i].address}`);
+        throw new Error(`Unknown public key for address: ${info.owners[i].address}`);
       }
     });
     return {
       threshold: info.threshold,
-      ownersWithWeight: info.ownerWithWeight.map((owner, i) => ({
+      ownersWithWeight: info.owners.map((owner, i) => ({
         publicKey: publicKeys[i] as PublicKey,
         weight: owner.weight,
       })),
@@ -64,18 +54,14 @@ export class CreateHelper {
     };
   }
 
-  private async submitToBackend(createInfo: CreateMSafeAccountInfo, signature: SerializedSignature) {
-    const pks = await this.pkHelper.getPublicKeyBatch(createInfo.ownerWithWeight.map((owner) => owner.address));
+  private async submitToBackend(createInfo: CreateMSafeInfo, signature: SerializedSignature) {
+    const pks = await this.pkHelper.getPublicKeyBatch(createInfo.owners.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,
-        };
-      }),
+      owners: createInfo.owners.map((owner, i) => ({
+        address: owner.address,
+        weight: owner.weight,
+        ...PublicKeySerde.ser(pks[i] as PublicKey),
+      })),
       threshold: createInfo.threshold,
       name: createInfo.name, // name validation is deferred to backend
       description: createInfo.description, // description validation is deferred to backend

package/src/core/InvitationSDK.ts

@@ -0,0 +1,15 @@
+import { IPageOptions, UserMSafeStatus } from '@msafe/sui3-utils';
+
+import { MSafeGlobals } from '@/globals';
+
+export class InvitationSDK {
+  constructor(public readonly globals: MSafeGlobals) {}
+
+  async getMSafeByStatus(status: UserMSafeStatus, pagination?: IPageOptions) {
+    return this.globals.backend.getOwnedMSafeByStatus({ status, pagination });
+  }
+
+  async updateMSafeStatus(msafeAddress: string, status: UserMSafeStatus) {
+    return this.globals.backend.updateMSafeStatus({ msafeAddress, status });
+  }
+}

package/src/core/MSafeAccount.ts

@@ -1,38 +1,51 @@
-import { buildIntentionTransaction, MSafeAccountInfo, MultisigAccountManager } from '@msafe/sui3-utils';
+import {
+  buildIntentionTransaction,
+  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 { 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[]> {
@@ -81,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;
   }
@@ -105,7 +118,7 @@ export class MSafeAccount {
     intention: TxIntention;
     sequenceNumber: number;
   }) {
-    const message = MessageHelper.proposeIntentionMessage({
+    const message = SigningMessageHelper.proposeIntentionMessage({
       msafeAddress: this.address,
       intention: input.intention,
       sn: input.sequenceNumber,
@@ -229,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,
@@ -245,7 +258,7 @@ export class MSafeAccount {
   }
 
   get address() {
-    return this.info.address;
+    return this.multiSig.address;
   }
 
   private get backend() {