@layerzerolabs/common-suimove 0.2.7 → 0.2.9

package/src/provider.ts

@@ -5,6 +5,16 @@ import type {
     SuiMoveDevInspectResult,
     SuiMoveEvent,
     SuiMoveEventCursor,
+    SuiMoveGetAllCoinsParams,
+    SuiMoveGetAllCoinsResponse,
+    SuiMoveGetObjectParams,
+    SuiMoveGetOwnedObjectsParams,
+    SuiMoveGetOwnedObjectsResponse,
+    SuiMoveGetTransactionBlockParams,
+    SuiMoveObjectResponse,
+    SuiMovePaginatedTransactionResponse,
+    SuiMoveQueryTransactionBlocksParams,
+    SuiMoveSystemStateSummary,
     SuiMoveTransactionBlockResponse,
 } from './types';
 
@@ -23,9 +33,17 @@ export interface SuiMoveProvider {
         cursor?: SuiMoveEventCursor;
     }): Promise<SuiMoveEvent[]>;
 
+    queryTransactionBlocks(
+        args: SuiMoveQueryTransactionBlocksParams,
+    ): Promise<SuiMovePaginatedTransactionResponse>;
+
+    getChainIdentifier(): Promise<string>;
+
     getCheckpoint(args: { id: string }): Promise<SuiMoveCheckpoint>;
 
-    getSuiMoveTransactionBlock(args: { digest: string }): Promise<SuiMoveTransactionBlockResponse>;
+    getSuiMoveTransactionBlock(
+        args: SuiMoveGetTransactionBlockParams,
+    ): Promise<SuiMoveTransactionBlockResponse>;
 
     getLatestCheckpointSequenceNumber(): Promise<string>;
 
@@ -42,4 +60,14 @@ export interface SuiMoveProvider {
         transactionBlock: SuiMoveTransaction;
         sender: string;
     }): Promise<SuiMoveDevInspectResult>;
+
+    getSuiMoveObject(args: SuiMoveGetObjectParams): Promise<SuiMoveObjectResponse>;
+
+    getAllSuiMoveCoins(args: SuiMoveGetAllCoinsParams): Promise<SuiMoveGetAllCoinsResponse>;
+
+    getSuiMoveOwnedObject(
+        args: SuiMoveGetOwnedObjectsParams,
+    ): Promise<SuiMoveGetOwnedObjectsResponse>;
+
+    getSuiMoveSystemStateSummary(): Promise<SuiMoveSystemStateSummary>;
 }

package/src/transaction.ts

@@ -1,17 +1,15 @@
 import type {
     TransactionArgument as IotaTransactionArgument,
-    TransactionObjectArgument as IotaTransactionObjectArgument,
     TransactionResult as IotaTransactionResult,
 } from '@iota/iota-sdk/transactions';
 import type { Transaction as IotaTransaction } from '@iota/iota-sdk/transactions';
 import type {
     TransactionArgument as SuiTransactionArgument,
-    TransactionObjectArgument as SuiTransactionObjectArgument,
     TransactionResult as SuiTransactionResult,
 } from '@mysten/sui/transactions';
 import type { Transaction as SuiTransaction } from '@mysten/sui/transactions';
 
-export type SuiMoveObjectArgument = SuiTransactionObjectArgument | IotaTransactionObjectArgument;
+import type { SuiMoveProvider } from './provider';
 
 export type SuiMoveArgument = SuiTransactionArgument | IotaTransactionArgument;
 
@@ -19,13 +17,46 @@ export type SuiMoveTransactionResult = SuiTransactionResult | IotaTransactionRes
 
 export type SuiMoveClock = SuiTransaction['object']['clock'] | IotaTransaction['object']['clock'];
 
