@haneullabs/haneul 0.1.0

package/dist/esm/graphql/client.d.ts

@@ -0,0 +1,50 @@
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { TadaDocumentNode } from 'gql.tada';
+import type { DocumentNode } from 'graphql';
+import { Experimental_BaseClient } from '../experimental/index.js';
+import type { Experimental_HaneulClientTypes } from '../experimental/index.js';
+import { GraphQLCoreClient } from './core.js';
+import type { TypedDocumentString } from './generated/queries.js';
+export type GraphQLDocument<Result = Record<string, unknown>, Variables = Record<string, unknown>> = string | DocumentNode | TypedDocumentString<Result, Variables> | TypedDocumentNode<Result, Variables> | TadaDocumentNode<Result, Variables>;
+export type GraphQLQueryOptions<Result = Record<string, unknown>, Variables = Record<string, unknown>> = {
+    query: GraphQLDocument<Result, Variables>;
+    operationName?: string;
+    extensions?: Record<string, unknown>;
+    signal?: AbortSignal;
+} & (Variables extends {
+    [key: string]: never;
+} ? {
+    variables?: Variables;
+} : {
+    variables: Variables;
+});
+export type GraphQLQueryResult<Result = Record<string, unknown>> = {
+    data?: Result;
+    errors?: GraphQLResponseErrors;
+    extensions?: Record<string, unknown>;
+};
+export type GraphQLResponseErrors = Array<{
+    message: string;
+    locations?: {
+        line: number;
+        column: number;
+    }[];
+    path?: (string | number)[];
+}>;
+export interface HaneulGraphQLClientOptions<Queries extends Record<string, GraphQLDocument>> {
+    url: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    queries?: Queries;
+    network?: Experimental_HaneulClientTypes.Network;
+    mvr?: Experimental_HaneulClientTypes.MvrOptions;
+}
+export declare class HaneulGraphQLRequestError extends Error {
+}
+export declare class HaneulGraphQLClient<Queries extends Record<string, GraphQLDocument> = {}> extends Experimental_BaseClient {
+    #private;
+    core: GraphQLCoreClient;
+    constructor({ url, fetch: fetchFn, headers, queries, network, mvr, }: HaneulGraphQLClientOptions<Queries>);
+    query<Result = Record<string, unknown>, Variables = Record<string, unknown>>(options: GraphQLQueryOptions<Result, Variables>): Promise<GraphQLQueryResult<Result>>;
+    execute<const Query extends Extract<keyof Queries, string>, Result = Queries[Query] extends GraphQLDocument<infer R, unknown> ? R : Record<string, unknown>, Variables = Queries[Query] extends GraphQLDocument<unknown, infer V> ? V : Record<string, unknown>>(query: Query, options: Omit<GraphQLQueryOptions<Result, Variables>, 'query'>): Promise<GraphQLQueryResult<Result>>;
+}

package/dist/esm/graphql/client.js

@@ -0,0 +1,74 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 _url, _queries, _headers, _fetch;
+import { print } from "graphql";
+import { Experimental_BaseClient } from "../experimental/index.js";
+import { GraphQLCoreClient } from "./core.js";
+class HaneulGraphQLRequestError extends Error {
+}
+class HaneulGraphQLClient extends Experimental_BaseClient {
+  constructor({
+    url,
+    fetch: fetchFn = fetch,
+    headers = {},
+    queries = {},
+    network = "unknown",
+    mvr
+  }) {
+    super({
+      network
+    });
+    __privateAdd(this, _url);
+    __privateAdd(this, _queries);
+    __privateAdd(this, _headers);
+    __privateAdd(this, _fetch);
+    __privateSet(this, _url, url);
+    __privateSet(this, _queries, queries);
+    __privateSet(this, _headers, headers);
+    __privateSet(this, _fetch, (...args) => fetchFn(...args));
+    this.core = new GraphQLCoreClient({
+      graphqlClient: this,
+      mvr
+    });
+  }
+  async query(options) {
+    const res = await __privateGet(this, _fetch).call(this, __privateGet(this, _url), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...__privateGet(this, _headers)
+      },
+      body: JSON.stringify({
+        query: typeof options.query === "string" || options.query instanceof String ? String(options.query) : print(options.query),
+        variables: options.variables,
+        extensions: options.extensions,
+        operationName: options.operationName
+      }),
+      signal: options.signal
+    });
+    if (!res.ok) {
+      throw new HaneulGraphQLRequestError(`GraphQL request failed: ${res.statusText} (${res.status})`);
+    }
+    return await res.json();
+  }
+  async execute(query, options) {
+    return this.query({
+      ...options,
+      query: __privateGet(this, _queries)[query]
+    });
+  }
+}
+_url = new WeakMap();
+_queries = new WeakMap();
+_headers = new WeakMap();
+_fetch = new WeakMap();
+export {
+  HaneulGraphQLClient,
+  HaneulGraphQLRequestError
+};
+//# sourceMappingURL=client.js.map

