wowok 1.8.2 → 2.1.9

package/dist/cjs/graphql/core.js

@@ -0,0 +1,506 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var core_exports = {};
+__export(core_exports, {
+  GraphQLCoreClient: () => GraphQLCoreClient
+});
+module.exports = __toCommonJS(core_exports);
+var import_core = require("../experimental/core.js");
+var import_queries = require("./generated/queries.js");
+var import_errors = require("../experimental/errors.js");
+var import_utils = require("@mysten/utils");
+var import_sui_types = require("../utils/sui-types.js");
+var import_dynamic_fields = require("../utils/dynamic-fields.js");
+var import_utils2 = require("../experimental/transports/utils.js");
+var _graphqlClient, _GraphQLCoreClient_instances, graphqlQuery_fn;
+class GraphQLCoreClient extends import_core.Experimental_CoreClient {
+  constructor({
+    graphqlClient,
+    mvr
+  }) {
+    super({ network: graphqlClient.network, base: graphqlClient, mvr });
+    __privateAdd(this, _GraphQLCoreClient_instances);
+    __privateAdd(this, _graphqlClient);
+    __privateSet(this, _graphqlClient, graphqlClient);
+  }
+  async getObjects(options) {
+    const batches = (0, import_utils.chunk)(options.objectIds, 50);
+    const results = [];
+    for (const batch of batches) {
+      const page = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+        query: import_queries.MultiGetObjectsDocument,
+        variables: {
+          objectKeys: batch.map((address) => ({ address }))
+        }
+      }, (result) => result.multiGetObjects);
+      results.push(
+        ...batch.map((id) => (0, import_sui_types.normalizeWowAddress)(id)).map(
+          (id) => page.find((obj) => obj?.address === id) ?? new import_errors.ObjectError(
+            "notFound",
+            `Object ${id} not found`
+          )
+        ).map((obj) => {
+          if (obj instanceof import_errors.ObjectError) {
+            return obj;
+          }
+          return {
+            id: obj.address,
+            version: obj.version?.toString(),
+            digest: obj.digest,
+            owner: mapOwner(obj.owner),
+            type: obj.asMoveObject?.contents?.type?.repr,
+            content: Promise.resolve(
+              obj.asMoveObject?.contents?.bcs ? (0, import_utils.fromBase64)(obj.asMoveObject.contents.bcs) : new Uint8Array()
+            ),
+            previousTransaction: obj.previousTransaction?.digest ?? null
+          };
+        })
+      );
+    }
+    return {
+      objects: results
+    };
+  }
+  async getOwnedObjects(options) {
+    const objects = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetOwnedObjectsDocument,
+      variables: {
+        owner: options.address,
+        limit: options.limit,
+        cursor: options.cursor,
+        filter: options.type ? {
+          type: (await this.mvr.resolveType({
+            type: options.type
+          })).type
+        } : void 0
+      }
+    }, (result) => result.address?.objects);
+    return {
+      objects: objects.nodes.map((obj) => ({
+        id: obj.address,
+        version: obj.version?.toString(),
+        digest: obj.digest,
+        owner: mapOwner(obj.owner),
+        type: obj.contents?.type?.repr,
+        content: Promise.resolve(
+          obj.contents?.bcs ? (0, import_utils.fromBase64)(obj.contents.bcs) : new Uint8Array()
+        ),
+        previousTransaction: obj.previousTransaction?.digest ?? null
+      })),
+      hasNextPage: objects.pageInfo.hasNextPage,
+      cursor: objects.pageInfo.endCursor ?? null
+    };
+  }
+  async getCoins(options) {
+    const coins = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetCoinsDocument,
+      variables: {
+        owner: options.address,
+        cursor: options.cursor,
+        first: options.limit,
+        type: `0x2::coin::Coin<${(await this.mvr.resolveType({ type: options.coinType })).type}>`
+      }
+    }, (result) => result.address?.objects);
+    return {
+      cursor: coins.pageInfo.endCursor ?? null,
+      hasNextPage: coins.pageInfo.hasNextPage,
+      objects: coins.nodes.map((coin) => ({
+        id: coin.address,
+        version: coin.version?.toString(),
+        digest: coin.digest,
+        owner: mapOwner(coin.owner),
+        type: coin.contents?.type?.repr,
+        balance: coin.contents?.json?.balance,
+        content: Promise.resolve(
+          coin.contents?.bcs ? (0, import_utils.fromBase64)(coin.contents.bcs) : new Uint8Array()
+        ),
+        previousTransaction: coin.previousTransaction?.digest ?? null
+      }))
+    };
+  }
+  async getBalance(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetBalanceDocument,
+      variables: {
+        owner: options.address,
+        type: (await this.mvr.resolveType({ type: options.coinType })).type
+      }
+    }, (result2) => result2.address?.balance);
+    return {
+      balance: {
+        coinType: result.coinType?.repr,
+        balance: result.totalBalance
+      }
+    };
+  }
+  async getAllBalances(options) {
+    const balances = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetAllBalancesDocument,
+      variables: { owner: options.address }
+    }, (result) => result.address?.balances);
+    return {
+      cursor: balances.pageInfo.endCursor ?? null,
+      hasNextPage: balances.pageInfo.hasNextPage,
+      balances: balances.nodes.map((balance) => ({
+        coinType: balance.coinType?.repr,
+        balance: balance.totalBalance
+      }))
+    };
+  }
+  async getTransaction(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetTransactionBlockDocument,
+      variables: { digest: options.digest }
+    }, (result2) => result2.transaction);
+    return {
+      transaction: parseTransaction(result)
+    };
+  }
+  async executeTransaction(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.ExecuteTransactionDocument,
+      variables: {
+        transactionDataBcs: (0, import_utils.toBase64)(options.transaction),
+        signatures: options.signatures
+      }
+    }, (result2) => result2.executeTransaction);
+    if (result.errors) {
+      if (result.errors.length === 1) {
+        throw new Error(result.errors[0]);
+      }
+      throw new AggregateError(
+        result.errors.map((error) => new Error(error))
+      );
+    }
+    return {
+      transaction: parseTransaction(result.effects?.transaction)
+    };
+  }
+  async dryRunTransaction(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.SimulateTransactionDocument,
+      variables: {
+        transaction: {
+          bcs: {
+            value: (0, import_utils.toBase64)(options.transaction)
+          }
+        }
+      }
+    }, (result2) => result2.simulateTransaction);
+    if (result.error) {
+      throw new Error(result.error);
+    }
+    return {
+      transaction: parseTransaction(result.effects?.transaction)
+    };
+  }
+  async getReferenceGasPrice() {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetReferenceGasPriceDocument
+    }, (result2) => result2.epoch?.referenceGasPrice);
+    return {
+      referenceGasPrice: result
+    };
+  }
+  async getDynamicFields(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetDynamicFieldsDocument,
+      variables: { parentId: options.parentId }
+    }, (result2) => result2.address?.dynamicFields);
+    return {
+      dynamicFields: result.nodes.map((dynamicField) => {
+        const valueType = dynamicField.value?.__typename === "MoveObject" ? dynamicField.value.contents?.type?.repr : dynamicField.value?.type?.repr;
+        return {
+          id: (0, import_dynamic_fields.deriveDynamicFieldID)(
+            options.parentId,
+            dynamicField.name?.type?.repr,
+            (0, import_utils.fromBase64)(dynamicField.name?.bcs)
+          ),
+          type: (0, import_sui_types.normalizeStructTag)(
+            dynamicField.value?.__typename === "MoveObject" ? `0x2::dynamic_field::Field<0x2::dynamic_object_field::Wrapper<${dynamicField.name?.type?.repr}>,0x2::object::ID>` : `0x2::dynamic_field::Field<${dynamicField.name?.type?.repr},${valueType}>`
+          ),
+          name: {
+            type: dynamicField.name?.type?.repr,
+            bcs: (0, import_utils.fromBase64)(dynamicField.name?.bcs)
+          },
+          valueType
+        };
+      }),
+      cursor: result.pageInfo.endCursor ?? null,
+      hasNextPage: result.pageInfo.hasNextPage
+    };
+  }
+  async verifyZkLoginSignature(options) {
+    const intentScope = options.intentScope === "TransactionData" ? import_queries.ZkLoginIntentScope.TransactionData : import_queries.ZkLoginIntentScope.PersonalMessage;
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.VerifyZkLoginSignatureDocument,
+      variables: {
+        bytes: options.bytes,
+        signature: options.signature,
+        intentScope,
+        author: options.author
+      }
+    }, (result2) => result2.verifyZkLoginSignature);
+    return {
+      success: result.success ?? false,
+      errors: result.error ? [result.error] : []
+    };
+  }
+  async defaultNameServiceName(options) {
+    const name = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.DefaultSuinsNameDocument,
+      signal: options.signal,
+      variables: {
+        address: options.address
+      }
+    }, (result) => result.address?.defaultSuinsName ?? null);
+    return {
+      data: { name }
+    };
+  }
+  async getMoveFunction(options) {
+    const moveFunction = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: import_queries.GetMoveFunctionDocument,
+      variables: {
+        package: (await this.mvr.resolvePackage({
+          package: options.packageId
+        })).package,
+        module: options.moduleName,
+        function: options.name
+      }
+    }, (result) => result.package?.module?.function);
+    let visibility = "unknown";
+    switch (moveFunction.visibility) {
+      case "PUBLIC":
+        visibility = "public";
+        break;
+      case "PRIVATE":
+        visibility = "private";
+        break;
+      case "FRIEND":
+        visibility = "friend";
+        break;
+    }
+    return {
+      function: {
+        packageId: (0, import_sui_types.normalizeWowAddress)(options.packageId),
+        moduleName: options.moduleName,
+        name: moveFunction.name,
+        visibility,
+        isEntry: moveFunction.isEntry ?? false,
+        typeParameters: moveFunction.typeParameters?.map(({ constraints }) => ({
+          isPhantom: false,
+          constraints: constraints.map((constraint) => {
+            switch (constraint) {
+              case "COPY":
+                return "copy";
+              case "DROP":
+                return "drop";
+              case "STORE":
+                return "store";
+              case "KEY":
+                return "key";
+              default:
+                return "unknown";
+            }
+          }) ?? []
+        })) ?? [],
+        parameters: moveFunction.parameters?.map(
+          (param) => parseNormalizedSuiMoveType(param.signature)
+        ) ?? [],
+        returns: moveFunction.return?.map(
+          ({ signature }) => parseNormalizedSuiMoveType(signature)
+        ) ?? []
+      }
+    };
+  }
+  resolveTransactionPlugin() {
+    throw new Error(
+      "GraphQL client does not support transaction resolution yet"
+    );
+  }
+}
+_graphqlClient = new WeakMap();
+_GraphQLCoreClient_instances = new WeakSet();
+graphqlQuery_fn = async function(options, getData) {
+  const { data, errors } = await __privateGet(this, _graphqlClient).query(options);
+  handleGraphQLErrors(errors);
+  const extractedData = data && (getData ? getData(data) : data);
+  if (extractedData == null) {
+    throw new Error("Missing response data");
+  }
+  return extractedData;
+};
+function handleGraphQLErrors(errors) {
+  if (!errors || errors.length === 0) return;
+  const errorInstances = errors.map(
+    (error) => new GraphQLResponseError(error)
+  );
+  if (errorInstances.length === 1) {
+    throw errorInstances[0];
+  }
+  throw new AggregateError(errorInstances);
+}
+class GraphQLResponseError extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "locations");
+    this.locations = error.locations;
+  }
+}
+function mapOwner(owner) {
+  switch (owner.__typename) {
+    case "AddressOwner":
+      return {
+        $kind: "AddressOwner",
+        AddressOwner: owner.address?.address
+      };
+    case "ConsensusAddressOwner":
+      return {
+        $kind: "ConsensusAddressOwner",
+        ConsensusAddressOwner: {
+          owner: owner?.address?.address,
+          startVersion: String(owner.startVersion)
+        }
+      };
+    case "ObjectOwner":
+      return {
+        $kind: "ObjectOwner",
+        ObjectOwner: owner.address?.address
+      };
+    case "Immutable":
+      return { $kind: "Immutable", Immutable: true };
+    case "Shared":
+      return {
+        $kind: "Shared",
+        Shared: {
+          initialSharedVersion: String(owner.initialSharedVersion)
+        }
+      };
+  }
+}
+function parseTransaction(transaction) {
+  const objectTypes = {};
+  transaction.effects?.unchangedConsensusObjects?.nodes.forEach((node) => {
+    if (node.__typename === "ConsensusObjectRead") {
+      const type = node.object?.asMoveObject?.contents?.type?.repr;
+      const address = node.object?.asMoveObject?.address;
+      if (type && address) {
+        objectTypes[address] = type;
+      }
+    }
+  });
+  transaction.effects?.objectChanges?.nodes.forEach((node) => {
+    const address = node.address;
+    const type = node.inputState?.asMoveObject?.contents?.type?.repr ?? node.outputState?.asMoveObject?.contents?.type?.repr;
+    if (address && type) {
+      objectTypes[address] = type;
+    }
+  });
+  if (transaction.effects?.balanceChanges?.pageInfo.hasNextPage) {
+    throw new Error("Pagination for balance changes is not supported");
+  }
+  return {
+    digest: transaction.digest,
+    effects: (0, import_utils2.parseTransactionEffectsBcs)(
+      (0, import_utils.fromBase64)(transaction.effects?.effectsBcs)
+    ),
+    epoch: transaction.effects?.epoch?.epochId?.toString() ?? null,
+    objectTypes: Promise.resolve(objectTypes),
+    transaction: (0, import_utils2.parseTransactionBcs)(
+      (0, import_utils.fromBase64)(transaction.transactionBcs)
+    ),
+    signatures: transaction.signatures.map((sig) => sig.signatureBytes),
+    balanceChanges: transaction.effects?.balanceChanges?.nodes.map((change) => ({
+      coinType: change?.coinType?.repr,
+      address: change.owner?.address,
+      amount: change.amount
+    })) ?? []
+    // events: transaction.events?.pageInfo.hasNextPage
+  };
+}
+function parseNormalizedSuiMoveType(type) {
+  let reference = null;
+  if (type.ref === "&") {
+    reference = "immutable";
+  } else if (type.ref === "&mut") {
+    reference = "mutable";
+  }
+  return {
+    reference,
+    body: parseNormalizedSuiMoveTypeBody(type.body)
+  };
+}
+function parseNormalizedSuiMoveTypeBody(type) {
+  switch (type) {
+    case "address":
+      return { $kind: "address" };
+    case "bool":
+      return { $kind: "bool" };
+    case "u8":
+      return { $kind: "u8" };
+    case "u16":
+      return { $kind: "u16" };
+    case "u32":
+      return { $kind: "u32" };
+    case "u64":
+      return { $kind: "u64" };
+    case "u128":
+      return { $kind: "u128" };
+    case "u256":
+      return { $kind: "u256" };
+  }
+  if (typeof type === "string") {
+    throw new Error(`Unknown type: ${type}`);
+  }
+  if ("vector" in type) {
+    return {
+      $kind: "vector",
+      vector: parseNormalizedSuiMoveTypeBody(type.vector)
+    };
+  }
+  if ("datatype" in type) {
+    return {
+      $kind: "datatype",
+      datatype: {
+        typeName: `${(0, import_sui_types.normalizeWowAddress)(type.datatype.package)}::${type.datatype.module}::${type.datatype.type}`,
+        typeParameters: type.datatype.typeParameters.map(
+          (t) => parseNormalizedSuiMoveTypeBody(t)
+        )
+      }
+    };
+  }
+  if ("typeParameter" in type) {
+    return {
+      $kind: "typeParameter",
+      index: type.typeParameter
+    };
+  }
+  throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+}