@msafe/sui3-sdk 0.0.15-pre-3e855d9.0 → 0.0.16

package/src/backend/BackendImpl.ts

@@ -1,23 +1,32 @@
 import {
-  HistoryTransaction,
+  GetHistoryTransactionsResponse,
+  GetPendingTransactionResponse,
+  GetTransactionIntentionsResponse,
   IAuthLoginReq,
   IAuthLoginResp,
+  IBuildTransactionRequest,
   ICreateMSafeReq,
+  IGetAddressBookResult,
+  IGetHistoryTransactionsRequest,
+  IGetIntentionsRequest,
   IGetMSafeQuery,
   IGetMSafesQuery,
+  IGetPendingTransactionRequest,
   IGetPublicKeyBatchQuery,
   IGetPublicKeyBatchResp,
+  IMSafeConfig,
   IMSafeInfoResp,
-  IPagedResult,
   IPageOptions,
+  IPagedResult,
+  IProposeIntentionRequest,
+  ISkipIntentionRequest,
   IUpdateMSafeStatusReq,
   IUserInfoResp,
+  IVoteTransactionRequest,
   JWTToken,
   PublicKeySerde,
-  UserMSafeStatus,
-  IGetAddressBookResult,
   UpdateAddressBookEntry,
-  IMSafeConfig,
+  UserMSafeStatus,
 } from '@msafe/sui3-utils';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 import { PublicKey } from '@mysten/sui.js/src/cryptography';
@@ -25,7 +34,6 @@ import axios from 'axios';
 
 import { IBackend } from '@/backend/interface';
 import { TxIntention } from '@/transactions/intention';
-import { FutureIntention, PendingTx, ProposeIntention } from '@/types/msafe';
 
 export class BackendImpl implements IBackend {
   private _token: JWTToken;
@@ -137,8 +145,9 @@ export class BackendImpl implements IBackend {
     }
   }
 