package/dist/esm/graphql/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/graphql/client.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { TypedDocumentNode } from '@graphql-typed-document-node/core';\nimport type { TadaDocumentNode } from 'gql.tada';\nimport type { DocumentNode } from 'graphql';\nimport { print } from 'graphql';\nimport { Experimental_BaseClient } from '../experimental/index.js';\nimport type { Experimental_HaneulClientTypes } from '../experimental/index.js';\nimport { GraphQLCoreClient } from './core.js';\nimport type { TypedDocumentString } from './generated/queries.js';\n\nexport type GraphQLDocument<\n\tResult = Record<string, unknown>,\n\tVariables = Record<string, unknown>,\n> =\n\t| string\n\t| DocumentNode\n\t| TypedDocumentString<Result, Variables>\n\t| TypedDocumentNode<Result, Variables>\n\t| TadaDocumentNode<Result, Variables>;\n\nexport type GraphQLQueryOptions<\n\tResult = Record<string, unknown>,\n\tVariables = Record<string, unknown>,\n> = {\n\tquery: GraphQLDocument<Result, Variables>;\n\toperationName?: string;\n\textensions?: Record<string, unknown>;\n\tsignal?: AbortSignal;\n} & (Variables extends { [key: string]: never }\n\t? { variables?: Variables }\n\t: {\n\t\t\tvariables: Variables;\n\t\t});\n\nexport type GraphQLQueryResult<Result = Record<string, unknown>> = {\n\tdata?: Result;\n\terrors?: GraphQLResponseErrors;\n\textensions?: Record<string, unknown>;\n};\n\nexport type GraphQLResponseErrors = Array<{\n\tmessage: string;\n\tlocations?: { line: number; column: number }[];\n\tpath?: (string | number)[];\n}>;\n\nexport interface HaneulGraphQLClientOptions<Queries extends Record<string, GraphQLDocument>> {\n\turl: string;\n\tfetch?: typeof fetch;\n\theaders?: Record<string, string>;\n\tqueries?: Queries;\n\tnetwork?: Experimental_HaneulClientTypes.Network;\n\tmvr?: Experimental_HaneulClientTypes.MvrOptions;\n}\n\nexport class HaneulGraphQLRequestError extends Error {}\n\nexport class HaneulGraphQLClient<\n\t// eslint-disable-next-line @typescript-eslint/ban-types\n\tQueries extends Record<string, GraphQLDocument> = {},\n> extends Experimental_BaseClient {\n\t#url: string;\n\t#queries: Queries;\n\t#headers: Record<string, string>;\n\t#fetch: typeof fetch;\n\tcore: GraphQLCoreClient;\n\n\tconstructor({\n\t\turl,\n\t\tfetch: fetchFn = fetch,\n\t\theaders = {},\n\t\tqueries = {} as Queries,\n\t\tnetwork = 'unknown',\n\t\tmvr,\n\t}: HaneulGraphQLClientOptions<Queries>) {\n\t\tsuper({\n\t\t\tnetwork,\n\t\t});\n\t\tthis.#url = url;\n\t\tthis.#queries = queries;\n\t\tthis.#headers = headers;\n\t\tthis.#fetch = (...args) => fetchFn(...args);\n\t\tthis.core = new GraphQLCoreClient({\n\t\t\tgraphqlClient: this,\n\t\t\tmvr,\n\t\t});\n\t}\n\n\tasync query<Result = Record<string, unknown>, Variables = Record<string, unknown>>(\n\t\toptions: GraphQLQueryOptions<Result, Variables>,\n\t): Promise<GraphQLQueryResult<Result>> {\n\t\tconst res = await this.#fetch(this.#url, {\n\t\t\tmethod: 'POST',\n\t\t\theaders: {\n\t\t\t\t'Content-Type': 'application/json',\n\t\t\t\t...this.#headers,\n\t\t\t},\n\t\t\tbody: JSON.stringify({\n\t\t\t\tquery:\n\t\t\t\t\ttypeof options.query === 'string' || options.query instanceof String\n\t\t\t\t\t\t? String(options.query)\n\t\t\t\t\t\t: print(options.query),\n\t\t\t\tvariables: options.variables,\n\t\t\t\textensions: options.extensions,\n\t\t\t\toperationName: options.operationName,\n\t\t\t}),\n\t\t\tsignal: options.signal,\n\t\t});\n\n\t\tif (!res.ok) {\n\t\t\tthrow new HaneulGraphQLRequestError(`GraphQL request failed: ${res.statusText} (${res.status})`);\n\t\t}\n\n\t\treturn await res.json();\n\t}\n\n\tasync execute<\n\t\tconst Query extends Extract<keyof Queries, string>,\n\t\tResult = Queries[Query] extends GraphQLDocument<infer R, unknown> ? R : Record<string, unknown>,\n\t\tVariables = Queries[Query] extends GraphQLDocument<unknown, infer V>\n\t\t\t? V\n\t\t\t: Record<string, unknown>,\n\t>(\n\t\tquery: Query,\n\t\toptions: Omit<GraphQLQueryOptions<Result, Variables>, 'query'>,\n\t): Promise<GraphQLQueryResult<Result>> {\n\t\treturn this.query({\n\t\t\t...(options as { variables: Record<string, unknown> }),\n\t\t\tquery: this.#queries[query]!,\n\t\t}) as Promise<GraphQLQueryResult<Result>>;\n\t}\n}\n"],
+  "mappings": ";;;;;;;AAAA;AAMA,SAAS,aAAa;AACtB,SAAS,+BAA+B;AAExC,SAAS,yBAAyB;AAgD3B,MAAM,kCAAkC,MAAM;AAAC;AAE/C,MAAM,4BAGH,wBAAwB;AAAA,EAOjC,YAAY;AAAA,IACX;AAAA,IACA,OAAO,UAAU;AAAA,IACjB,UAAU,CAAC;AAAA,IACX,UAAU,CAAC;AAAA,IACX,UAAU;AAAA,IACV;AAAA,EACD,GAAwC;AACvC,UAAM;AAAA,MACL;AAAA,IACD,CAAC;AAhBF;AACA;AACA;AACA;AAcC,uBAAK,MAAO;AACZ,uBAAK,UAAW;AAChB,uBAAK,UAAW;AAChB,uBAAK,QAAS,IAAI,SAAS,QAAQ,GAAG,IAAI;AAC1C,SAAK,OAAO,IAAI,kBAAkB;AAAA,MACjC,eAAe;AAAA,MACf;AAAA,IACD,CAAC;AAAA,EACF;AAAA,EAEA,MAAM,MACL,SACsC;AACtC,UAAM,MAAM,MAAM,mBAAK,QAAL,WAAY,mBAAK,OAAM;AAAA,MACxC,QAAQ;AAAA,MACR,SAAS;AAAA,QACR,gBAAgB;AAAA,QAChB,GAAG,mBAAK;AAAA,MACT;AAAA,MACA,MAAM,KAAK,UAAU;AAAA,QACpB,OACC,OAAO,QAAQ,UAAU,YAAY,QAAQ,iBAAiB,SAC3D,OAAO,QAAQ,KAAK,IACpB,MAAM,QAAQ,KAAK;AAAA,QACvB,WAAW,QAAQ;AAAA,QACnB,YAAY,QAAQ;AAAA,QACpB,eAAe,QAAQ;AAAA,MACxB,CAAC;AAAA,MACD,QAAQ,QAAQ;AAAA,IACjB;AAEA,QAAI,CAAC,IAAI,IAAI;AACZ,YAAM,IAAI,0BAA0B,2BAA2B,IAAI,UAAU,KAAK,IAAI,MAAM,GAAG;AAAA,IAChG;AAEA,WAAO,MAAM,IAAI,KAAK;AAAA,EACvB;AAAA,EAEA,MAAM,QAOL,OACA,SACsC;AACtC,WAAO,KAAK,MAAM;AAAA,MACjB,GAAI;AAAA,MACJ,OAAO,mBAAK,UAAS,KAAK;AAAA,IAC3B,CAAC;AAAA,EACF;AACD;AAtEC;AACA;AACA;AACA;",
+  "names": []
+}