+// Extract types from SuiTransaction.getData() return type
+export type SuiMoveTransactionData =
+    | ReturnType<SuiTransaction['getData']>
+    | ReturnType<IotaTransaction['getData']>;
+export type SuiMoveTransactionInput = SuiMoveTransactionData['inputs'][number];
+
+// Extract command types - filter out the undefined case
+export type SuiMoveCommand = SuiMoveTransactionData['commands'][number];
+export type SuiMoveCall = Extract<SuiMoveCommand, { $kind: 'MoveCall' }>['MoveCall'];
+export type SuiMoveCallArgument = SuiMoveCall['arguments'][number];
+
+export type SuiMoveGas = SuiTransaction['gas'] | IotaTransaction['gas'];
+
 export interface SuiMoveTransaction {
+    gas: SuiMoveGas;
+
     getNew(): SuiMoveTransaction;
 
-    from(tx: SuiMoveTransaction): SuiMoveTransaction;
+    from(tx: SuiMoveTransaction | string): SuiMoveTransaction;
 
     setSender(sender: string): void;
 
+    suiMoveObjectRef(args: {
+        objectId: string;
+        digest: string;
+        version: string | number;
+    }): SuiMoveArgument;
+
+    suiMoveSharedObjectRef(args: {
+        objectId: string;
+        initialSharedVersion: string | number;
+        mutable: boolean;
+    }): SuiMoveArgument;
+
+    suiMoveReceivingRef(args: {
+        objectId: string;
+        digest: string;
+        version: string | number;
+    }): SuiMoveArgument;
+
     suiMoveCall(args: {
         target: string;
         arguments: SuiMoveArgument[];
@@ -38,20 +69,41 @@ export interface SuiMoveTransaction {
     }): SuiMoveTransactionResult;
 
     suiMoveTransferObjects(
-        objects: SuiMoveObjectArgument[],
+        objects: (SuiMoveArgument | string)[],
         target: string | SuiMoveArgument,
     ): SuiMoveTransactionResult;
 
     suiMakeMoveVec(args: {
-        type: string;
-        elements: SuiMoveObjectArgument[];
+        type: string | undefined;
+        elements: SuiMoveArgument[];
     }): SuiMoveTransactionResult;
 
     toJSON(): Promise<string>;
 
-    getData(): ReturnType<SuiTransaction['getData'] | IotaTransaction['getData']>;
+    getData(): SuiMoveTransactionData;
+
+    getDigest(args: { client: SuiMoveProvider }): Promise<string>;
+
+    suiMoveSplitCoins(args: {
+        coin?: SuiMoveArgument;
+        amounts: SuiMoveArgument[];
+    }): SuiMoveTransactionResult;
+
+    upgrade(args: {
+        modules: number[][] | string[];
+        dependencies: string[];
+        package: string;
+        ticket: string | SuiMoveArgument;
+    }): SuiMoveTransactionResult;
+
+    mergeCoins(
+        destination: string | SuiMoveArgument,
+        sources: (string | SuiMoveArgument)[],
+    ): SuiMoveTransactionResult;
+
+    buildSuiMove(args: { client: SuiMoveProvider }): Promise<Uint8Array>;
 
-    suiMoveSplitCoins(args: { amounts: SuiMoveArgument[] }): SuiMoveTransactionResult;
+    setExpiration(args: { Epoch: string }): void;
 
     asObject(args: { objectId: string | SuiMoveArgument }): SuiMoveArgument;
 

package/src/types.ts

@@ -2,17 +2,37 @@ import type { bcs as iotaBcs, BcsType as IotaBcsType } from '@iota/iota-sdk/bcs'
 import type {
     DevInspectResults as IotaDevInspectResults,
     IotaExecutionResult,
+    IotaObjectData,
+    IotaObjectResponse,
+    IotaTransactionBlockResponse,
+    LatestIotaSystemStateSummary,
+    PaginatedObjectsResponse as IotaPaginatedObjectsResponse,
+    PaginatedTransactionResponse as IotaPaginatedTransactionResponse,
+    QueryTransactionBlocksParams as IotaQueryTransactionBlocksParams,
 } from '@iota/iota-sdk/client';
 import type { bcs as suiBcs, BcsType as SuiBcsType } from '@mysten/sui/bcs';
 import type {
+    Checkpoint,
     DevInspectResults as SuiDevInspectResults,
+    GetAllCoinsParams,
+    GetObjectParams,
+    GetOwnedObjectsParams,
+    GetTransactionBlockParams,
+    PaginatedCoins,
+    PaginatedObjectsResponse as SuiPaginatedObjectsResponse,
+    PaginatedTransactionResponse as SuiPaginatedTransactionResponse,
+    QueryTransactionBlocksParams as SuiQueryTransactionBlocksParams,
     SuiExecutionResult,
+    SuiObjectData,
+    SuiObjectResponse,
+    SuiSystemStateSummary,
+    SuiTransactionBlockResponse,
 } from '@mysten/sui/client';
 
 export type SuiMoveBcsType<T, U> = SuiBcsType<T, U> | IotaBcsType<T, U>;
 
 export type SuiTypes =
-    | typeof suiBcs.U128
+    | typeof suiBcs.U256
     | typeof suiBcs.U64
     | typeof suiBcs.U32
     | typeof suiBcs.U16
@@ -28,7 +48,7 @@ export type SuiTypes =
       >;
 
 export type IotaTypes =
-    | typeof iotaBcs.U128
+    | typeof iotaBcs.U256
     | typeof iotaBcs.U64
     | typeof iotaBcs.U32
     | typeof iotaBcs.U16
@@ -46,7 +66,7 @@ export type IotaTypes =
 export type SuiMoveTypes = SuiTypes | IotaTypes;
 
 export interface SuiMoveBcs {
-    u256: typeof suiBcs.U128 | typeof iotaBcs.U128;
+    u256: typeof suiBcs.U256 | typeof iotaBcs.U256;
     u128: typeof suiBcs.U128 | typeof iotaBcs.U128;
     u64: typeof suiBcs.U64 | typeof iotaBcs.U64;
     u32: typeof suiBcs.U32 | typeof iotaBcs.U32;
@@ -83,17 +103,6 @@ export interface SuiMoveEvent {
     blockDigest?: string;
 }
 
-export interface SuiMoveCheckpoint {
-    digest: string;
-    sequenceNumber: string;
-}
-
-export interface SuiMoveTransactionBlockResponse {
-    digest: string;
-    events: SuiMoveEvent[];
-    checkpoint?: string;
-}
-
 export interface SuiMoveCoinBalance {
     coinType: string;
     totalBalance: string;
@@ -104,6 +113,40 @@ export interface SuiMoveViewResult {
     type: string;
 }
 
+export type SuiMoveCheckpoint = Checkpoint;
+
+export type SuiMoveGetTransactionBlockParams = GetTransactionBlockParams;
+
+export type SuiMoveTransactionBlockResponse =
+    | SuiTransactionBlockResponse
+    | IotaTransactionBlockResponse;
+
+export type SuiMoveGetAllCoinsParams = GetAllCoinsParams;
+
+export type SuiMoveGetAllCoinsResponse = PaginatedCoins;
+
+export type SuiMoveGetObjectParams = GetObjectParams;
+
+export type SuiMoveObjectResponse = SuiObjectResponse | IotaObjectResponse;
+
+export type SuiMoveGetOwnedObjectsParams = GetOwnedObjectsParams;
+
+export type SuiMoveGetOwnedObjectsResponse =
+    | SuiPaginatedObjectsResponse
+    | IotaPaginatedObjectsResponse;
+
 export type SuiMoveDevInspectResult = SuiDevInspectResults | IotaDevInspectResults;
 
 export type SuiMoveExecutionResult = SuiExecutionResult | IotaExecutionResult;
+
+export type SuiMoveObjectData = SuiObjectData | IotaObjectData;
+
+export type SuiMoveSystemStateSummary = SuiSystemStateSummary | LatestIotaSystemStateSummary;
+
+export type SuiMoveQueryTransactionBlocksParams =
+    | SuiQueryTransactionBlocksParams
+    | IotaQueryTransactionBlocksParams;
+
+export type SuiMovePaginatedTransactionResponse =
+    | SuiPaginatedTransactionResponse
+    | IotaPaginatedTransactionResponse;

package/src/utils.ts

@@ -1,12 +1,185 @@
-import { fromBase64 } from '@mysten/sui/utils';
+import { normalizeIotaAddress } from '@iota/iota-sdk/utils';
+import type {
+    CoinStruct,
+    GetObjectParams,
+    GetTransactionBlockParams,
+    SuiObjectChange,
+    SuiObjectDataOptions,
+    SuiTransactionBlockResponseOptions,
+} from '@mysten/sui/client';
+import { fromBase64, normalizeSuiAddress, parseStructTag } from '@mysten/sui/utils';
+
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+import type {
+    AllRequired,
+    MaybePartial,
+    Prettify,
+    RemoveNever,
+} from '@layerzerolabs/typescript-utils';
 
 import { SuiMoveAbortError, SuiMoveUnclassifiedError } from './error';
 import type { SuiMoveProvider } from './provider';
 import type { SuiMoveTransaction } from './transaction';
-import type { SuiMoveEvent, SuiMoveExecutionResult, SuiMoveViewResult } from './types';
+import type {
+    SuiMoveEvent,
+    SuiMoveExecutionResult,
+    SuiMoveObjectResponse,
+    SuiMoveTransactionBlockResponse,
+    SuiMoveViewResult,
+} from './types';
 
 const MOCK_SENDER = '0x1234567890123456789012345678901234567890123456789012345678901234';
 
+export interface MatchQuery {
+    type: string;
+    check: 'includes' | 'startsWith' | 'endsWith' | 'equals' | 'regex';
+}
+
+type FullObjectOptions = AllRequired<SuiObjectDataOptions>;
+type FullBlockResponseOptions = AllRequired<SuiTransactionBlockResponseOptions>;
+
+type ObjectChangeTypes = SuiObjectChange['type'];
+type ObjectChangeTypesOptions = {
+    [K in ObjectChangeTypes as `show${Capitalize<K>}`]?: boolean;
+};
+
+type ObjectChangeTypeResults<Options extends ObjectChangeTypesOptions> = Prettify<
+    RemoveNever<{
+        [K in ObjectChangeTypes]: `show${Capitalize<K>}` extends keyof Options
+            ? Options[`show${Capitalize<K>}`] extends true
+                ? Extract<SuiObjectChange, { type: K }>[]
+                : never
+            : never;
+    }>
+>;
+
+const objectOptionKeys: (keyof FullObjectOptions)[] = [
+    'showBcs',
+    'showContent',
+    'showType',
+    'showDisplay',
+    'showOwner',
+    'showPreviousTransaction',
+    'showStorageRebate',
+] as const;
+
+const blockResponseOptionsKeys: (keyof FullBlockResponseOptions)[] = [
+    'showBalanceChanges',
+    'showEffects',
+    'showEvents',
+    'showObjectChanges',
+    'showRawEffects',
+] as const;
+
+type OptionsValidated<
+    FullOptions extends Record<string, any>,
+    CurrentOptions extends Record<string, any>,
+    Data extends Record<string, any>,
+> = Prettify<
+    RemoveNever<{
+        [key in keyof AllRequired<Data>]: key extends string
+            ? `show${Capitalize<key>}` extends keyof FullOptions
+                ? CurrentOptions[`show${Capitalize<key>}`] extends true
+                    ? NonNullable<Data[key]>
+                    : never
+                : Data[key]
+            : never;
+    }>
+>;
+
+const validateOptions = <
+    FullOptions extends Record<string, any>,
+    Options extends Record<string, any>,
+    Data extends Record<string, any>,
+>(
+    data: Data,
+    fullOptionKeys: string[],
+    options?: Options,
+): OptionsValidated<FullOptions, Options, Data> => {
+    // check inclusion of all options
+    fullOptionKeys.forEach((option) => {
+        // Remove 'show' prefix and convert first letter to lowercase for camelCase
+        const fieldName = option.slice('show'.length);
+        const field = fieldName.charAt(0).toLowerCase() + fieldName.slice(1);
+        if (options?.[option] && !data[field]) {
+            throw new Error(`Missing required field ${field} on data object ${data}`);
+        }
+    });
+
+    // check validity of inclusions:
+    return Object.fromEntries(
+        Object.entries(data).map(([key, value]) => {
+            for (const option of fullOptionKeys) {
+                // Convert option to expected field name
+                const fieldName = option.slice('show'.length);
+                const expectedField = fieldName.charAt(0).toLowerCase() + fieldName.slice(1);
+                if (expectedField === key && options?.[option] && !value) {
+                    throw new Error(
+                        `Failed fetching data for option ${option} on object ${data.objectId}`,
+                    );
+                }
+            }
+            return [key, value];
+        }),
+    ) as OptionsValidated<FullObjectOptions, Options, Data>;
+};
+
+export const checkInclusion = (objectType: string, query: MatchQuery) => {
+    const check = query.check;
+    const type = query.type;
+    switch (check) {
+        case 'includes':
+            return objectType.includes(type);
+        case 'startsWith':
+            return objectType.startsWith(type);
+        case 'endsWith':
+            return objectType.endsWith(type);
+        case 'equals':
+            return objectType === type;
+        case 'regex':
+            return new RegExp(type).test(objectType);
+        default:
+            throw new Error(`Unknown check type: ${check}`);
+    }
+};
+
+export const filterObjectChanges = <Options extends ObjectChangeTypesOptions>(
+    objectChanges: SuiObjectChange[],
+    query: MatchQuery | 'all',
+    options?: Options,
+): ObjectChangeTypeResults<Options> => {
+    const result = {} as ObjectChangeTypeResults<Options>;
+    type key = keyof ObjectChangeTypeResults<Options>;
+    const capitalize = (s: string) => s.slice(0, 1).toUpperCase() + s.slice(1);
+
+    for (const objectChange of objectChanges) {
+        // Published has packageId
+        if (objectChange.type === 'published') {
+            if (
+                options?.showPublished &&
+                (query === 'all' || checkInclusion(objectChange.packageId, query))
+            ) {
+                // FIXME: maybe we can remove these as? not sure though
+                result['published' as key] ??= [] as any;
+                result['published' as key].push(objectChange as any);
+            }
+        } else {
+            // Everyone else has objectType
+            const show = `show${capitalize(objectChange.type)}` as keyof Options;
+            if (
+                options?.[show] &&
+                (query === 'all' || checkInclusion(objectChange.objectType, query))
+            ) {
+                // FIXME: maybe we can remove these as? not sure though
+                result[objectChange.type as key] ??= [] as any;
+                result[objectChange.type as key].push(objectChange as any);
+            }
+        }
+    }
+
+    return result;
+};
+
 /**
  * Converts raw Sui move events to SuiMoveEvent format
  */
@@ -84,3 +257,232 @@ export async function suiMoveView(
     ]);
     return results[0];
 }
+
+export async function suiMoveViewParsed<T>({
+    client,
+    tx,
+    parser,
+}: {
+    client: SuiMoveProvider;
+    tx: SuiMoveTransaction;
+    parser: (result: { value: Uint8Array }[]) => T;
+}): Promise<T> {
+    const results = await suiMoveViewMultiResult(client, tx, [
+        tx.getData().commands.length - 1, // last command
+    ]);
+    return parser(results[0]);
+}
+
+/**
+ * Returns the defining package ID for a given object type. This is the package
+ * that defined the object's Move type at the time the object was created.
+ *
+ * @param objectType The object type, e.g. 0xc6b8aab4e0124a27071228cb4c2b422344cb13574a9641ed0d9177c7111ed7::my_coin::MY_COIN
+ * @returns The defining package ID, e.g. 0xc6b8aab4e0124a27071228cb4c2b422344cb13574a9641ed0d9177c7111ed7
+ */
+export function getDefiningPackageIdFromObjectType(
+    chainName: ChainName,
+    objectType: string,
+): string {
+    const address = parseStructTag(objectType).address;
+    return normalizeSuiMoveAddress(address, chainName);
+}
+
+export async function getSuiMoveObjectValidated<const Options extends SuiObjectDataOptions>(
+    args: Omit<GetObjectParams, 'options'> & { options?: Options; client: SuiMoveProvider },
+): Promise<
+    OptionsValidated<FullObjectOptions, Options, NonNullable<SuiMoveObjectResponse['data']>>
+> {
+    const object = await args.client.getSuiMoveObject(args);
+    if (object.error) {
+        throw new Error(`Failed to get object ${args.id}`, { cause: object.error });
+    } else if (!object.data) {
+        throw new Error(`Object not found: ${args.id}`);
+    }
+
+    return validateOptions<FullObjectOptions, Options, NonNullable<SuiMoveObjectResponse['data']>>(
+        object.data,
+        objectOptionKeys,
+        args.options,
+    );
+}
+
+export async function getSuiMoveTransactionBlockValidated<
+    const Options extends SuiTransactionBlockResponseOptions,
+>(
+    args: Omit<GetTransactionBlockParams, 'options'> & {
+        options?: Options;
+        client: SuiMoveProvider;
+    },
+): Promise<OptionsValidated<FullBlockResponseOptions, Options, SuiMoveTransactionBlockResponse>> {
+    const txBlock = await args.client.getSuiMoveTransactionBlock(args);
+    if (txBlock.errors?.length) {
+        throw new Error(`Couldn't fetch transaction block due to errors: ${txBlock.errors}`);
+    }
+
+    return validateOptions<FullBlockResponseOptions, Options, SuiMoveTransactionBlockResponse>(
+        txBlock,
+        blockResponseOptionsKeys,
+        args.options,
+    );
+}
+
+/**
+ * Fetches all owned coins that have the specified package id
+ * @param chainName chainName to denormalize the addresses
+ * @param normalizedCoinPackageId Coin package id to search for
+ * @param normalizedWalletAddress Wallet address to search for coins on
+ * @returns Array of all found coin objects, sorted by balance
+ */
+export async function searchForCoinTypeInWallet(
+    chainName: ChainName,
+    coinPackageId: string,
+    walletAddress: string,
+    client: SuiMoveProvider,
+): Promise<CoinStruct[]> {
+    let cursor: string | undefined | null = undefined;
+    let hasNextPage = true;
+    let coinObjects = [] as CoinStruct[];
+
+    while (hasNextPage) {
+        const coins = await client.getAllSuiMoveCoins({
+            owner: walletAddress,
+            limit: 50,
+            cursor,
+        });
+
+        // Sui has its own normalization for addresses that we need to use to compare addresses
+        const normalizedCoinPackageId = normalizeSuiMoveAddress(coinPackageId, chainName);
+
+        const matchedCoins = coins.data.filter((coin) => {
+            const coinType = coin.coinType;
+            const definingPackageId = getDefiningPackageIdFromObjectType(chainName, coinType);
+            return definingPackageId === normalizedCoinPackageId;
+        });
+
+        coinObjects = coinObjects.concat(matchedCoins);
+        cursor = coins.nextCursor;
+        hasNextPage = coins.hasNextPage;
+    }
+    return coinObjects.sort((a, b) => Number(BigInt(b.balance) - BigInt(a.balance)));
+}
+
+export async function getSuiMoveOwnedObjectsByType<
+    T extends Record<string, MatchQuery>,
+    Options extends SuiObjectDataOptions,
+    AllowPartial extends boolean = false,
+>({
+    walletAddress,
+    typeInclusions,
+    options,
+    client,
+}: {
+    walletAddress: string;
+    typeInclusions: T;
+    options?: Omit<Options, 'showType'> & { allowPartial?: AllowPartial };
+    client: SuiMoveProvider;
+}): Promise<
+    Record<
+        keyof T,
+        MaybePartial<
+            OptionsValidated<
+                FullObjectOptions,
+                Options & { showType: true },
+                NonNullable<SuiMoveObjectResponse['data']>
+            >[],
+            AllowPartial
+        >
+    >
+> {
+    let cursor: string | undefined | null = undefined;
+    let hasNextPage = true;
+    const result = {} as Record<
+        keyof T,
+        OptionsValidated<
+            FullObjectOptions,
+            Options & { showType: true },
+            NonNullable<SuiMoveObjectResponse['data']>
+        >[]
+    >;
+    const typeInclusionsArray = Object.entries(typeInclusions);
+
+    while (hasNextPage) {
+        const objects = await client.getSuiMoveOwnedObject({
+            owner: walletAddress,
+            options: {
+                ...options,
+                showType: true,
+            },
+            cursor,
+            limit: 50,
+        });
+        for (const object of objects.data) {
+            if (!object.data) continue;
+            const objectType = object.data.type;
+            if (!objectType) {
+                continue;
+            }
+            for (const [key, query] of typeInclusionsArray) {
+                if (checkInclusion(objectType, query)) {
+                    const validated = validateOptions<
+                        FullObjectOptions,
+                        Options,
+                        NonNullable<SuiMoveObjectResponse['data']>
+                    >(object.data, objectOptionKeys, options as Options | undefined);
+                    result[key as keyof T] ??= [];
+                    result[key as keyof T].push(validated);
+                }
+            }
+        }
+        cursor = objects.nextCursor;
+        hasNextPage = objects.hasNextPage;
+    }
+
+    if (!options?.allowPartial && Object.keys(result).length !== typeInclusionsArray.length) {
+        const difference = new Set(typeInclusionsArray.map(([k]) => k));
+        Object.keys(result).forEach((key) => difference.delete(key));
+        throw new Error(`Couldnt find all objects, missing: ${[...difference]}`);
+    }
+
+    return result;
+}
+
+export async function getSuiMovePackagePublishObjectChanges<
+    Queries extends Record<string, MatchQuery | 'all'>,
+    ChangeOptions extends ObjectChangeTypesOptions,
+>({
+    packageId,
+    queries,
+    options,
+    client,
+}: {
+    packageId: string;
+    queries: Queries;
+    client: SuiMoveProvider;
+    options?: ChangeOptions;
+}): Promise<Record<keyof Queries, ObjectChangeTypeResults<ChangeOptions>>> {
+    const pkgObject = await getSuiMoveObjectValidated({
+        id: packageId,
+        client,
+        options: { showPreviousTransaction: true },
+    });
+
+    const txBlock = await getSuiMoveTransactionBlockValidated({
+        digest: pkgObject.previousTransaction,
+        options: { showObjectChanges: true },
+        client,
+    });
+
+    return Object.fromEntries(
+        Object.entries(queries).map(([k, query]) => {
+            return [k, filterObjectChanges(txBlock.objectChanges, query, options)];
+        }),
+    ) as Record<keyof Queries, ObjectChangeTypeResults<ChangeOptions>>;
+}
+
+export const normalizeSuiMoveAddress = (address: string, chainName: ChainName) => {
+    if (chainName === ChainName.IOTAL1) {
+        return normalizeIotaAddress(address);
+    }
+    return normalizeSuiAddress(address);
+};

package/dist/AHFVRB2R.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/error.ts"],"names":["SuiMoveAbortError","Error","abortCode","rawMsg","SuiMoveUnclassifiedError"],"mappings":";;;;;;AAAO,IAAMA,iBAAAA,GAAN,cAAgCC,KAAAA,CAAAA;EAAvC;;;AACaC,EAAAA,SAAAA;AACT,EAAA,WAAA,CAAYA,WAAmBC,MAAAA,EAAgB;AAC3C,IAAA,KAAA,CAAM,CAAA,sBAAA,EAAyBD,SAAAA,CAAAA,qBAAAA,EAAiCC,MAAAA,CAAAA,CAAQ,CAAA;AACxE,IAAA,IAAA,CAAKD,SAAAA,GAAYA,SAAAA;AACrB,EAAA;AACJ;AAEO,IAAME,wBAAAA,GAAN,cAAuCH,KAAAA,CAAAA;EAR9C;;;AAQqD","file":"AHFVRB2R.cjs","sourcesContent":["export class SuiMoveAbortError extends Error {\n    readonly abortCode: number;\n    constructor(abortCode: number, rawMsg: string) {\n        super(`Move abort with code: ${abortCode}. Raw error message: ${rawMsg}`);\n        this.abortCode = abortCode;\n    }\n}\n\nexport class SuiMoveUnclassifiedError extends Error {}\n"]}