-  async getPendingTransactions(msafeAddress: string): Promise<PendingTx[]> {
-    const res = await axios.get<PendingTx[]>(`${this.apiURL}/transaction/pending/${msafeAddress}`, {
+  async getPendingTransactions(input: IGetPendingTransactionRequest): Promise<GetPendingTransactionResponse> {
+    const res = await axios.get<GetPendingTransactionResponse>(`${this.apiURL}/transaction/pending`, {
+      params: input,
       headers: this.headers(),
     });
     if (res.status !== 200 && res.status !== 201) {
@@ -147,35 +156,20 @@ export class BackendImpl implements IBackend {
     return res.data;
   }
 
-  async getHistoryTransactions(
-    msafeAddress: string,
-    paginationOption?: IPageOptions,
-  ): Promise<IPagedResult<HistoryTransaction>> {
-    const res = await axios.get<IPagedResult<HistoryTransaction>>(
-      `${this.apiURL}/transaction/history?address=${msafeAddress}`,
-      {
-        params: {
-          page: paginationOption?.page,
-          limit: paginationOption?.limit,
-        },
-        headers: this.headers(),
-      },
-    );
+  async getHistoryTransactions(input: IGetHistoryTransactionsRequest): Promise<GetHistoryTransactionsResponse> {
+    const res = await axios.get<GetHistoryTransactionsResponse>(`${this.apiURL}/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(
-    msafeAddress: string,
-    paginationOption?: IPageOptions,
-  ): Promise<IPagedResult<FutureIntention>> {
-    const res = await axios.get<IPagedResult<FutureIntention>>(`${this.apiURL}/transaction/intention/${msafeAddress}`, {
-      params: {
-        page: paginationOption?.page,
-        limit: paginationOption?.limit,
-      },
+  async getFutureIntentions(input: IGetIntentionsRequest): Promise<GetTransactionIntentionsResponse> {
+    const res = await axios.get<GetTransactionIntentionsResponse>(`${this.apiURL}/transaction/intention`, {
+      params: input,
       headers: this.headers(),
     });
     if (res.status !== 200 && res.status !== 201) {
@@ -184,8 +178,11 @@ export class BackendImpl implements IBackend {
     return res.data;
   }
 
-  async getCurrentSequenceNumber(msafeAddress: string): Promise<number> {
-    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/current/${msafeAddress}`, {
+  async getCurrentSequenceNumber(address: string): Promise<number> {
+    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/current`, {
+      params: {
+        msafeAddress: address,
+      },
       headers: this.headers(),
     });
     if (res.status !== 200 && res.status !== 201) {
@@ -194,8 +191,11 @@ export class BackendImpl implements IBackend {
     return res.data;
   }
 
-  async getNextSequenceNumber(msafeAddress: string): Promise<number> {
-    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/next/${msafeAddress}`, {
+  async getNextSequenceNumber(address: string): Promise<number> {
+    const res = await axios.get<number>(`${this.apiURL}/transaction/sn/next`, {
+      params: {
+        msafeAddress: address,
+      },
       headers: this.headers(),
     });
     if (res.status !== 200 && res.status !== 201) {
@@ -213,7 +213,7 @@ export class BackendImpl implements IBackend {
     }
   }
 
-  async proposeIntention(input: ProposeIntention): Promise<void> {
+  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}`);
@@ -232,71 +232,33 @@ export class BackendImpl implements IBackend {
     return undefined;
   }
 
-  async rejectCurrentTx(input: {
-    userAddress: string;
-    msafeAddress: string;
-    digest: string;
-    signature: SerializedSignature;
-  }) {
-    const res = await axios.post(
-      `${this.apiURL}/transaction/pending/reject`,
-      {
-        address: input.msafeAddress,
-        digest: input.digest,
-        signature: input.signature,
-      },
-      {
-        headers: this.headers(),
-      },
-    );
+  async rejectCurrentTx(input: IVoteTransactionRequest) {
+    const res = await axios.post(`${this.apiURL}/transaction/pending/reject`, input, {
+      headers: this.headers(),
+    });
     if (res.status !== 200 && res.status !== 201) {
       throw new Error(`invalid voteForTransaction return: ${res}`);
     }
   }
 
-  async voteForTransaction(input: {
-    txDigest: string;
-    msafeAddress: string;
-    userAddress: string;
-    signature: SerializedSignature;
-  }) {
-    const res = await axios.post(
-      `${this.apiURL}/transaction/pending/vote`,
-      {
-        address: input.msafeAddress,
-        digest: input.txDigest,
-        signature: input.signature,
-      },
-      {
-        headers: this.headers(),
-      },
-    );
+  async voteForTransaction(input: IVoteTransactionRequest) {
+    const res = await axios.post(`${this.apiURL}/transaction/pending/vote`, input, {
+      headers: this.headers(),
+    });
     if (res.status !== 200 && res.status !== 201) {
       throw new Error(`invalid voteForTransaction return: ${res}`);
     }
   }
 
-  async buildNextIntentionAndAddToPending(input: { msafeAddress: string }) {
-    const res = await axios.post(
-      `${this.apiURL}/transaction/pending/build`,
-      {
-        address: input.msafeAddress,
-      },
-      { headers: this.headers() },
-    );
+  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}`);
     }
   }
 
-  async skipNextFailedIntention(input: { msafeAddress: string; userAddress: string }) {
-    const res = await axios.post(
-      `${this.apiURL}/transaction/pending/skip`,
-      {
-        msafeAddress: input.msafeAddress,
-      },
-      { 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}`);
     }

package/src/backend/interface.ts

@@ -1,20 +1,28 @@
 import {
-  HistoryTransaction,
+  GetHistoryTransactionsResponse,
+  GetPendingTransactionResponse,
+  GetTransactionIntentionsResponse,
   IAuthLoginReq,
+  IBuildTransactionRequest,
   ICreateMSafeReq,
-  IPageOptions,
-  IUserInfoResp,
-  UserMSafeStatus,
   IGetAddressBookResult,
+  IGetHistoryTransactionsRequest,
+  IGetIntentionsRequest,
+  IGetPendingTransactionRequest,
+  IMSafeConfig,
+  IPageOptions,
   IPagedResult,
-  UpdateAddressBookEntry,
+  IProposeIntentionRequest,
+  ISkipIntentionRequest,
+  IUserInfoResp,
+  IVoteTransactionRequest,
   JWTToken,
-  IMSafeConfig,
+  UpdateAddressBookEntry,
+  UserMSafeStatus,
 } from '@msafe/sui3-utils';
 import { PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { TxIntention } from '@/transactions/intention';
-import { FutureIntention, PendingTx, ProposeIntention } from '@/types/msafe';
 
 export interface IBackend {
   authSign(input: IAuthLoginReq): Promise<JWTToken>;
@@ -31,17 +39,14 @@ export interface IBackend {
   }): Promise<IPagedResult<IMSafeConfig>>;
   updateMSafeStatus(input: { msafeAddress: string; status: UserMSafeStatus }): Promise<void>;
 
-  getPendingTransactions(msafeAddress: string): Promise<PendingTx[]>;
-  getHistoryTransactions(
-    msafeAddress: string,
-    paginationOption?: IPageOptions,
-  ): Promise<IPagedResult<HistoryTransaction>>;
-  getFutureIntentions(msafeAddress: string, paginationOption?: IPageOptions): Promise<IPagedResult<FutureIntention>>;
-  getCurrentSequenceNumber(msafeAddress: string): Promise<number>;
-  getNextSequenceNumber(msafeAddress: string): Promise<number>;
+  getPendingTransactions(input: IGetPendingTransactionRequest): Promise<GetPendingTransactionResponse>;
+  getHistoryTransactions(input: IGetHistoryTransactionsRequest): Promise<GetHistoryTransactionsResponse>;
+  getFutureIntentions(input: IGetIntentionsRequest): Promise<GetTransactionIntentionsResponse>;
+  getCurrentSequenceNumber(address: string): Promise<number>;
+  getNextSequenceNumber(address: string): Promise<number>;
 
   createMSafeAccount(input: ICreateMSafeReq): Promise<void>;
-  proposeIntention(input: ProposeIntention): Promise<void>;
+  proposeIntention(input: IProposeIntentionRequest): Promise<void>;
   proposePendingTransaction(input: {
     intention: TxIntention;
     userAddress: string;
@@ -49,20 +54,10 @@ export interface IBackend {
     digest: string;
     signature: SerializedSignature;
   }): Promise<void>;
-  rejectCurrentTx(input: {
-    userAddress: string;
-    msafeAddress: string;
-    digest: string;
-    signature: SerializedSignature;
-  }): Promise<void>;
-  voteForTransaction(input: {
-    txDigest: string;
-    msafeAddress: string;
-    userAddress: string;
-    signature: SerializedSignature;
-  }): Promise<void>;
-  buildNextIntentionAndAddToPending(input: { msafeAddress: string }): Promise<void>;
-  skipNextFailedIntention(input: { msafeAddress: string; userAddress: string }): Promise<void>;
+  rejectCurrentTx(input: IVoteTransactionRequest): Promise<void>;
+  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>;

package/src/core/MSafeAccount.ts

@@ -1,19 +1,24 @@
 import {
-  buildIntentionTransaction,
+  CoinTransferIntention,
   IMSafeConfig,
-  IPageOptions,
+  IProposeIntentionRequest,
   MultiSigAccount,
+  ObjectTransferIntention,
   SigningMessageHelper,
+  TransactionDefaultApplication,
+  TransactionSubTypes,
+  TransactionType,
 } 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 { TransactionBlock } from '@mysten/sui.js/transactions';
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
 import { IntentionHelper, TxIntention } from '@/transactions/intention';
 import { OwnedCoin } from '@/types/assets';
-import { PendingTx, SimulationResult } from '@/types/msafe';
+import { Pagination, PendingTx, SimulationResult } from '@/types/msafe';
 import { CoinHelper } from '@/utils';
 import { HexToUint8Array } from '@/utils/buffer';
 import { BatchObjectOptions, getAllOwnedObjects } from '@/utils/iter/object';
@@ -70,32 +75,40 @@ export class MSafeAccount {
   }
 
   async pendingTransaction(): Promise<PendingTx | undefined> {
-    const pendings = await this.backend.getPendingTransactions(this.address);
-    if (pendings.length > 2) {
-      throw new Error(`invalid backend getPendingTransactions resp, length should not > 2: ${pendings}`);
-    }
-    if (pendings.length === 0) {
+    const res = await this.backend.getPendingTransactions({ msafeAddress: this.address });
+    if (!res.pending) {
       return undefined;
     }
 
-    const pendingTx = pendings.find((tx) => !tx.isRejectTx);
-    const rejectPending = pendings.find((tx) => tx.isRejectTx);
+    const pendingTx = res.pending;
+    const rejectPending = res.reject;
 
     return {
-      ...pendingTx!,
+      txType: TransactionType.Assets,
+      txSubType: TransactionSubTypes.assets.coin.send,
+      createdAt: pendingTx.createdAt as Date,
+      creator: pendingTx.creator,
+      digest: pendingTx.digest,
+      intention: pendingTx.intention,
+      sequenceNumber: pendingTx.sequenceNumber,
+      payload: pendingTx.payload,
+      votes: pendingTx.votes,
+      msafeAddress: pendingTx.msafeAddress,
       rejectDigest: rejectPending?.digest ?? '',
       rejectPayload: rejectPending?.payload ?? '',
       rejectVotes: rejectPending?.votes ?? [],
     };
   }
 
-  async historyTransaction(paginationOption?: IPageOptions) {
-    return this.backend.getHistoryTransactions(this.address, paginationOption);
+  async historyTransaction(pagination?: Pagination) {
+    return this.backend.getHistoryTransactions({
+      msafeAddress: this.address,
+      ...pagination,
+    });
   }
 
-  async futureIntentions(paginationOption?: IPageOptions) {
-    const paginatedIntentions = await this.backend.getFutureIntentions(this.address, paginationOption);
-    return paginatedIntentions.data;
+  async futureIntentions(pagination?: Pagination) {
+    return this.backend.getFutureIntentions({ msafeAddress: this.address, ...pagination });
   }
 
   async currentSequenceNumber() {
@@ -106,13 +119,7 @@ export class MSafeAccount {
     return this.backend.getNextSequenceNumber(this.address);
   }
 
-  async proposeIntention(input: {
-    application: string;
-    txType: string;
-    txSubType: string;
-    intention: TxIntention;
-    sequenceNumber: number;
-  }) {
+  async proposeIntention(input: Omit<IProposeIntentionRequest, 'signature' | 'msafeAddress'>) {
     const message = SigningMessageHelper.proposeIntentionMessage({
       msafeAddress: this.address,
       intention: input.intention,
@@ -122,22 +129,41 @@ export class MSafeAccount {
       messageStr: message,
     });
 
-    // TODO get application from common utils
     await this.backend.proposeIntention({
       ...input,
       msafeAddress: this.address,
-      userAddress: await this.userAddress(),
       signature: signature.signature,
     });
   }
 
+  async proposeCoinTransferIntention(intention: CoinTransferIntention) {
+    const sn = await this.nextSequenceNumber();
+    return this.proposeIntention({
+      application: TransactionDefaultApplication,
+      txType: TransactionType.Assets,
+      txSubType: TransactionSubTypes.assets.coin.send,
+      sequenceNumber: sn,
+      intention,
+    });
+  }
+
+  async proposeObjectTransferIntention(intention: ObjectTransferIntention) {
+    const sn = await this.nextSequenceNumber();
+    return this.proposeIntention({
+      application: TransactionDefaultApplication,
+      txType: TransactionType.Assets,
+      txSubType: TransactionSubTypes.assets.object.send,
+      sequenceNumber: sn,
+      intention,
+    });
+  }
+
   async voteForTransaction(digest: string, payload: string) {
     const payloadBytes = HexToUint8Array(payload);
     const signature = await this.wallet.signTransactionBlock({ transactionBlock: payloadBytes });
     return this.backend.voteForTransaction({
       msafeAddress: this.address,
-      userAddress: await this.userAddress(),
-      txDigest: digest,
+      digest,
       signature: signature.signature,
     });
   }
@@ -162,21 +188,13 @@ export class MSafeAccount {
     });
   }
 
-  async rejectCurrentTx(pending?: PendingTx) {
-    let payloadToReject: string;
-    if (pending) {
-      if (pending.isRejectTx) {
-        throw new Error('Pending not reject transaction');
-      }
-      payloadToReject = pending.payload;
-    } else {
-      const pendingTx = await this.pendingTransaction();
-      if (!pendingTx || pendingTx.rejectDigest !== '') {
-        throw new Error('Already rejected');
-      }
-
-      payloadToReject = pendingTx.payload;
+  async rejectCurrentTx() {
+    const pendingTx = await this.pendingTransaction();
+    if (!pendingTx || pendingTx.rejectDigest !== '') {
+      throw new Error('Already rejected');
     }
+
+    const payloadToReject = pendingTx.payload;
     const rejectTxb = await IntentionHelper.buildRejectTransaction({
       msafeAddress: this.address,
       payloadToReject,
@@ -186,7 +204,6 @@ export class MSafeAccount {
     const signature = await this.wallet.signTransactionBlock({ transactionBlock: payload });
     return this.backend.rejectCurrentTx({
       msafeAddress: this.address,
-      userAddress: await this.userAddress(),
       digest,
       signature: signature.signature,
     });
@@ -197,11 +214,13 @@ export class MSafeAccount {
   }
 
   async skipNextFailedIntention() {
-    return this.backend.skipNextFailedIntention({ msafeAddress: this.address, userAddress: await this.userAddress() });
+    return this.backend.skipNextFailedIntention({ msafeAddress: this.address });
   }
 
-  async simulateIntention(intention: TxIntention): Promise<SimulationResult> {
-    const txb = await buildIntentionTransaction(this.suiClient, intention, this.address);
+  async simulateIntention(intention: any): Promise<SimulationResult> {
+    // Todo, move to API
+    const txb = new TransactionBlock(); // await buildIntentionTransaction(this.suiClient, intention, this.address);
+    txb.setSender(this.address);
     if (!txb.blockData.gasConfig.price) {
       const refGas = await this.suiClient.getReferenceGasPrice();
       txb.setGasPrice(refGas);

package/src/types/msafe.ts

@@ -1,13 +1,15 @@
-import { GasCostSummary, DryRunTransactionBlockResponse } from '@mysten/sui.js/client';
+import { TransactionType } from '@msafe/sui3-utils';
+import { DryRunTransactionBlockResponse, GasCostSummary } from '@mysten/sui.js/client';
 import { SerializedSignature } from '@mysten/sui.js/cryptography';
 
 import { TxIntention } from '@/transactions/intention';
 
 export interface PendingTx {
+  txType: TransactionType;
+  txSubType: string;
   digest: string;
   payload: string;
   msafeAddress: string;
-  isRejectTx: boolean;
   intention: TxIntention;
   creator: string;
   createdAt: Date;
@@ -86,3 +88,8 @@ export interface SimulationResult {
   gasUsed: GasCostSummary;
   dryRunResult: DryRunTransactionBlockResponse;
 }
+
+export interface Pagination {
+  page?: string;
+  limit?: string;
+}