package/dist/esm/graphql/core.d.ts

@@ -0,0 +1,32 @@
+import { Experimental_CoreClient } from '../experimental/core.js';
+import type { Experimental_HaneulClientTypes } from '../experimental/types.js';
+import type { HaneulGraphQLClient } from './client.js';
+export declare class GraphQLCoreClient extends Experimental_CoreClient {
+    #private;
+    constructor({ graphqlClient, mvr, }: {
+        graphqlClient: HaneulGraphQLClient;
+        mvr?: Experimental_HaneulClientTypes.MvrOptions;
+    });
+    getObjects(options: Experimental_HaneulClientTypes.GetObjectsOptions): Promise<Experimental_HaneulClientTypes.GetObjectsResponse>;
+    getOwnedObjects(options: Experimental_HaneulClientTypes.GetOwnedObjectsOptions): Promise<Experimental_HaneulClientTypes.GetOwnedObjectsResponse>;
+    getCoins(options: Experimental_HaneulClientTypes.GetCoinsOptions): Promise<Experimental_HaneulClientTypes.GetCoinsResponse>;
+    getBalance(options: Experimental_HaneulClientTypes.GetBalanceOptions): Promise<Experimental_HaneulClientTypes.GetBalanceResponse>;
+    getAllBalances(options: Experimental_HaneulClientTypes.GetAllBalancesOptions): Promise<Experimental_HaneulClientTypes.GetAllBalancesResponse>;
+    getTransaction(options: Experimental_HaneulClientTypes.GetTransactionOptions): Promise<Experimental_HaneulClientTypes.GetTransactionResponse>;
+    executeTransaction(options: Experimental_HaneulClientTypes.ExecuteTransactionOptions): Promise<Experimental_HaneulClientTypes.ExecuteTransactionResponse>;
+    dryRunTransaction(options: Experimental_HaneulClientTypes.DryRunTransactionOptions): Promise<Experimental_HaneulClientTypes.DryRunTransactionResponse>;
+    getReferenceGasPrice(): Promise<Experimental_HaneulClientTypes.GetReferenceGasPriceResponse>;
+    getDynamicFields(options: Experimental_HaneulClientTypes.GetDynamicFieldsOptions): Promise<Experimental_HaneulClientTypes.GetDynamicFieldsResponse>;
+    verifyZkLoginSignature(options: Experimental_HaneulClientTypes.VerifyZkLoginSignatureOptions): Promise<Experimental_HaneulClientTypes.ZkLoginVerifyResponse>;
+    defaultNameServiceName(options: Experimental_HaneulClientTypes.DefaultNameServiceNameOptions): Promise<Experimental_HaneulClientTypes.DefaultNameServiceNameResponse>;
+    getMoveFunction(options: Experimental_HaneulClientTypes.GetMoveFunctionOptions): Promise<Experimental_HaneulClientTypes.GetMoveFunctionResponse>;
+    resolveTransactionPlugin(): never;
+}
+export type GraphQLResponseErrors = Array<{
+    message: string;
+    locations?: {
+        line: number;
+        column: number;
+    }[];
+    path?: (string | number)[];
+}>;

