wowok 2.1.10 → 2.1.13

package/dist/cjs/grpc/core.js

@@ -1,645 +1,608 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var core_exports = {};
-__export(core_exports, {
-  GrpcCoreClient: () => GrpcCoreClient,
-  parseTransactionEffects: () => parseTransactionEffects
-});
-module.exports = __toCommonJS(core_exports);
-var import_experimental = require("../experimental/index.js");
-var import_owner = require("./proto/sui/rpc/v2/owner.js");
-var import_utils = require("@mysten/utils");
-var import_effects = require("./proto/sui/rpc/v2/effects.js");
-var import_effects2 = require("./proto/sui/rpc/v2/effects.js");
-var import_transactions = require("../transactions/index.js");
-var import_bcs = require("../bcs/index.js");
-var import_move_package = require("./proto/sui/rpc/v2/move_package.js");
-var _client;
-class GrpcCoreClient extends import_experimental.Experimental_CoreClient {
-  constructor({ client, ...options }) {
-    super(options);
-    __privateAdd(this, _client);
-    __privateSet(this, _client, client);
-  }
-  async getObjects(options) {
-    const batches = (0, import_utils.chunk)(options.objectIds, 50);
-    const results = [];
-    for (const batch of batches) {
-      const response = await __privateGet(this, _client).ledgerService.batchGetObjects({
-        requests: batch.map((id) => ({ objectId: id })),
-        readMask: {
-          paths: [
-            "owner",
-            "object_type",
-            "bcs",
-            "digest",
-            "version",
-            "object_id",
-            "previous_transaction"
-          ]
-        }
-      });
-      results.push(
-        ...response.response.objects.map(
-          (object) => {
-            if (object.result.oneofKind === "error") {
-              return new Error(object.result.error.message);
-            }
-            if (object.result.oneofKind !== "object") {
-              return new Error("Unexpected result type");
-            }
-            return {
-              id: object.result.object.objectId,
-              version: object.result.object.version?.toString(),
-              digest: object.result.object.digest,
-              // TODO: bcs content is not returned in all cases
-              content: Promise.resolve(
-                object.result.object.bcs?.value
-              ),
-              owner: mapOwner(object.result.object.owner),
-              type: object.result.object.objectType,
-              previousTransaction: object.result.object.previousTransaction ?? null
-            };
-          }
-        )
-      );
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcCoreClient = void 0;
+exports.parseTransactionEffects = parseTransactionEffects;
+const index_js_1 = require("../experimental/index.js");
+const owner_js_1 = require("./proto/sui/rpc/v2/owner.js");
+const utils_1 = require("@mysten/utils");
+const effects_js_1 = require("./proto/sui/rpc/v2/effects.js");
+const effects_js_2 = require("./proto/sui/rpc/v2/effects.js");
+const index_js_2 = require("../transactions/index.js");
+const index_js_3 = require("../bcs/index.js");
+const move_package_js_1 = require("./proto/sui/rpc/v2/move_package.js");
+class GrpcCoreClient extends index_js_1.Experimental_CoreClient {
+    #client;
+    constructor({ client, ...options }) {
+        super(options);
+        this.#client = client;
     }
-    return {
-      objects: results
-    };
-  }
-  async getOwnedObjects(options) {
-    const response = await __privateGet(this, _client).stateService.listOwnedObjects({
-      owner: options.address,
-      objectType: options.type,
-      pageToken: options.cursor ? (0, import_utils.fromBase64)(options.cursor) : void 0,
-      readMask: {
-        paths: [
-          "owner",
-          "object_type",
-          "bcs",
-          "digest",
-          "version",
-          "object_id",
-          "previous_transaction"
-        ]
-      }
-    });
-    const objects = response.response.objects.map(
-      (object) => ({
-        id: object.objectId,
-        version: object.version?.toString(),
-        digest: object.digest,
-        // TODO: List owned objects doesn't return content right now
-        get content() {
-          return object.bcs?.value ? Promise.resolve(object.bcs.value) : Promise.reject(
-            new Error(
-              "GRPC does not return object contents when listing owned objects"
-            )
-          );
-        },
-        owner: mapOwner(object.owner),
-        type: object.objectType,
-        previousTransaction: object.previousTransaction ?? null
-      })
-    );
-    return {
-      objects,
-      cursor: response.response.nextPageToken ? (0, import_utils.toBase64)(response.response.nextPageToken) : null,
-      hasNextPage: response.response.nextPageToken !== void 0
-    };
-  }
-  async getCoins(options) {
-    const response = await __privateGet(this, _client).stateService.listOwnedObjects({
-      owner: options.address,
-      objectType: `0x2::coin::Coin<${options.coinType}>`,
-      pageToken: options.cursor ? (0, import_utils.fromBase64)(options.cursor) : void 0,
-      readMask: {
-        paths: [
-          "owner",
-          "object_type",
-          "bcs",
-          "digest",
-          "version",
-          "object_id",
-          "balance",
-          "previous_transaction"
-        ]
-      }
-    });
-    return {
-      objects: response.response.objects.map(
-        (object) => ({
-          id: object.objectId,
-          version: object.version?.toString(),
-          digest: object.digest,
-          // TODO: List owned objects doesn't return content right now
-          get content() {
-            return object.bcs?.value ? Promise.resolve(object.bcs.value) : Promise.reject(
-              new Error(
-                "GRPC does not return object contents when listing owned objects"
-              )
-            );
-          },
-          owner: mapOwner(object.owner),
-          type: object.objectType,
-          balance: object.balance?.toString(),
-          previousTransaction: object.previousTransaction ?? null
-        })
-      ),
-      cursor: response.response.nextPageToken ? (0, import_utils.toBase64)(response.response.nextPageToken) : null,
-      hasNextPage: response.response.nextPageToken !== void 0
-    };
-  }
-  async getBalance(options) {
-    const result = await __privateGet(this, _client).stateService.getBalance({
-      owner: options.address,
-      coinType: options.coinType
-    });
-    return {
-      balance: {
-        balance: result.response.balance?.balance?.toString() ?? "0",
-        coinType: result.response.balance?.coinType ?? options.coinType
-      }
-    };
-  }
-  async getAllBalances(options) {
-    const result = await __privateGet(this, _client).stateService.listBalances({
-      owner: options.address,
-      pageToken: options.cursor ? (0, import_utils.fromBase64)(options.cursor) : void 0,
-      pageSize: options.limit
-    });
-    return {
-      hasNextPage: !!result.response.nextPageToken,
-      cursor: result.response.nextPageToken ? (0, import_utils.toBase64)(result.response.nextPageToken) : null,
-      balances: result.response.balances.map((balance) => ({
-        balance: balance.balance?.toString() ?? "0",
-        coinType: balance.coinType
-      }))
-    };
-  }
-  async getTransaction(options) {
-    const { response } = await __privateGet(this, _client).ledgerService.getTransaction({
-      digest: options.digest,
-      readMask: {
-        paths: [
-          "digest",
-          "transaction",
-          "effects",
-          "signatures",
-          "balance_changes"
-        ]
-      }
-    });
-    return {
-      transaction: parseTransaction(response.transaction)
-    };
-  }
-  async executeTransaction(options) {
-    const { response } = await __privateGet(this, _client).transactionExecutionService.executeTransaction({
-      transaction: {
-        bcs: {
-          value: options.transaction
-        }
-      },
-      signatures: options.signatures.map((signature) => ({
-        bcs: {
-          value: (0, import_utils.fromBase64)(signature)
-        },
-        signature: {
-          oneofKind: void 0
+    async getObjects(options) {
+        const batches = (0, utils_1.chunk)(options.objectIds, 50);
+        const results = [];
+        for (const batch of batches) {
+            const response = await this.#client.ledgerService.batchGetObjects({
+                requests: batch.map((id) => ({ objectId: id })),
+                readMask: {
+                    paths: [
+                        "owner",
+                        "object_type",
+                        "bcs",
+                        "digest",
+                        "version",
+                        "object_id",
+                        "previous_transaction",
+                    ],
+                },
+            });
+            results.push(...response.response.objects.map((object) => {
+                if (object.result.oneofKind === "error") {
+                    // TODO: improve error handling
+                    return new Error(object.result.error.message);
+                }
+                if (object.result.oneofKind !== "object") {
+                    return new Error("Unexpected result type");
+                }
+                const obj = object.result.object;
+                return {
+                    id: obj.objectId,
+                    version: obj.version?.toString(),
+                    digest: obj.digest,
+                    // TODO: bcs content is not returned in all cases
+                    content: Promise.resolve(obj.bcs?.value),
+                    owner: mapOwner(obj.owner),
+                    type: obj.objectType,
+                    previousTransaction: obj.previousTransaction ?? null,
+                };
+            }));
         }
-      })),
-      readMask: {
-        paths: [
-          "transaction.digest",
-          "transaction.transaction",
-          "transaction.effects",
-          "transaction.signatures",
-          "transaction.balance_changes"
-        ]
-      }
-    });
-    return {
-      transaction: parseTransaction(response.transaction)
-    };
-  }
-  async dryRunTransaction(options) {
-    const { response } = await __privateGet(this, _client).transactionExecutionService.simulateTransaction({
-      transaction: {
-        bcs: {
-          value: options.transaction
+        return {
+            objects: results,
+        };
+    }
+    async getOwnedObjects(options) {
+        const response = await this.#client.stateService.listOwnedObjects({
+            owner: options.address,
+            objectType: options.type,
+            pageToken: options.cursor ? (0, utils_1.fromBase64)(options.cursor) : undefined,
+            readMask: {
+                paths: [
+                    "owner",
+                    "object_type",
+                    "bcs",
+                    "digest",
+                    "version",
+                    "object_id",
+                    "previous_transaction",
+                ],
+            },
+        });
+        const objects = response.response.objects.map((object) => ({
+            id: object.objectId,
+            version: object.version?.toString(),
+            digest: object.digest,
+            // TODO: List owned objects doesn't return content right now
+            get content() {
+                return object.bcs?.value
+                    ? Promise.resolve(object.bcs.value)
+                    : Promise.reject(new Error("GRPC does not return object contents when listing owned objects"));
+            },
+            owner: mapOwner(object.owner),
+            type: object.objectType,
+            previousTransaction: object.previousTransaction ?? null,
+        }));
+        return {
+            objects,
+            cursor: response.response.nextPageToken
+                ? (0, utils_1.toBase64)(response.response.nextPageToken)
+                : null,
+            hasNextPage: response.response.nextPageToken !== undefined,
+        };
+    }
+    async getCoins(options) {
+        const response = await this.#client.stateService.listOwnedObjects({
+            owner: options.address,
+            objectType: `0x2::coin::Coin<${options.coinType}>`,
+            pageToken: options.cursor ? (0, utils_1.fromBase64)(options.cursor) : undefined,
+            readMask: {
+                paths: [
+                    "owner",
+                    "object_type",
+                    "bcs",
+                    "digest",
+                    "version",
+                    "object_id",
+                    "balance",
+                    "previous_transaction",
+                ],
+            },
+        });
+        return {
+            objects: response.response.objects.map((object) => ({
+                id: object.objectId,
+                version: object.version?.toString(),
+                digest: object.digest,
+                // TODO: List owned objects doesn't return content right now
+                get content() {
+                    return object.bcs?.value
+                        ? Promise.resolve(object.bcs.value)
+                        : Promise.reject(new Error("GRPC does not return object contents when listing owned objects"));
+                },
+                owner: mapOwner(object.owner),
+                type: object.objectType,
+                balance: object.balance?.toString(),
+                previousTransaction: object.previousTransaction ?? null,
+            })),
+            cursor: response.response.nextPageToken
+                ? (0, utils_1.toBase64)(response.response.nextPageToken)
+                : null,
+            hasNextPage: response.response.nextPageToken !== undefined,
+        };
+    }
+    async getBalance(options) {
+        const result = await this.#client.stateService.getBalance({
+            owner: options.address,
+            coinType: options.coinType,
+        });
+        return {
+            balance: {
+                balance: result.response.balance?.balance?.toString() ?? "0",
+                coinType: result.response.balance?.coinType ?? options.coinType,
+            },
+        };
+    }
+    async getAllBalances(options) {
+        const result = await this.#client.stateService.listBalances({
+            owner: options.address,
+            pageToken: options.cursor ? (0, utils_1.fromBase64)(options.cursor) : undefined,
+            pageSize: options.limit,
+        });
+        return {
+            hasNextPage: !!result.response.nextPageToken,
+            cursor: result.response.nextPageToken
+                ? (0, utils_1.toBase64)(result.response.nextPageToken)
+                : null,
+            balances: result.response.balances.map((balance) => ({
+                balance: balance.balance?.toString() ?? "0",
+                coinType: balance.coinType,
+            })),
+        };
+    }
+    async getTransaction(options) {
+        const { response } = await this.#client.ledgerService.getTransaction({
+            digest: options.digest,
+            readMask: {
+                paths: [
+                    "digest",
+                    "transaction",
+                    "effects",
+                    "signatures",
+                    "balance_changes",
+                ],
+            },
+        });
+        return {
+            transaction: parseTransaction(response.transaction),
+        };
+    }
+    async executeTransaction(options) {
+        const { response } = await this.#client.transactionExecutionService.executeTransaction({
+            transaction: {
+                bcs: {
+                    value: options.transaction,
+                },
+            },
+            signatures: options.signatures.map((signature) => ({
+                bcs: {
+                    value: (0, utils_1.fromBase64)(signature),
+                },
+                signature: {
+                    oneofKind: undefined,
+                },
+            })),
+            readMask: {
+                paths: [
+                    "transaction.digest",
+                    "transaction.transaction",
+                    "transaction.effects",
+                    "transaction.signatures",
+                    "transaction.balance_changes",
+                ],
+            },
+        });
+        return {
+            transaction: parseTransaction(response.transaction),
+        };
+    }
+    async dryRunTransaction(options) {
+        const { response } = await this.#client.transactionExecutionService.simulateTransaction({
+            transaction: {
+                bcs: {
+                    value: options.transaction,
+                },
+            },
+            readMask: {
+                paths: [
+                    "transaction.digest",
+                    "transaction.transaction",
+                    "transaction.effects",
+                    "transaction.signatures",
+                    "transaction.balance_changes",
+                ],
+            },
+        });
+        return {
+            transaction: parseTransaction(response.transaction),
+        };
+    }
+    async getReferenceGasPrice() {
+        const response = await this.#client.ledgerService.getEpoch({});
+        return {
+            referenceGasPrice: response.response.epoch?.referenceGasPrice?.toString(),
+        };
+    }
+    async getDynamicFields(options) {
+        const response = await this.#client.stateService.listDynamicFields({
+            parent: options.parentId,
+            pageToken: options.cursor ? (0, utils_1.fromBase64)(options.cursor) : undefined,
+        });
+        return {
+            dynamicFields: response.response.dynamicFields.map((field) => ({
+                id: field.fieldId,
+                name: {
+                    type: field.name?.name,
+                    bcs: field.name?.value,
+                },
+                type: field.fieldObject
+                    ? `0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<${field.name?.name}>,0x2::object::ID>`
+                    : `0x2::dynamic_field::Field<${field.name?.value},${field.valueType}>`,
+            })),
+            cursor: response.response.nextPageToken
+                ? (0, utils_1.toBase64)(response.response.nextPageToken)
+                : null,
+            hasNextPage: response.response.nextPageToken !== undefined,
+        };
+    }
+    async getMoveFunction(options) {
+        const { response } = await this.#client.movePackageService.getFunction({
+            packageId: options.packageId,
+            moduleName: options.moduleName,
+            name: options.name,
+        });
+        let visibility = "unknown";
+        switch (response.function?.visibility) {
+            case move_package_js_1.FunctionDescriptor_Visibility.PUBLIC:
+                visibility = "public";
+                break;
+            case move_package_js_1.FunctionDescriptor_Visibility.PRIVATE:
+                visibility = "private";
+                break;
+            case move_package_js_1.FunctionDescriptor_Visibility.FRIEND:
+                visibility = "friend";
+                break;
         }
