@msafe/sui3-sdk 0.0.90 → 1.0.6

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,
     };
   }

package/src/utils/sui.ts

@@ -1,21 +1,64 @@
 import { PublicKeySerde } from '@msafe/sui3-utils';
-import { SuiClient, PaginatedTransactionResponse, PaginatedCoins, CoinStruct } from '@mysten/sui.js/client';
-import { parseSerializedSignature, PublicKey, SerializedSignature } from '@mysten/sui.js/cryptography';
-import { MultiSigPublicKey } from '@mysten/sui.js/multisig';
+import type { SuiClientTypes } from '@mysten/sui/client';
+import { parseSerializedSignature, type PublicKey } from '@mysten/sui/cryptography';
+import { SuiGraphQLClient } from '@mysten/sui/graphql';
+import type { SuiGrpcClient } from '@mysten/sui/grpc';
+import { MultiSigPublicKey } from '@mysten/sui/multisig';
 
 import { Formatter } from '@/utils/format';
 
 export const SUI_COIN = '0x2::sui::SUI';
 
-export async function getPublicKeyFromChain(suiClient: SuiClient, address: string): Promise<PublicKey | undefined> {
-  let txs: PaginatedTransactionResponse;
+const GRAPHQL_URL_BY_NETWORK: Record<string, string> = {
+  mainnet: 'https://sui-mainnet.mystenlabs.com/graphql',
+  testnet: 'https://sui-testnet.mystenlabs.com/graphql',
+  devnet: 'https://sui-devnet.mystenlabs.com/graphql',
+};
+
+function graphqlClientForGrpc(suiClient: SuiGrpcClient) {
+  const url = GRAPHQL_URL_BY_NETWORK[suiClient.network] ?? GRAPHQL_URL_BY_NETWORK.testnet;
+  return new SuiGraphQLClient({ url, network: suiClient.network });
+}
+
+function collectSignatureStrings(value: unknown): string[] {
+  if (typeof value === 'string') {
+    return [value];
+  }
+  if (!value || typeof value !== 'object') {
+    return [];
+  }
+  if ('base64' in value && typeof (value as { base64: unknown }).base64 === 'string') {
+    return [(value as { base64: string }).base64];
+  }
+  if ('scheme' in value && 'base64' in value) {
+    const b64 = (value as { base64?: unknown }).base64;
+    return typeof b64 === 'string' ? [b64] : [];
+  }
+  return [];
+}
+
+const TX_SIG_QUERY = `
+  query PublicKeyTxSigs($sender: SuiAddress!, $first: Int!) {
+    transactions(first: $first, filter: { sentAddress: $sender }) {
+      nodes {
+        signatures
+      }
+    }
+  }
+`;
+
+export async function getPublicKeyFromChain(suiClient: SuiGrpcClient, address: string): Promise<PublicKey | undefined> {
+  const graphql = graphqlClientForGrpc(suiClient);
+  let txs: { transactions?: { nodes?: unknown[] } };
   try {
-    txs = await suiClient.queryTransactionBlocks({
-      // Disable naming rule since the variable is defined by Mysten
-      filter: { FromAddress: address },
-      options: { showInput: true },
-      limit: 2,
+    const res = await graphql.query({
+      query: TX_SIG_QUERY,
+      variables: { sender: address, first: 2 },
     });
+    if (res.errors?.length) {
+      return undefined;
+    }
+    txs = (res.data ?? {}) as { transactions?: { nodes?: unknown[] } };
   } catch (e) {
     // Currently when there is no history transaction, will report an error:
     // Error: byte deserialization failed, cause by: Odd number of digits
@@ -23,11 +66,18 @@ export async function getPublicKeyFromChain(suiClient: SuiClient, address: strin
     return undefined;
   }
 
-  if (txs.data.length === 0 || !txs.data[0].transaction?.txSignatures) {
+  const nodes = txs.transactions?.nodes ?? [];
+  if (nodes.length === 0) {
+    return undefined;
+  }
+
+  const first = nodes[0] as { signatures?: unknown };
+  const rawSigs = first.signatures;
+  const signatures: string[] = Array.isArray(rawSigs) ? rawSigs.flatMap((item) => collectSignatureStrings(item)) : [];
+
+  if (signatures.length === 0) {
     return undefined;
   }
-  const tx = txs.data[0];
-  const signatures = tx.transaction?.txSignatures as string[];
 
   for (let i = 0; i !== signatures.length; i++) {
     const serializedSig = signatures[i];
@@ -40,7 +90,7 @@ export async function getPublicKeyFromChain(suiClient: SuiClient, address: strin
   return undefined;
 }
 
-function getAddressFromSignatures(serializedSig: SerializedSignature, targetAddress: string) {
+function getAddressFromSignatures(serializedSig: string, targetAddress: string) {
   const decoded = parseSerializedSignature(serializedSig);
   switch (decoded.signatureScheme) {
     case 'MultiSig': {
@@ -56,7 +106,7 @@ function getAddressFromSignatures(serializedSig: SerializedSignature, targetAddr
     case 'Secp256r1': {
       const pk = PublicKeySerde.de({ publicKeyEncoded: decoded.publicKey, schema: decoded.signatureScheme });
       if (Formatter.isSuiAddressEqual(pk.toSuiAddress(), targetAddress)) {
-        return pk;
+        return pk as unknown as PublicKey;
       }
       return undefined;
     }
@@ -66,19 +116,19 @@ function getAddressFromSignatures(serializedSig: SerializedSignature, targetAddr
   }
 }
 
-export async function getAllCoins(input: { suiClient: SuiClient; owner: string; coinType: string | undefined }) {
+export async function getAllCoins(input: { suiClient: SuiGrpcClient; owner: string; coinType: string | undefined }) {
   let hasNext = true;
-  let cursor: string | undefined | null;
-  const res: CoinStruct[] = [];
+  let cursor: string | null | undefined;
+  const res: SuiClientTypes.Coin[] = [];
   while (hasNext) {
-    const currentPage: PaginatedCoins = await input.suiClient.getCoins({
+    const currentPage = await input.suiClient.listCoins({
       owner: input.owner,
       coinType: input.coinType,
       cursor,
     });
-    res.push(...currentPage.data);
+    res.push(...currentPage.objects);
     hasNext = currentPage.hasNextPage;
-    cursor = currentPage.nextCursor;
+    cursor = currentPage.cursor;
   }
   return res;
 }

package/src/utils/transaction.ts

@@ -0,0 +1,12 @@
+import { Transaction, isTransaction } from '@mysten/sui/transactions';
+
+/**
+ * Normalize a transaction value to {@link Transaction} (handles plain Transaction or serialized legacy shapes).
+ */
+export function toSuiTransaction(txb: Transaction | unknown): Transaction {
+  if (isTransaction(txb)) {
+    return txb as Transaction;
+  }
+  const legacy = txb as { serialize: () => string };
+  return Transaction.from(legacy.serialize()) as Transaction;
+}

package/tsconfig.json

@@ -6,7 +6,7 @@
     "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
     "module": "ES2022",                                /* Specify what module code is generated. */
     "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    "moduleResolution": "node",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "bundler",                  /* Resolve @mysten/sui subpath exports (ESM). */
     "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     "paths": { "@/*": ["./src/*"] },                     /* Specify a set of entries that re-map imports to additional lookup locations. */
     "resolveJsonModule": true,                        /* Enable importing .json files. */