package/dist/esm/graphql/core.js

@@ -0,0 +1,469 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 _graphqlClient, _GraphQLCoreClient_instances, graphqlQuery_fn;
+import { Experimental_CoreClient } from "../experimental/core.js";
+import {
+  DefaultHaneulnsNameDocument,
+  ExecuteTransactionDocument,
+  GetAllBalancesDocument,
+  GetBalanceDocument,
+  GetCoinsDocument,
+  GetDynamicFieldsDocument,
+  GetMoveFunctionDocument,
+  GetOwnedObjectsDocument,
+  GetReferenceGasPriceDocument,
+  GetTransactionBlockDocument,
+  MultiGetObjectsDocument,
+  SimulateTransactionDocument,
+  VerifyZkLoginSignatureDocument,
+  ZkLoginIntentScope
+} from "./generated/queries.js";
+import { ObjectError } from "../experimental/errors.js";
+import { chunk, fromBase64, toBase64 } from "@haneullabs/utils";
+import { normalizeStructTag, normalizeHaneulAddress } from "../utils/haneul-types.js";
+import { deriveDynamicFieldID } from "../utils/dynamic-fields.js";
+import {
+  parseTransactionBcs,
+  parseTransactionEffectsBcs
+} from "../experimental/transports/utils.js";
+class GraphQLCoreClient extends 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 = chunk(options.objectIds, 50);
+    const results = [];
+    for (const batch of batches) {
+      const page = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+        query: MultiGetObjectsDocument,
+        variables: {
+          objectKeys: batch.map((address) => ({ address }))
+        }
+      }, (result) => result.multiGetObjects);
+      results.push(
+        ...batch.map((id) => normalizeHaneulAddress(id)).map(
+          (id) => page.find((obj) => obj?.address === id) ?? new ObjectError("notFound", `Object ${id} not found`)
+        ).map((obj) => {
+          if (obj instanceof 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 ? 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: 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 ? 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: 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 ? 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: 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: 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: 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: ExecuteTransactionDocument,
+      variables: {
+        transactionDataBcs: 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: SimulateTransactionDocument,
+      variables: {
+        transaction: {
+          bcs: {
+            value: 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: GetReferenceGasPriceDocument
+    }, (result2) => result2.epoch?.referenceGasPrice);
+    return {
+      referenceGasPrice: result
+    };
+  }
+  async getDynamicFields(options) {
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: 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: deriveDynamicFieldID(
+            options.parentId,
+            dynamicField.name?.type?.repr,
+            fromBase64(dynamicField.name?.bcs)
+          ),
+          type: 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: fromBase64(dynamicField.name?.bcs)
+          },
+          valueType
+        };
+      }),
+      cursor: result.pageInfo.endCursor ?? null,
+      hasNextPage: result.pageInfo.hasNextPage
+    };
+  }
+  async verifyZkLoginSignature(options) {
+    const intentScope = options.intentScope === "TransactionData" ? ZkLoginIntentScope.TransactionData : ZkLoginIntentScope.PersonalMessage;
+    const result = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: 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: DefaultHaneulnsNameDocument,
+      signal: options.signal,
+      variables: {
+        address: options.address
+      }
+    }, (result) => result.address?.defaultHaneulnsName ?? null);
+    return {
+      data: { name }
+    };
+  }
+  async getMoveFunction(options) {
+    const moveFunction = await __privateMethod(this, _GraphQLCoreClient_instances, graphqlQuery_fn).call(this, {
+      query: 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: normalizeHaneulAddress(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);
+    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: parseTransactionEffectsBcs(fromBase64(transaction.effects?.effectsBcs)),
+    epoch: transaction.effects?.epoch?.epochId?.toString() ?? null,
+    objectTypes: Promise.resolve(objectTypes),
+    transaction: parseTransactionBcs(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: `${normalizeHaneulAddress(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)}`);
+}
+export {
+  GraphQLCoreClient
+};
+//# sourceMappingURL=core.js.map