-      },
-      readMask: {
-        paths: [
-          "transaction.digest",
-          "transaction.transaction",
-          "transaction.effects",
-          "transaction.signatures",
-          "transaction.balance_changes"
-        ]
-      }
-    });
-    return {
-      transaction: parseTransaction(response.transaction)
-    };
-  }
-  async getReferenceGasPrice() {
-    const response = await __privateGet(this, _client).ledgerService.getEpoch({});
-    return {
-      referenceGasPrice: response.response.epoch?.referenceGasPrice?.toString()
-    };
-  }
-  async getDynamicFields(options) {
-    const response = await __privateGet(this, _client).stateService.listDynamicFields({
-      parent: options.parentId,
-      pageToken: options.cursor ? (0, import_utils.fromBase64)(options.cursor) : void 0
-    });
-    return {
-      dynamicFields: response.response.dynamicFields.map((field) => ({
-        id: field.fieldId,
-        name: {
-          type: field.name?.name,
-          bcs: field.name?.value
-        },
-        type: field.fieldObject ? `0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<${field.name?.name}>,0x2::object::ID>` : `0x2::dynamic_field::Field<${field.name?.value},${field.valueType}>`
-      })),
-      cursor: response.response.nextPageToken ? (0, import_utils.toBase64)(response.response.nextPageToken) : null,
-      hasNextPage: response.response.nextPageToken !== void 0
-    };
-  }
-  async getMoveFunction(options) {
-    const { response } = await __privateGet(this, _client).movePackageService.getFunction({
-      packageId: options.packageId,
-      moduleName: options.moduleName,
-      name: options.name
-    });
-    let visibility = "unknown";
-    switch (response.function?.visibility) {
-      case import_move_package.FunctionDescriptor_Visibility.PUBLIC:
-        visibility = "public";
-        break;
-      case import_move_package.FunctionDescriptor_Visibility.PRIVATE:
-        visibility = "private";
-        break;
-      case import_move_package.FunctionDescriptor_Visibility.FRIEND:
-        visibility = "friend";
-        break;
+        return {
+            function: {
+                packageId: options.packageId,
+                moduleName: options.moduleName,
+                name: response.function?.name,
+                visibility,
+                isEntry: response.function?.isEntry ?? false,
+                typeParameters: response.function?.typeParameters?.map(({ constraints }) => ({
+                    isPhantom: false,
+                    constraints: constraints.map((constraint) => {
+                        switch (constraint) {
+                            case move_package_js_1.Ability.COPY:
+                                return "copy";
+                            case move_package_js_1.Ability.DROP:
+                                return "drop";
+                            case move_package_js_1.Ability.STORE:
+                                return "store";
+                            case move_package_js_1.Ability.KEY:
+                                return "key";
+                            default:
+                                return "unknown";
+                        }
+                    }) ?? [],
+                })) ?? [],
+                parameters: response.function?.parameters?.map((param) => parseNormalizedSuiMoveType(param)) ?? [],
+                returns: response.function?.returns?.map((ret) => parseNormalizedSuiMoveType(ret)) ?? [],
+            },
+        };
+    }
+    resolveTransactionPlugin() {
+        // const client = this.#client;
+        return async function resolveTransactionData(_transactionData, _options, _next) {
+            throw new Error("Transaction resolution is not supported with the GRPC client");
+            // const result = await client.liveDataService.simulateTransaction({
+            // 	transaction: transactionFromData(transactionData)
+            // })
+            // const resolvedData = dataFromSimulate(result)
+            // transactionData.applyResolvedData(resolvedData);
+            // return await next();
+        };
     }
-    return {
-      function: {
-        packageId: options.packageId,
-        moduleName: options.moduleName,
-        name: response.function?.name,
-        visibility,
-        isEntry: response.function?.isEntry ?? false,
-        typeParameters: response.function?.typeParameters?.map(
-          ({ constraints }) => ({
-            isPhantom: false,
-            constraints: constraints.map((constraint) => {
-              switch (constraint) {
-                case import_move_package.Ability.COPY:
-                  return "copy";
-                case import_move_package.Ability.DROP:
-                  return "drop";
-                case import_move_package.Ability.STORE:
-                  return "store";
-                case import_move_package.Ability.KEY:
-                  return "key";
-                default:
-                  return "unknown";
-              }
-            }) ?? []
-          })
-        ) ?? [],
-        parameters: response.function?.parameters?.map(
-          (param) => parseNormalizedSuiMoveType(param)
-        ) ?? [],
-        returns: response.function?.returns?.map(
-          (ret) => parseNormalizedSuiMoveType(ret)
-        ) ?? []
-      }
-    };
-  }
-  resolveTransactionPlugin() {
-    return async function resolveTransactionData(_transactionData, _options, _next) {
-      throw new Error(
-        "Transaction resolution is not supported with the GRPC client"
-      );
-    };
-  }
 }
