@msafe/sui3-sdk 0.0.90 → 1.0.4

package/src/simulate/simulator.ts

@@ -1,17 +1,30 @@
-import { GasCostSummary } from '@mysten/sui.js/client';
-import { TransactionBlock } from '@mysten/sui.js/transactions';
+import type { SuiClientTypes } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
 
 // Default to 120% o the reference gas price
 import { MSafeGlobals } from '@/globals/MSafeGlobals';
-import { SimulationResult } from '@/types';
+import type { GasObjectReference, SimulationResult, SimulateDryRunResponse } from '@/types';
 
 const GAS_SAFE_OVERHEAD = 1000n;
 
+function formatExecutionError(error: SuiClientTypes.ExecutionError): string {
+  return error.message;
+}
+
+function gasObjectToReference(gas: SuiClientTypes.ChangedObject | null | undefined): GasObjectReference {
+  if (!gas?.objectId) {
+    throw new Error('Gas object missing from simulation effects');
+  }
+  const version = gas.outputVersion ?? gas.inputVersion ?? '0';
+  const digest = gas.outputDigest ?? gas.inputDigest ?? '';
+  return { objectId: gas.objectId, version, digest };
+}
+
 export class Simulator {
   constructor(private globals: MSafeGlobals) {}
 
-  public async simulate(input: { txb: TransactionBlock; sender: string }): Promise<SimulationResult> {
-    const tx = this.copyTransactionBlock(input.txb);
+  public async simulate(input: { txb: Transaction; sender: string }): Promise<SimulationResult> {
+    const tx = this.copyTransaction(input.txb);
 
     const { suiClient } = this.globals;
 
@@ -19,36 +32,66 @@ export class Simulator {
 
     tx.setGasPrice(gasPrice);
 
-    const inspectResult = await suiClient.dryRunTransactionBlock({
-      transactionBlock: await tx.build({ client: suiClient }),
-    });
-    const success = inspectResult.effects.status.status === 'success';
+    let built: Uint8Array;
+    try {
+      built = await tx.build({ client: suiClient });
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      return {
+        success: false,
+        gasPrice,
+        simulationError: message,
+      };
+    }
+
+    let inspectResult: SimulateDryRunResponse;
+    try {
+      inspectResult = await suiClient.simulateTransaction({
+        transaction: built,
+        include: { effects: true },
+      });
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      return {
+        success: false,
+        gasPrice,
+        simulationError: message,
+      };
+    }
+    const txRow = inspectResult.Transaction ?? inspectResult.FailedTransaction;
+    const { effects } = txRow;
+    if (!effects) {
+      throw new Error('simulateTransaction did not return effects');
+    }
+    const success = effects.status.success === true;
 
     if (!success) {
+      const err = effects.status.success === false ? effects.status.error : null;
       return {
         success,
         gasPrice,
         response: inspectResult,
-        simulationError: inspectResult.effects.status.error!,
+        simulationError: err ? formatExecutionError(err) : 'Simulation failed',
       };
     }
-    const gasBudget = this.toGasBudget(inspectResult.effects.gasUsed, gasPrice);
+    const gasBudget = this.toGasBudget(effects.gasUsed, gasPrice);
 
     return {
       success,
       gasPrice,
-      gasObject: inspectResult.effects.gasObject.reference,
-      gasUsed: inspectResult.effects.gasUsed,
+      gasObject: gasObjectToReference(effects.gasObject),
+      gasUsed: effects.gasUsed,
       gasBudget,
       response: inspectResult,
     };
   }
 
   private async getGasPrice() {
-    return this.globals.suiClient.getReferenceGasPrice();
+    const { referenceGasPrice } = await this.globals.suiClient.getReferenceGasPrice();
+    return BigInt(referenceGasPrice);
   }
 
-  private toGasBudget(gasUsed: GasCostSummary, gasPrice: bigint) {
+  private toGasBudget(gasUsed: SuiClientTypes.GasCostSummary, gasPrice: bigint) {
     const { computationCost, storageCost, storageRebate } = gasUsed;
     const safeOverhead = GAS_SAFE_OVERHEAD * gasPrice;
 
@@ -61,7 +104,7 @@ export class Simulator {
     return gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead;
   }
 
-  private copyTransactionBlock(tx: TransactionBlock): TransactionBlock {
-    return TransactionBlock.from(tx.serialize());
+  private copyTransaction(tx: Transaction): Transaction {
+    return Transaction.from(tx.serialize());
   }
 }

package/src/types/assets.ts

@@ -1,4 +1,6 @@
-import { CoinMetadata } from '@mysten/sui.js/client';
+import type { SuiClientTypes } from '@mysten/sui/client';
+
+export type CoinMetadata = SuiClientTypes.CoinMetadata;
 
 export interface OwnedCoin {
   type: string;

package/src/types/msafe.ts

@@ -1,6 +1,14 @@
 import { IGasOption, TransactionType, TxIntention } from '@msafe/sui3-utils';
-import { DryRunTransactionBlockResponse, GasCostSummary, SuiObjectRef } from '@mysten/sui.js/client';
-import { SerializedSignature } from '@mysten/sui.js/cryptography';
+import type { SuiClientTypes } from '@mysten/sui/client';
+
+/** Gas coin reference derived from simulation / execution effects. */
+export interface GasObjectReference {
+  objectId: string;
+  version: string;
+  digest: string;
+}
+
+export type SimulateDryRunResponse = SuiClientTypes.SimulateTransactionResult<{ effects: true }>;
 
 export interface PendingTx {
   application: string;
@@ -77,7 +85,7 @@ export interface ProposeIntention {
   sequenceNumber: number;
   userAddress: string;
   msafeAddress: string;
-  signature: SerializedSignature;
+  signature: string;
 }
 
 export type SimulationResult = SimulationSuccessResult | SimulationFailedResult;
@@ -85,16 +93,16 @@ export type SimulationResult = SimulationSuccessResult | SimulationFailedResult;
 export interface SimulationSuccessResult {
   success: true;
   gasPrice: bigint;
-  gasUsed: GasCostSummary;
+  gasUsed: SuiClientTypes.GasCostSummary;
   gasBudget: bigint;
-  gasObject: SuiObjectRef;
-  response: DryRunTransactionBlockResponse;
+  gasObject: GasObjectReference;
+  response: SimulateDryRunResponse;
 }
 
 export interface SimulationFailedResult {
   success: false;
   gasPrice: bigint;
-  response: DryRunTransactionBlockResponse;
+  response?: SimulateDryRunResponse;
   simulationError: string;
 }
 

package/src/types/wallet.ts

@@ -1,10 +1,6 @@
-import {
-  ExecuteTransactionRequestType,
-  SuiTransactionBlockResponseOptions,
-  SuiTransactionBlockResponse,
-} from '@mysten/sui.js/client';
-import { SignatureWithBytes } from '@mysten/sui.js/cryptography';
-import { TransactionBlock } from '@mysten/sui.js/transactions';
+import type { SuiClientTypes } from '@mysten/sui/client';
+import { SignatureWithBytes } from '@mysten/sui/cryptography';
+import { Transaction } from '@mysten/sui/transactions';
 
 export interface IWallet {
   walletType: string;
@@ -13,11 +9,10 @@ export interface IWallet {
 
   signPersonalMessage(input: { messageStr: string }): Promise<SignatureWithBytes>;
 
-  signTransactionBlock(input: { transactionBlock: TransactionBlock | Uint8Array }): Promise<SignatureWithBytes>;
+  signTransactionBlock(input: { transactionBlock: Transaction | Uint8Array }): Promise<SignatureWithBytes>;
 
   signAndExecuteTransactionBlock(input: {
-    transactionBlock: TransactionBlock;
-    requestType?: ExecuteTransactionRequestType;
-    options?: SuiTransactionBlockResponseOptions;
-  }): Promise<SuiTransactionBlockResponse>;
+    transactionBlock: Transaction | Uint8Array;
+    include?: SuiClientTypes.TransactionInclude;
+  }): Promise<SuiClientTypes.TransactionResult>;
 }

package/src/utils/coin.ts

@@ -1,13 +1,15 @@
-import { CoinMetadata, SuiClient, SuiObjectData } from '@mysten/sui.js/client';
-import { normalizeStructTag } from '@mysten/sui.js/utils';
+import type { SuiGrpcClient } from '@mysten/sui/grpc';
+import { normalizeStructTag } from '@mysten/sui/utils';
+
+import type { CoinMetadata } from '@/types/assets';
 
 // CoinHelper is the coin helper to query for coin metadata.
 export class CoinHelper {
-  private _client: SuiClient;
+  private _client: SuiGrpcClient;
 
   private _coinMetaReg: Map<string, CoinMetadata>;
 
-  constructor(client: SuiClient) {
+  constructor(client: SuiGrpcClient) {
     this._client = client;
     this._coinMetaReg = new Map();
   }
@@ -26,7 +28,7 @@ export class CoinHelper {
 
   private async queryCoinMeta(coinType: string): Promise<CoinMetadata | undefined> {
     const res = await this._client.getCoinMetadata({ coinType });
-    return res || undefined;
+    return res.coinMetadata ?? undefined;
   }
 }
 
@@ -48,14 +50,25 @@ export class Coin {
     return res || null;
   }
 
-  static getBalance(data: SuiObjectData): bigint | undefined {
+  static getBalance(data: {
+    type?: string | null;
+    json?: Record<string, unknown> | null;
+    content?: { dataType?: string; fields?: { balance?: string } };
+  }): bigint | undefined {
     if (!Coin.isCoin(data.type)) {
       return undefined;
     }
+    if (data.json && typeof data.json === 'object' && 'balance' in data.json) {
+      const { balance } = data.json as { balance?: string };
+      if (balance === undefined) {
+        return undefined;
+      }
+      return BigInt(balance);
+    }
     if (data.content?.dataType !== 'moveObject') {
       return undefined;
     }
-    const { balance } = data.content?.fields as any;
+    const { balance } = data.content?.fields as { balance?: string };
     if (balance === undefined) {
       return undefined;
     }

package/src/utils/crypto.ts

@@ -1,5 +1,4 @@
-import { SerializedSignature } from '@mysten/sui.js/cryptography';
-import { verifyPersonalMessage, verifyTransactionBlock } from '@mysten/sui.js/verify';
+import { verifyPersonalMessageSignature, verifyTransactionSignature } from '@mysten/sui/verify';
 
 import { stringToBuffer } from '@/utils/buffer';
 import { Formatter } from '@/utils/format';
@@ -8,15 +7,15 @@ export class SignatureVerifier {
   static async getPublicKeyFromSignature(input: {
     message: Uint8Array;
     messageType: 'TransactionBlock' | 'Personal';
-    signature: SerializedSignature;
+    signature: string;
   }) {
     if (input.messageType === 'TransactionBlock') {
-      return verifyTransactionBlock(input.message, input.signature);
+      return verifyTransactionSignature(input.message, input.signature);
     }
-    return verifyPersonalMessage(input.message, input.signature);
+    return verifyPersonalMessageSignature(input.message, input.signature);
   }
 
-  static async getPublicKeyFromPersonalSignature(input: { messageStr: string; signature: SerializedSignature }) {
+  static async getPublicKeyFromPersonalSignature(input: { messageStr: string; signature: string }) {
     const message = stringToBuffer(input.messageStr);
     return this.getPublicKeyFromSignature({
       message,
@@ -28,18 +27,14 @@ export class SignatureVerifier {
   static async verifySignature(input: {
     message: Uint8Array;
     messageType: 'TransactionBlock' | 'Personal';
-    signature: SerializedSignature;
+    signature: string;
     targetAddress: string;
   }) {
     const publicKey = await SignatureVerifier.getPublicKeyFromSignature(input);
     return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
   }
 
-  static async verifyPersonalSignature(input: {
-    messageStr: string;
-    signature: SerializedSignature;
-    targetAddress: string;
-  }) {
+  static async verifyPersonalSignature(input: { messageStr: string; signature: string; targetAddress: string }) {
     const message = stringToBuffer(input.messageStr);
     return this.verifySignature({
       message,
@@ -51,7 +46,7 @@ export class SignatureVerifier {
 
   static async verifyTransactionSignature(input: {
     payload: Uint8Array;
-    signature: SerializedSignature;
+    signature: string;
     targetAddress: string;
   }): Promise<boolean> {
     return this.verifySignature({

package/src/utils/format.ts

@@ -1,4 +1,4 @@
-import { normalizeSuiAddress, normalizeStructTag } from '@mysten/sui.js/utils';
+import { normalizeSuiAddress, normalizeStructTag } from '@mysten/sui/utils';
 
 import { Coin } from '@/utils/coin';
 

package/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from './crypto';
 export * from './format';
 export * from './sui';
 export * from './coin';
+export * from './transaction';

package/src/utils/iter/object.ts

@@ -1,11 +1,15 @@
-import { SuiObjectResponse, SuiObjectDataOptions, SuiObjectData, SuiClient } from '@mysten/sui.js/client';
+import type { SuiClientTypes } from '@mysten/sui/client';
+import type { SuiGrpcClient } from '@mysten/sui/grpc';
 
 import { EntryIterator, getAllFromIterator, REQUEST_PAGE_SIZE, SuiIterator } from './iterator';
 import { PagedData, Requester } from './requester';
 
 // TODO: setup testnet faucet and test this file
 
-export type ObjectFilter = (objRes: SuiObjectResponse) => boolean;
+/** Owned object row with Move JSON content (for helpers like Coin.getBalance). */
+export type OwnedObjectData = SuiClientTypes.Object<{ json: true }>;
+
+export type ObjectFilter = (obj: OwnedObjectData) => boolean;
 
 // OidIter is the iterator to give the list of object ids
 export type OidIter = SuiIterator<string>;
@@ -13,20 +17,27 @@ export type OidIter = SuiIterator<string>;
 export interface BatchObjectOptions {
   filter?: ObjectFilter;
   pageSize?: number;
-  objectOptions?: SuiObjectDataOptions;
+  /** Extra fields to request from the node; defaults include Move JSON for struct fields. */
+  objectInclude?: SuiClientTypes.ObjectInclude;
+}
+
+const defaultObjectInclude: SuiClientTypes.ObjectInclude = { json: true };
+
+function mergeInclude(options?: BatchObjectOptions): SuiClientTypes.ObjectInclude {
+  return { ...defaultObjectInclude, ...options?.objectInclude };
 }
 
 // getObjectsById get the list of objects by id.
 // Compared with the multiGetObject method defined by SUI, this method will do the pagination
 // for get object requests.
 export async function getObjectsById(
-  provider: SuiClient,
+  provider: SuiGrpcClient,
   ids: string[],
   options?: BatchObjectOptions,
-): Promise<(SuiObjectData | undefined)[]> {
+): Promise<(OwnedObjectData | undefined)[]> {
   const oidIter = new ListOidIterator(ids);
   const iter = new ObjectBatchIterator(provider, oidIter, options);
-  return (await getAllFromIterator(iter)) as (SuiObjectData | undefined)[];
+  return (await getAllFromIterator(iter)) as (OwnedObjectData | undefined)[];
 }
 
 // ListOidIterator is the iterator that iterate through a list of ids.
@@ -53,9 +64,9 @@ export class ListOidIterator implements OidIter {
   }
 }
 
-export class ObjectBatchIterator extends EntryIterator<SuiObjectData> {
+export class ObjectBatchIterator extends EntryIterator<OwnedObjectData> {
   constructor(
-    public readonly provider: SuiClient,
+    public readonly provider: SuiGrpcClient,
     public readonly idIter: OidIter,
     public readonly options?: BatchObjectOptions,
   ) {
@@ -64,27 +75,24 @@ export class ObjectBatchIterator extends EntryIterator<SuiObjectData> {
 }
 
 // TODO: Test with customize objects
-export class ObjectBatchRequester implements Requester<SuiObjectData> {
+export class ObjectBatchRequester implements Requester<OwnedObjectData> {
   filter: ObjectFilter | undefined;
 
   pageSize: number;
 
-  objectOptions: SuiObjectDataOptions;
+  objectInclude: SuiClientTypes.ObjectInclude;
 
   constructor(
-    public readonly provider: SuiClient,
+    public readonly provider: SuiGrpcClient,
     public readonly stringIter: OidIter,
     public options?: BatchObjectOptions,
   ) {
     this.filter = options?.filter;
     this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
-    this.objectOptions = options?.objectOptions || {
-      showType: true,
-      showContent: true,
-    };
+    this.objectInclude = mergeInclude(options);
   }
 
-  async doNextRequest(): Promise<PagedData<SuiObjectData>> {
+  async doNextRequest(): Promise<PagedData<OwnedObjectData>> {
     const requestPage: string[] = [];
     while (requestPage.length < this.pageSize) {
       const hasNext = await this.stringIter.hasNext();
@@ -96,36 +104,44 @@ export class ObjectBatchRequester implements Requester<SuiObjectData> {
         requestPage.push(objId);
       }
     }
-    const res: SuiObjectResponse[] = await this.provider.multiGetObjects({
-      ids: requestPage,
-      options: this.objectOptions,
+    const { objects } = await this.provider.getObjects({
+      objectIds: requestPage,
+      include: this.objectInclude,
     });
-    let filtered: SuiObjectResponse[];
+    const rows: OwnedObjectData[] = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const entry of objects) {
+      if (entry instanceof Error) {
+        continue;
+      }
+      rows.push(entry as OwnedObjectData);
+    }
+    let filtered: OwnedObjectData[];
     if (this.filter) {
       const { filter } = this;
-      filtered = res.filter((r: SuiObjectResponse) => filter?.(r));
+      filtered = rows.filter((r) => filter(r));
     } else {
-      filtered = res;
+      filtered = rows;
     }
     return {
-      data: filtered.map((objRes) => objRes.data).filter((data) => data) as SuiObjectData[],
+      data: filtered,
       hasNext: await this.stringIter.hasNext(),
     };
   }
 }
 
 export async function getAllOwnedObjects(
-  provider: SuiClient,
+  provider: SuiGrpcClient,
   owner: string,
   options?: BatchObjectOptions,
-): Promise<SuiObjectData[]> {
+): Promise<OwnedObjectData[]> {
   const iter = new OwnedObjectIterator(provider, owner, options);
-  return (await getAllFromIterator(iter)) as SuiObjectData[];
+  return (await getAllFromIterator(iter)) as OwnedObjectData[];
 }
 
-export class OwnedObjectIterator extends EntryIterator<SuiObjectData> implements SuiIterator<SuiObjectData> {
+export class OwnedObjectIterator extends EntryIterator<OwnedObjectData> implements SuiIterator<OwnedObjectData> {
   constructor(
-    public readonly provider: SuiClient,
+    public readonly provider: SuiGrpcClient,
     public readonly owner: string,
     public readonly options?: BatchObjectOptions,
   ) {
@@ -133,46 +149,43 @@ export class OwnedObjectIterator extends EntryIterator<SuiObjectData> implements
   }
 }
 
-export class OwnedObjectRequester implements Requester<SuiObjectData> {
+export class OwnedObjectRequester implements Requester<OwnedObjectData> {
   nextCursor: string | null;
 
   public filter: ObjectFilter | undefined;
 
   public pageSize: number;
 
-  public objectOptions: SuiObjectDataOptions;
+  public objectInclude: SuiClientTypes.ObjectInclude;
 
   constructor(
-    public readonly provider: SuiClient,
+    public readonly provider: SuiGrpcClient,
     public readonly owner: string,
     public readonly options?: BatchObjectOptions,
   ) {
     this.nextCursor = null;
     this.filter = options?.filter;
     this.pageSize = options?.pageSize || REQUEST_PAGE_SIZE;
-    this.objectOptions = options?.objectOptions || {
-      showType: true,
-      showContent: true,
-    };
+    this.objectInclude = mergeInclude(options);
   }
 
-  async doNextRequest(): Promise<PagedData<SuiObjectData>> {
-    const res = await this.provider.getOwnedObjects({
+  async doNextRequest(): Promise<PagedData<OwnedObjectData>> {
+    const res = await this.provider.listOwnedObjects({
       owner: this.owner,
-      options: this.objectOptions,
+      include: this.objectInclude,
       cursor: this.nextCursor,
       limit: this.pageSize,
     });
-    this.nextCursor = res.nextCursor as string;
-    let filtered: SuiObjectResponse[];
+    this.nextCursor = res.cursor;
+    let filtered: OwnedObjectData[];
     if (this.filter) {
       const { filter } = this;
-      filtered = res.data.filter((obj: SuiObjectResponse) => filter?.(obj));
+      filtered = res.objects.filter((obj) => filter(obj as OwnedObjectData));
     } else {
-      filtered = res.data;
+      filtered = res.objects as OwnedObjectData[];
     }
     return {
-      data: filtered.map((r: SuiObjectResponse) => r.data).filter((data) => data) as SuiObjectData[],
+      data: filtered,
       hasNext: res.hasNextPage,
     };
   }