@msafe/sui3-sdk 0.0.21 → 0.0.23

package/src/backend/BackendImpl.ts

@@ -31,9 +31,10 @@ import {
 } from '@msafe/sui3-utils';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 import { PublicKey } from '@mysten/sui.js/src/cryptography';
-import axios from 'axios';
+import axios, { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 
 import { IBackend } from '@/backend/interface';
+import { addPrefix } from '@/utils';
 
 export class BackendImpl implements IBackend {
   private _token: JWTToken;
@@ -41,18 +42,15 @@ export class BackendImpl implements IBackend {
   constructor(private readonly apiURL: string) {}
 
   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}`);
-    }
+    const res = await this.post<IAuthLoginResp>(`/auth/login`, input);
+
     this._token = res.data.accessToken;
     return this._token;
   }
 
   async verifyToken(jwt: JWTToken): Promise<boolean> {
     try {
-      const res = await axios.get(`${this.apiURL}/auth`, { headers: this.headers(jwt) });
+      const res = await this.get(`/auth`, { headers: this.headers(jwt) });
       return res.status === 200;
     } catch (_) {
       return false;
@@ -71,15 +69,10 @@ export class BackendImpl implements IBackend {
     const query: IGetPublicKeyBatchQuery = {
       userAddressList: addresses,
     };
-    const res = await axios.get<IGetPublicKeyBatchResp>(`${this.apiURL}/user/public-keys`, {
+    const res = await this.get<IGetPublicKeyBatchResp>(`/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,
     );
@@ -89,25 +82,17 @@ export class BackendImpl implements IBackend {
     const q: IGetMSafeQuery = {
       msafeAddress,
     };
-    const res = await axios.get<IMSafeInfoResp>(`${this.apiURL}/msafe`, {
+    const res = await this.get<IMSafeInfoResp>(`/msafe`, {
       params: q,
       headers: this.headers(),
     });
-    // TODO unify response struct
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
     return BackendImpl.toMSafeConfig(res.data);
   }
 
   async getUserInfo(): Promise<IUserInfoResp> {
-    const userRes = await axios.get<IUserInfoResp>(`${this.apiURL}/user`, {
+    const userRes = await this.get<IUserInfoResp>(`/user`, {
       headers: this.headers(),
     });
-    // TODO unify response struct
-    if (userRes.status !== 200 && userRes.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${userRes}`);
-    }
     return userRes.data;
   }
 
@@ -124,13 +109,10 @@ export class BackendImpl implements IBackend {
           }
         : {}),
     };
-    const res = await axios.get<IPagedResult<IMSafeInfoResp>>(`${this.apiURL}/msafe/owned`, {
+    const res = await this.get<IPagedResult<IMSafeInfoResp>>(`/msafe/owned`, {
       params: q,
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getOwnedMSafeByStatus return: ${res}`);
-    }
     return {
       data: res.data.data.map(BackendImpl.toMSafeConfig),
       meta: res.data.meta,
@@ -139,85 +121,61 @@ export class BackendImpl implements IBackend {
 
   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}`);
-    }
+    await this.post(`/msafe/status`, p, { headers: this.headers() });
   }
 
   async getPendingTransactions(input: IGetPendingTransactionRequest): Promise<GetPendingTransactionResponse> {
-    const res = await axios.get<GetPendingTransactionResponse>(`${this.apiURL}/transaction/pending`, {
+    const res = await this.get<GetPendingTransactionResponse>(`/transaction/pending`, {
       params: input,
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getPublicKeyBatch return: ${res}`);
-    }
     return res.data;
   }
 
   async getHistoryTransactions(input: IGetHistoryTransactionsRequest): Promise<GetHistoryTransactionsResponse> {
-    const res = await axios.get<GetHistoryTransactionsResponse>(`${this.apiURL}/transaction/history`, {
+    const res = await this.get<GetHistoryTransactionsResponse>(`/transaction/history`, {
       params: input,
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
     return res.data;
   }
 
   async getFutureIntentions(input: IGetIntentionsRequest): Promise<GetTransactionIntentionsResponse> {
-    const res = await axios.get<GetTransactionIntentionsResponse>(`${this.apiURL}/transaction/intention`, {
+    const res = await this.get<GetTransactionIntentionsResponse>(`/transaction/intention`, {
       params: input,
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
     return res.data;
   }
 
   async getCurrentSequenceNumber(address: string): Promise<number> {
-    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/current`, {
+    const res = await this.get<number>(`/transaction/sn/current`, {
       params: {
         msafeAddress: address,
       },
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getCurrentSequenceNumber return: ${res}`);
-    }
     return res.data;
   }
 
   async getNextSequenceNumber(address: string): Promise<number> {
-    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/next`, {
+    const res = await this.get<number>(`/transaction/sn/next`, {
       params: {
         msafeAddress: address,
       },
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid getNextSequenceNumber return: ${res}`);
-    }
     return res.data;
   }
 
   async createMSafeAccount(input: ICreateMSafeReq): Promise<void> {
-    const res = await axios.post(`${this.apiURL}/msafe/create`, input, {
+    await this.post(`/msafe/create`, input, {
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid createMSafeAccount return: ${res}`);
-    }
   }
 
   async proposeIntention(input: IProposeIntentionRequest): Promise<void> {
-    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}`);
-    }
+    await this.post(`/transaction/intention`, input, { headers: this.headers() });
   }
 
   // TODO later
@@ -233,58 +191,35 @@ export class BackendImpl implements IBackend {
   }
 
   async rejectCurrentTx(input: IVoteTransactionRequest) {
-    const res = await axios.post(`${this.apiURL}/transaction/pending/reject`, input, {
+    await this.post(`/transaction/pending/reject`, input, {
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid voteForTransaction return: ${res}`);
-    }
   }
 
   async voteForTransaction(input: IVoteTransactionRequest) {
-    const res = await axios.post(`${this.apiURL}/transaction/pending/vote`, input, {
+    await this.post(`/transaction/pending/vote`, input, {
       headers: this.headers(),
     });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid voteForTransaction return: ${res}`);
-    }
   }
 
   async buildNextIntentionAndAddToPending(input: IBuildTransactionRequest) {
-    const res = await axios.post(`${this.apiURL}/transaction/pending/build`, input, { headers: this.headers() });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid buildNextIntentionAndAddToPending return: ${res}`);
-    }
+    await this.post(`/transaction/pending/build`, input, { headers: this.headers() });
   }
 
   async skipNextFailedIntention(input: ISkipIntentionRequest) {
-    const res = await axios.post(`${this.apiURL}/transaction/pending/skip`, input, { headers: this.headers() });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid skipNextFailedIntention return: ${res}`);
-    }
+    await this.post(`/transaction/pending/skip`, input, { headers: this.headers() });
   }
 
   async getAddressBookEntries(pagination?: IPageOptions): Promise<IGetAddressBookResult> {
-    const res = await axios.get<IGetAddressBookResult>(`${this.apiURL}/address-book`, {
+    const res = await this.get<IGetAddressBookResult>(`/address-book`, {
       headers: this.headers(),
       params: pagination,
     });
-    if (res.status !== 200) {
-      throw new Error(`Invalid address-book return: ${res}`);
-    }
     return res.data;
   }
 
   async updateAddressBook(input: { updates: UpdateAddressBookEntry[]; signature: SerializedSignature }) {
-    const res = await axios.post(`${this.apiURL}/address-book`, input, { headers: this.headers() });
-    if (res.status !== 200 && res.status !== 201) {
-      throw new Error(`invalid updateAddressBook return: ${res}`);
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async processExecutedTransaction(_digest: string) {
-    return undefined;
+    await this.post(`/address-book`, input, { headers: this.headers() });
   }
 
   private headers(token?: string) {
@@ -304,4 +239,69 @@ export class BackendImpl implements IBackend {
       })),
     };
   }
+
+  private async get<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R> {
+    const fullUrl = this.getFullUrl(url);
+    try {
+      return await axios.get<T, R, D>(fullUrl, config);
+    } catch (e: any) {
+      throw BackendError.fromError(e) ?? e;
+    }
+  }
+
+  private async post<T = any, R = AxiosResponse<T>, D = any>(
+    url: string,
+    data?: D,
+    config?: AxiosRequestConfig<D>,
+  ): Promise<R> {
+    const fullUrl = this.getFullUrl(url);
+    try {
+      return await axios.post<T, R, D>(fullUrl, data, config);
+    } catch (e: unknown) {
+      throw BackendError.fromError(e) ?? e;
+    }
+  }
+
+  private getFullUrl(url: string) {
+    return url.startsWith(this.apiURL) ? url : `${this.apiURL}${addPrefix(url, '/')}`;
+  }
+}
+
+export class BackendError extends Error {
+  constructor(public readonly e: AxiosError) {
+    super();
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  public readonly name: 'Backend';
+
+  static fromError(e: unknown) {
+    if (axios.isAxiosError(e) && e?.response?.data && 'message' in e.response.data) {
+      return new BackendError(e as AxiosError);
+    }
+    return undefined;
+  }
+
+  get status() {
+    return this.e.response?.status ?? undefined;
+  }
+
+  get message(): string {
+    return `Request to ${this.endpoint} failed: ${this.status} ${this.respMessage() ?? 'Unknown resp'}`;
+  }
+
+  private respMessage() {
+    if (!this.e.response?.data) {
+      return undefined;
+    }
+    return (this.e.response?.data as any).message ?? undefined;
+  }
+
+  get endpoint() {
+    return this.e.config?.url ?? '';
+  }
+
+  toString() {
+    return this.message;
+  }
 }

package/src/backend/interface.ts

@@ -57,7 +57,6 @@ export interface IBackend {
   voteForTransaction(input: IVoteTransactionRequest): Promise<void>;
   buildNextIntentionAndAddToPending(input: IBuildTransactionRequest): Promise<void>;
   skipNextFailedIntention(input: ISkipIntentionRequest): Promise<void>;
-  processExecutedTransaction(digest: string): Promise<void>;
 
   getAddressBookEntries(pagination?: IPageOptions): Promise<IGetAddressBookResult>;
   updateAddressBook(input: { updates: UpdateAddressBookEntry[]; signature: SerializedSignature }): Promise<void>;

package/src/core/MSafeAccount.ts

@@ -11,6 +11,7 @@ import {
   TxIntention,
   buildObjectTransferTxb,
   buildRejectTxb,
+  isSameAddress,
 } from '@msafe/sui3-utils';
 import { SuiObjectData } from '@mysten/sui.js/client';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
@@ -76,6 +77,7 @@ export class MSafeAccount {
     return getAllOwnedObjects(this.suiClient, this.address, filterCoinObjectOptions);
   }
 
+  // TODO: Calculate the votes
   async pendingTransaction(): Promise<PendingTx | undefined> {
     const res = await this.backend.getPendingTransactions({ msafeAddress: this.address });
     if (!res.pending) {
@@ -98,13 +100,16 @@ export class MSafeAccount {
       sequenceNumber: pendingTx.sequenceNumber,
       payload: pendingTx.payload,
       votes: pendingTx.votes,
+      approvalWeight: this.calculateWeightFromVotes(pendingTx.votes),
       msafeAddress: pendingTx.msafeAddress,
       rejectDigest: rejectPending?.digest ?? '',
       rejectPayload: rejectPending?.payload ?? '',
       rejectVotes: rejectPending?.votes ?? [],
+      rejectWeight: this.calculateWeightFromVotes(rejectPending?.votes ?? []),
     };
   }
 
+  // TODO: Calculate the votes.
   async historyTransaction(pagination?: Pagination) {
     return this.backend.getHistoryTransactions({
       msafeAddress: this.address,
@@ -241,28 +246,24 @@ export class MSafeAccount {
     };
   }
 
-  async executePendingTx(pending: PendingTx) {
-    let gotSigs: Map<string, string>;
-    let payload: string;
-    if (pending.votes.length >= this.info.threshold) {
-      gotSigs = new Map(pending.votes.map((vote) => [vote.userAddress, vote.signature]));
-      payload = pending.payload;
-    } else if (pending.rejectVotes && pending.rejectPayload && pending.rejectVotes?.length >= this.info.threshold) {
-      gotSigs = new Map(pending.rejectVotes.map((vote) => [vote.userAddress, vote.signature]));
-      payload = pending.rejectPayload;
-    } else {
-      throw new Error('Not enough signatures');
+  async executePendingTx(pending: PendingTx, isRejectTx: boolean = false) {
+    const votes = isRejectTx ? pending.rejectVotes : pending.votes;
+    const payload = isRejectTx ? pending.rejectPayload : pending.payload;
+
+    if (this.calculateWeightFromVotes(votes) < this.info.threshold) {
+      throw new Error('Not enough signature');
     }
 
-    const sigs: SerializedSignature[] = [];
+    const sortedSigs: SerializedSignature[] = [];
+    const gotSigs = new Map(votes.map((vote) => [vote.userAddress, vote.signature]));
     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);
+        sortedSigs.push(signature);
       }
     }
-    const multiSignature = this.multiSig.combinePartialSignatures(sigs);
+    const multiSignature = this.multiSig.combinePartialSignatures(sortedSigs);
     return this.suiClient.executeTransactionBlock({
       transactionBlock: HexToUint8Array(payload),
       signature: multiSignature,
@@ -270,6 +271,22 @@ export class MSafeAccount {
     });
   }
 
+  private calculateWeightFromVotes(votes: { userAddress: string }[]) {
+    return this.calculateWeight(votes.map((vote) => vote.userAddress));
+  }
+
+  private calculateWeight(addressList: string[]) {
+    let gotWeight = 0;
+
+    for (let i = 0; i < addressList.length; i++) {
+      const found = this.info.owners.find((owner) => isSameAddress(owner.address, addressList[i]));
+      if (found) {
+        gotWeight += found.weight;
+      }
+    }
+    return gotWeight;
+  }
+
   get address() {
     return this.multiSig.address;
   }

package/src/types/msafe.ts

@@ -12,9 +12,11 @@ export interface PendingTx {
   creator: string;
   createdAt: Date;
   sequenceNumber: number;
+  approvalWeight: number;
   votes: PendingVote[];
   rejectDigest: string;
   rejectPayload: string;
+  rejectWeight: number;
   rejectVotes: PendingVote[];
 }
 

package/src/utils/format.ts

@@ -23,3 +23,10 @@ export class Formatter {
     return Coin.isCoin(struct);
   }
 }
+
+export function addPrefix(s: string, prefix: string) {
+  if (s.startsWith(prefix)) {
+    return s;
+  }
+  return prefix + s;
+}