-_client = new WeakMap();
+exports.GrpcCoreClient = GrpcCoreClient;
 function mapOwner(owner) {
-  if (!owner) {
-    return null;
-  }
-  if (owner.kind === import_owner.Owner_OwnerKind.IMMUTABLE) {
-    return {
-      $kind: "Immutable",
-      Immutable: true
-    };
-  }
-  if (owner.kind === import_owner.Owner_OwnerKind.ADDRESS) {
-    return {
-      AddressOwner: owner.address,
-      $kind: "AddressOwner"
-    };
-  }
-  if (owner.kind === import_owner.Owner_OwnerKind.OBJECT) {
-    return {
-      $kind: "ObjectOwner",
-      ObjectOwner: owner.address
-    };
-  }
-  if (owner.kind === import_owner.Owner_OwnerKind.SHARED) {
-    if (owner.address) {
-      return {
-        $kind: "ConsensusAddressOwner",
-        ConsensusAddressOwner: {
-          owner: owner.address,
-          startVersion: owner.version?.toString()
+    if (!owner) {
+        return null;
+    }
+    if (owner.kind === owner_js_1.Owner_OwnerKind.IMMUTABLE) {
+        return {
+            $kind: "Immutable",
+            Immutable: true,
+        };
+    }
+    if (owner.kind === owner_js_1.Owner_OwnerKind.ADDRESS) {
+        return {
+            AddressOwner: owner.address,
+            $kind: "AddressOwner",
+        };
+    }
+    if (owner.kind === owner_js_1.Owner_OwnerKind.OBJECT) {
+        return {
+            $kind: "ObjectOwner",
+            ObjectOwner: owner.address,
+        };
+    }
+    if (owner.kind === owner_js_1.Owner_OwnerKind.SHARED) {
+        if (owner.address) {
+            return {
+                $kind: "ConsensusAddressOwner",
+                ConsensusAddressOwner: {
+                    owner: owner.address,
+                    startVersion: owner.version?.toString(),
+                },
+            };
         }
-      };
+        return {
+            $kind: "Shared",
+            Shared: {
+                initialSharedVersion: owner.version?.toString(),
+            },
+        };
     }
-    return {
-      $kind: "Shared",
-      Shared: {
-        initialSharedVersion: owner.version?.toString()
-      }
-    };
-  }
-  throw new Error("Unknown owner kind");
+    throw new Error("Unknown owner kind");
 }
 function mapIdOperation(operation) {
-  if (operation == null) {
-    return null;
-  }
-  switch (operation) {
-    case import_effects2.ChangedObject_IdOperation.CREATED:
-      return "Created";
-    case import_effects2.ChangedObject_IdOperation.DELETED:
-      return "Deleted";
-    case import_effects2.ChangedObject_IdOperation.NONE:
-    case import_effects2.ChangedObject_IdOperation.ID_OPERATION_UNKNOWN:
-      return "None";
-    default:
-      operation;
-      return "Unknown";
-  }
+    if (operation == null) {
+        return null;
+    }
+    switch (operation) {
+        case effects_js_2.ChangedObject_IdOperation.CREATED:
+            return "Created";
+        case effects_js_2.ChangedObject_IdOperation.DELETED:
+            return "Deleted";
+        case effects_js_2.ChangedObject_IdOperation.NONE:
+        case effects_js_2.ChangedObject_IdOperation.ID_OPERATION_UNKNOWN:
+            return "None";
+        default:
+            operation;
+            return "Unknown";
+    }
 }
 function mapInputObjectState(state) {
-  if (state == null) {
-    return null;
-  }
-  switch (state) {
-    case import_effects2.ChangedObject_InputObjectState.EXISTS:
-      return "Exists";
-    case import_effects2.ChangedObject_InputObjectState.DOES_NOT_EXIST:
-      return "DoesNotExist";
-    case import_effects2.ChangedObject_InputObjectState.UNKNOWN:
-      return "Unknown";
-    default:
-      state;
-      return "Unknown";
-  }
+    if (state == null) {
+        return null;
+    }
+    switch (state) {
+        case effects_js_2.ChangedObject_InputObjectState.EXISTS:
+            return "Exists";
+        case effects_js_2.ChangedObject_InputObjectState.DOES_NOT_EXIST:
+            return "DoesNotExist";
+        case effects_js_2.ChangedObject_InputObjectState.UNKNOWN:
+            return "Unknown";
+        default:
+            state;
+            return "Unknown";
+    }
 }
 function mapOutputObjectState(state) {
-  if (state == null) {
-    return null;
-  }
-  switch (state) {
-    case import_effects2.ChangedObject_OutputObjectState.OBJECT_WRITE:
-      return "ObjectWrite";
-    case import_effects2.ChangedObject_OutputObjectState.PACKAGE_WRITE:
-      return "PackageWrite";
-    case import_effects2.ChangedObject_OutputObjectState.DOES_NOT_EXIST:
-      return "DoesNotExist";
-    case import_effects2.ChangedObject_OutputObjectState.UNKNOWN:
-      return "Unknown";
-    default:
-      state;
-      return "Unknown";
-  }
+    if (state == null) {
+        return null;
+    }
+    switch (state) {
+        case effects_js_2.ChangedObject_OutputObjectState.OBJECT_WRITE:
+            return "ObjectWrite";
+        case effects_js_2.ChangedObject_OutputObjectState.PACKAGE_WRITE:
+            return "PackageWrite";
+        case effects_js_2.ChangedObject_OutputObjectState.DOES_NOT_EXIST:
+            return "DoesNotExist";
+        case effects_js_2.ChangedObject_OutputObjectState.UNKNOWN:
+            return "Unknown";
+        default:
+            state;
+            return "Unknown";
+    }
 }
 function mapUnchangedConsensusObjectKind(kind) {
-  if (kind == null) {
-    return null;
-  }
-  switch (kind) {
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.UNCHANGED_CONSENSUS_OBJECT_KIND_UNKNOWN:
-      return "Unknown";
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.READ_ONLY_ROOT:
-      return "ReadOnlyRoot";
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.MUTATE_CONSENSUS_STREAM_ENDED:
-      return "MutateConsensusStreamEnded";
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.READ_CONSENSUS_STREAM_ENDED:
-      return "ReadConsensusStreamEnded";
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.CANCELED:
-      return "Cancelled";
-    case import_effects.UnchangedConsensusObject_UnchangedConsensusObjectKind.PER_EPOCH_CONFIG:
-      return "PerEpochConfig";
-    default:
-      kind;
-      return "Unknown";
-  }
+    if (kind == null) {
+        return null;
+    }
+    switch (kind) {
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.UNCHANGED_CONSENSUS_OBJECT_KIND_UNKNOWN:
+            return "Unknown";
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.READ_ONLY_ROOT:
+            return "ReadOnlyRoot";
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.MUTATE_CONSENSUS_STREAM_ENDED:
+            return "MutateConsensusStreamEnded";
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.READ_CONSENSUS_STREAM_ENDED:
+            return "ReadConsensusStreamEnded";
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.CANCELED:
+            return "Cancelled";
+        case effects_js_1.UnchangedConsensusObject_UnchangedConsensusObjectKind.PER_EPOCH_CONFIG:
+            return "PerEpochConfig";
+        default:
+            kind;
+            return "Unknown";
+    }
 }
-function parseTransactionEffects({
-  effects
-}) {
-  if (!effects) {
-    return null;
-  }
-  const changedObjects = effects.changedObjects.map(
-    (change) => {
-      return {
-        id: change.objectId,
-        inputState: mapInputObjectState(change.inputState),
-        inputVersion: change.inputVersion?.toString() ?? null,
-        inputDigest: change.inputDigest ?? null,
-        inputOwner: mapOwner(change.inputOwner),
-        outputState: mapOutputObjectState(change.outputState),
-        outputVersion: change.outputVersion?.toString() ?? null,
-        outputDigest: change.outputDigest ?? null,
-        outputOwner: mapOwner(change.outputOwner),
-        idOperation: mapIdOperation(change.idOperation)
-      };
+function parseTransactionEffects({ effects, }) {
+    if (!effects) {
+        return null;
     }
-  );
-  return {
-    bcs: effects.bcs?.value,
-    digest: effects.digest,
-    version: 2,
-    status: effects.status?.success ? {
-      success: true,
-      error: null
-    } : {
-      success: false,
-      // TODO: parse errors properly
-      error: JSON.stringify(effects.status?.error)
-    },
-    gasUsed: {
-      computationCost: effects.gasUsed?.computationCost?.toString(),
-      storageCost: effects.gasUsed?.storageCost?.toString(),
-      storageRebate: effects.gasUsed?.storageRebate?.toString(),
-      nonRefundableStorageFee: effects.gasUsed?.nonRefundableStorageFee?.toString()
-    },
-    transactionDigest: effects.transactionDigest,
-    gasObject: {
-      id: effects.gasObject?.objectId,
-      inputState: mapInputObjectState(effects.gasObject?.inputState),
-      inputVersion: effects.gasObject?.inputVersion?.toString() ?? null,
-      inputDigest: effects.gasObject?.inputDigest ?? null,
-      inputOwner: mapOwner(effects.gasObject?.inputOwner),
-      outputState: mapOutputObjectState(effects.gasObject?.outputState),
-      outputVersion: effects.gasObject?.outputVersion?.toString() ?? null,
-      outputDigest: effects.gasObject?.outputDigest ?? null,
-      outputOwner: mapOwner(effects.gasObject?.outputOwner),
-      idOperation: mapIdOperation(effects.gasObject?.idOperation)
-    },
-    eventsDigest: effects.eventsDigest ?? null,
-    dependencies: effects.dependencies,
-    lamportVersion: effects.lamportVersion?.toString() ?? null,
-    changedObjects,
-    unchangedConsensusObjects: effects.unchangedConsensusObjects.map(
-      (object) => {
+    const changedObjects = effects.changedObjects.map((change) => {
         return {
-          kind: mapUnchangedConsensusObjectKind(object.kind),
-          // TODO: we are inconsistent about id vs objectId
-          objectId: object.objectId,
-          version: object.version?.toString() ?? null,
-          digest: object.digest ?? null
+            id: change.objectId,
+            inputState: mapInputObjectState(change.inputState),
+            inputVersion: change.inputVersion?.toString() ?? null,
+            inputDigest: change.inputDigest ?? null,
+            inputOwner: mapOwner(change.inputOwner),
+            outputState: mapOutputObjectState(change.outputState),
+            outputVersion: change.outputVersion?.toString() ?? null,
+            outputDigest: change.outputDigest ?? null,
+            outputOwner: mapOwner(change.outputOwner),
+            idOperation: mapIdOperation(change.idOperation),
         };
-      }
-    ),
-    auxiliaryDataDigest: effects.auxiliaryDataDigest ?? null
-  };
+    });
+    return {
+        bcs: effects.bcs?.value,
+        digest: effects.digest,
+        version: 2,
+        status: effects.status?.success
+            ? {
+                success: true,
+                error: null,
+            }
+            : {
+                success: false,
+                // TODO: parse errors properly
+                error: JSON.stringify(effects.status?.error),
+            },
+        gasUsed: {
+            computationCost: effects.gasUsed?.computationCost?.toString(),
+            storageCost: effects.gasUsed?.storageCost?.toString(),
+            storageRebate: effects.gasUsed?.storageRebate?.toString(),
+            nonRefundableStorageFee: effects.gasUsed?.nonRefundableStorageFee?.toString(),
+        },
+        transactionDigest: effects.transactionDigest,
+        gasObject: {
+            id: effects.gasObject?.objectId,
+            inputState: mapInputObjectState(effects.gasObject?.inputState),
+            inputVersion: effects.gasObject?.inputVersion?.toString() ?? null,
+            inputDigest: effects.gasObject?.inputDigest ?? null,
+            inputOwner: mapOwner(effects.gasObject?.inputOwner),
+            outputState: mapOutputObjectState(effects.gasObject?.outputState),
+            outputVersion: effects.gasObject?.outputVersion?.toString() ?? null,
+            outputDigest: effects.gasObject?.outputDigest ?? null,
+            outputOwner: mapOwner(effects.gasObject?.outputOwner),
+            idOperation: mapIdOperation(effects.gasObject?.idOperation),
+        },
+        eventsDigest: effects.eventsDigest ?? null,
+        dependencies: effects.dependencies,
+        lamportVersion: effects.lamportVersion?.toString() ?? null,
+        changedObjects,
+        unchangedConsensusObjects: effects.unchangedConsensusObjects.map((object) => {
+            return {
+                kind: mapUnchangedConsensusObjectKind(object.kind),
+                // TODO: we are inconsistent about id vs objectId
+                objectId: object.objectId,
+                version: object.version?.toString() ?? null,
+                digest: object.digest ?? null,
+            };
+        }),
+        auxiliaryDataDigest: effects.auxiliaryDataDigest ?? null,
+    };
 }
 function parseTransaction(transaction) {
-  const parsedTx = import_bcs.bcs.SenderSignedData.parse(
-    transaction.transaction?.bcs?.value
-  )[0];
-  const bytes = import_bcs.bcs.TransactionData.serialize(
-    parsedTx.intentMessage.value
-  ).toBytes();
-  const data = import_transactions.TransactionDataBuilder.restore({
-    version: 2,
-    sender: parsedTx.intentMessage.value.V1.sender,
-    expiration: parsedTx.intentMessage.value.V1.expiration,
-    gasData: parsedTx.intentMessage.value.V1.gasData,
-    inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction.inputs,
-    commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction.commands
-  });
-  const objectTypes = {};
-  transaction.objects?.objects.forEach((object) => {
-    if (object.objectId && object.objectType) {
-      objectTypes[object.objectId] = object.objectType;
-    }
-  });
-  const effects = parseTransactionEffects({
-    effects: transaction.effects
-  });
-  return {
-    digest: transaction.digest,
-    epoch: transaction.effects?.epoch?.toString() ?? null,
-    effects,
-    objectTypes: Promise.resolve(objectTypes),
-    transaction: {
-      gasData: data.gasData,
-      sender: data.sender,
-      expiration: data.expiration,
-      commands: data.commands,
-      inputs: data.inputs,
-      version: data.version,
-      bcs: bytes
-    },
-    signatures: parsedTx.txSignatures,
-    balanceChanges: transaction.balanceChanges?.map((change) => ({
-      coinType: change.coinType,
-      address: change.address,
-      amount: change.amount
-    })) ?? []
-  };
+    const parsedTx = index_js_3.bcs.SenderSignedData.parse(transaction.transaction?.bcs?.value)[0];
+    const bytes = index_js_3.bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
+    const data = index_js_2.TransactionDataBuilder.restore({
+        version: 2,
+        sender: parsedTx.intentMessage.value.V1.sender,
+        expiration: parsedTx.intentMessage.value.V1.expiration,
+        gasData: parsedTx.intentMessage.value.V1.gasData,
+        inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction
+            .inputs,
+        commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction
+            .commands,
+    });
+    const objectTypes = {};
+    transaction.objects?.objects.forEach((object) => {
+        if (object.objectId && object.objectType) {
+            objectTypes[object.objectId] = object.objectType;
+        }
+    });
+    const effects = parseTransactionEffects({
+        effects: transaction.effects,
+    });
+    return {
+        digest: transaction.digest,
+        epoch: transaction.effects?.epoch?.toString() ?? null,
+        effects,
+        objectTypes: Promise.resolve(objectTypes),
+        transaction: {
+            gasData: data.gasData,
+            sender: data.sender,
+            expiration: data.expiration,
+            commands: data.commands,
+            inputs: data.inputs,
+            version: data.version,
+            bcs: bytes,
+        },
+        signatures: parsedTx.txSignatures,
+        balanceChanges: transaction.balanceChanges?.map((change) => ({
+            coinType: change.coinType,
+            address: change.address,
+            amount: change.amount,
+        })) ?? [],
+    };
 }
 function parseNormalizedSuiMoveType(type) {
-  let reference = null;
-  if (type.reference === import_move_package.OpenSignature_Reference.IMMUTABLE) {
-    reference = "immutable";
-  } else if (type.reference === import_move_package.OpenSignature_Reference.MUTABLE) {
-    reference = "mutable";
-  }
-  return {
-    reference,
-    body: parseNormalizedSuiMoveTypeBody(type.body)
-  };
+    let reference = null;
+    if (type.reference === move_package_js_1.OpenSignature_Reference.IMMUTABLE) {
+        reference = "immutable";
+    }
+    else if (type.reference === move_package_js_1.OpenSignature_Reference.MUTABLE) {
+        reference = "mutable";
+    }
+    return {
+        reference,
+        body: parseNormalizedSuiMoveTypeBody(type.body),
+    };
 }
 function parseNormalizedSuiMoveTypeBody(type) {
-  switch (type.type) {
-    case import_move_package.OpenSignatureBody_Type.TYPE_UNKNOWN:
-      return { $kind: "unknown" };
-    case import_move_package.OpenSignatureBody_Type.ADDRESS:
-      return { $kind: "address" };
-    case import_move_package.OpenSignatureBody_Type.BOOL:
-      return { $kind: "bool" };
-    case import_move_package.OpenSignatureBody_Type.U8:
-      return { $kind: "u8" };
-    case import_move_package.OpenSignatureBody_Type.U16:
-      return { $kind: "u16" };
-    case import_move_package.OpenSignatureBody_Type.U32:
-      return { $kind: "u32" };
-    case import_move_package.OpenSignatureBody_Type.U64:
-      return { $kind: "u64" };
-    case import_move_package.OpenSignatureBody_Type.U128:
-      return { $kind: "u128" };
-    case import_move_package.OpenSignatureBody_Type.U256:
-      return { $kind: "u256" };
-    case import_move_package.OpenSignatureBody_Type.VECTOR:
-      return {
-        $kind: "vector",
-        vector: parseNormalizedSuiMoveTypeBody(
-          type.typeParameterInstantiation[0]
-        )
-      };
-    case import_move_package.OpenSignatureBody_Type.DATATYPE:
-      return {
-        $kind: "datatype",
-        datatype: {
-          typeName: type.typeName,
-          typeParameters: type.typeParameterInstantiation.map(
-            (t) => parseNormalizedSuiMoveTypeBody(t)
-          )
-        }
-      };
-    case import_move_package.OpenSignatureBody_Type.TYPE_PARAMETER:
-      return {
-        $kind: "typeParameter",
-        index: type.typeParameter
-      };
-    default:
-      return { $kind: "unknown" };
-  }
+    switch (type.type) {
+        case move_package_js_1.OpenSignatureBody_Type.TYPE_UNKNOWN:
+            return { $kind: "unknown" };
+        case move_package_js_1.OpenSignatureBody_Type.ADDRESS:
+            return { $kind: "address" };
+        case move_package_js_1.OpenSignatureBody_Type.BOOL:
+            return { $kind: "bool" };
+        case move_package_js_1.OpenSignatureBody_Type.U8:
+            return { $kind: "u8" };
+        case move_package_js_1.OpenSignatureBody_Type.U16:
+            return { $kind: "u16" };
+        case move_package_js_1.OpenSignatureBody_Type.U32:
+            return { $kind: "u32" };
+        case move_package_js_1.OpenSignatureBody_Type.U64:
+            return { $kind: "u64" };
+        case move_package_js_1.OpenSignatureBody_Type.U128:
+            return { $kind: "u128" };
+        case move_package_js_1.OpenSignatureBody_Type.U256:
+            return { $kind: "u256" };
+        case move_package_js_1.OpenSignatureBody_Type.VECTOR:
+            return {
+                $kind: "vector",
+                vector: parseNormalizedSuiMoveTypeBody(type.typeParameterInstantiation[0]),
+            };
+        case move_package_js_1.OpenSignatureBody_Type.DATATYPE:
+            return {
+                $kind: "datatype",
+                datatype: {
+                    typeName: type.typeName,
+                    typeParameters: type.typeParameterInstantiation.map((t) => parseNormalizedSuiMoveTypeBody(t)),
+                },
+            };
+        case move_package_js_1.OpenSignatureBody_Type.TYPE_PARAMETER:
+            return {
+                $kind: "typeParameter",
+                index: type.typeParameter,
+            };
+        default:
+            return { $kind: "unknown" };
+    }
 }
+//# sourceMappingURL=core.js.map