@ledgerhq/coin-aptos 1.10.0-nightly.0 → 2.0.0-nightly.1

package/src/api/index.ts

@@ -1,252 +1,32 @@
-import { ApolloClient, InMemoryCache } from "@apollo/client";
-
-import {
-  AccountData,
-  Aptos,
-  AptosApiType,
-  AptosConfig,
-  Ed25519PublicKey,
-  GasEstimation,
-  InputEntryFunctionData,
-  InputGenerateTransactionOptions,
-  MimeType,
-  post,
-  RawTransaction,
-  SimpleTransaction,
-  TransactionResponse,
-  UserTransactionResponse,
-  PostRequestOptions,
-  Block,
-} from "@aptos-labs/ts-sdk";
-import { getEnv } from "@ledgerhq/live-env";
-import network from "@ledgerhq/live-network";
-import BigNumber from "bignumber.js";
-import isUndefined from "lodash/isUndefined";
-import { APTOS_ASSET_ID } from "../constants";
-import { isTestnet } from "../bridge/logic";
-import type { AptosTransaction, TransactionOptions } from "../types";
-import { GetAccountTransactionsData, GetAccountTransactionsDataGt } from "./graphql/queries";
-import {
-  GetAccountTransactionsDataQuery,
-  GetAccountTransactionsDataGtQueryVariables,
-} from "./graphql/types";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-const getApiEndpoint = (currencyId: string) =>
-  isTestnet(currencyId) ? getEnv("APTOS_TESTNET_API_ENDPOINT") : getEnv("APTOS_API_ENDPOINT");
-const getIndexerEndpoint = (currencyId: string) =>
-  isTestnet(currencyId)
-    ? getEnv("APTOS_TESTNET_INDEXER_ENDPOINT")
-    : getEnv("APTOS_INDEXER_ENDPOINT");
-
-export class AptosAPI {
-  private apiUrl: string;
-  private indexerUrl: string;
-  private aptosConfig: AptosConfig;
-  private aptosClient: Aptos;
-  private apolloClient: ApolloClient<object>;
-
-  constructor(currencyId: string) {
-    this.apiUrl = getApiEndpoint(currencyId);
-    this.indexerUrl = getIndexerEndpoint(currencyId);
-    this.aptosConfig = new AptosConfig({
-      fullnode: this.apiUrl,
-      indexer: this.indexerUrl,
-    });
-    this.aptosClient = new Aptos(this.aptosConfig);
-    this.apolloClient = new ApolloClient({
-      uri: this.indexerUrl,
-      cache: new InMemoryCache(),
-      headers: {
-        "x-client": "ledger-live",
-      },
-    });
-  }
-
-  async getAccount(address: string): Promise<AccountData> {
-    return this.aptosClient.getAccountInfo({ accountAddress: address });
-  }
-
-  async getAccountInfo(address: string, startAt?: string) {
-    const [balance, transactions, blockHeight] = await Promise.all([
-      this.getCoinBalance(address, APTOS_ASSET_ID),
-      this.fetchTransactions(address, startAt),
-      this.getHeight(),
-    ]);
-
-    return {
-      balance,
-      transactions,
-      blockHeight,
-    };
-  }
-
-  async estimateGasPrice(): Promise<GasEstimation> {
-    return this.aptosClient.getGasPriceEstimation();
-  }
-
-  async generateTransaction(
-    address: string,
-    payload: InputEntryFunctionData,
-    options: TransactionOptions,
-  ): Promise<RawTransaction> {
-    const opts: Partial<InputGenerateTransactionOptions> = {};
-    if (!isUndefined(options.maxGasAmount)) {
-      opts.maxGasAmount = Number(options.maxGasAmount);
-    }
-
-    if (!isUndefined(options.gasUnitPrice)) {
-      opts.gasUnitPrice = Number(options.gasUnitPrice);
-    }
-
-    try {
-      const { ledger_timestamp } = await this.aptosClient.getLedgerInfo();
-      opts.expireTimestamp = Number(Math.ceil(+ledger_timestamp / 1_000_000 + 2 * 60)); // in milliseconds
-    } catch {
-      // skip
-    }
-
-    return this.aptosClient.transaction.build
-      .simple({
-        sender: address,
-        data: payload,
-        options: opts,
-      })
-      .then(t => t.rawTransaction)
-      .catch(error => {
-        throw error;
-      });
-  }
-
-  async simulateTransaction(
-    address: Ed25519PublicKey,
-    tx: RawTransaction,
-    options = {
-      estimateGasUnitPrice: true,
-      estimateMaxGasAmount: true,
-      estimatePrioritizedGasUnitPrice: false,
+import type { Api } from "@ledgerhq/coin-framework/api/index";
+import type { AptosConfig as AptosConfigApi } from "../config";
+import type { Balance, FeeEstimation, Operation } from "@ledgerhq/coin-framework/api/types";
+import coinConfig from "../config";
+import type { AptosAsset } from "../types/assets";
+import { AptosAPI } from "../network";
+
+export function createApi(config: AptosConfigApi): Api<AptosAsset> {
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
+
+  const client = new AptosAPI(config.aptosSettings);
+
+  return {
+    broadcast: (tx: string) => client.broadcast(tx),
+    combine: (_tx, _signature, _pubkey): string => {
+      throw new Error("Not Implemented");
     },
-  ): Promise<UserTransactionResponse[]> {
-    return this.aptosClient.transaction.simulate.simple({
-      signerPublicKey: address,
-      transaction: { rawTransaction: tx } as SimpleTransaction,
-      options,
-    });
-  }
-
-  async broadcast(signature: string): Promise<string> {
-    const txBytes = Uint8Array.from(Buffer.from(signature, "hex"));
-    const pendingTx = await post<PostRequestOptions, TransactionResponse>({
-      contentType: MimeType.BCS_SIGNED_TRANSACTION,
-      aptosConfig: this.aptosClient.config,
-      body: txBytes,
-      path: "transactions",
-      type: AptosApiType.FULLNODE,
-      originMethod: "",
-    });
-    return pendingTx.data.hash;
-  }
-
-  async getBalance(address: string, token: TokenCurrency): Promise<BigNumber> {
-    let balance = new BigNumber(0);
-    if (token.tokenType === "coin") {
-      balance = await this.getCoinBalance(address, token.contractAddress);
-    } else {
-      balance = await this.getFABalance(address, token.contractAddress);
-    }
-    return balance;
-  }
-
-  async getCoinBalance(address: string, contract_address: string): Promise<BigNumber> {
-    try {
-      const [balanceStr] = await this.aptosClient.view<[string]>({
-        payload: {
-          function: "0x1::coin::balance",
-          typeArguments: [contract_address],
-          functionArguments: [address],
-        },
-      });
-      const balance = parseInt(balanceStr, 10);
-      return new BigNumber(balance);
-    } catch (_) {
-      return new BigNumber(0);
-    }
-  }
-
-  async getFABalance(address: string, contract_address: string): Promise<BigNumber> {
-    try {
-      const [balanceStr] = await this.aptosClient.view<[string]>({
-        payload: {
-          function: "0x1::primary_fungible_store::balance",
-          typeArguments: ["0x1::object::ObjectCore"],
-          functionArguments: [address, contract_address],
-        },
-      });
-      const balance = parseInt(balanceStr, 10);
-      return new BigNumber(balance);
-    } catch (_) {
-      return new BigNumber(0);
-    }
-  }
-
-  private async fetchTransactions(address: string, gt?: string) {
-    if (!address) {
-      return [];
-    }
-
-    let query = GetAccountTransactionsData;
-    if (gt) {
-      query = GetAccountTransactionsDataGt;
-    }
-
-    const queryResponse = await this.apolloClient.query<
-      GetAccountTransactionsDataQuery,
-      GetAccountTransactionsDataGtQueryVariables
-    >({
-      query,
-      variables: {
-        address,
-        limit: 1000,
-        gt,
-      },
-      fetchPolicy: "network-only",
-    });
-
-    return Promise.all(
-      queryResponse.data.account_transactions.map(({ transaction_version }) => {
-        return this.richItemByVersion(transaction_version);
-      }),
-    );
-  }
-
-  private async richItemByVersion(version: number): Promise<AptosTransaction | null> {
-    try {
-      const tx: TransactionResponse = await this.aptosClient.getTransactionByVersion({
-        ledgerVersion: version,
-      });
-      const block = await this.getBlock(version);
-      return {
-        ...tx,
-        block,
-      } as AptosTransaction;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  private async getHeight(): Promise<number> {
-    const { data } = await network<Block>({
-      method: "GET",
-      url: this.apiUrl,
-    });
-    return parseInt(data.block_height);
-  }
-
-  private async getBlock(version: number) {
-    const block = await this.aptosClient.getBlockByVersion({ ledgerVersion: version });
-    return {
-      height: parseInt(block.block_height),
-      hash: block.block_hash,
-    };
-  }
+    craftTransaction: (_transactionIntent, _customFees): Promise<string> => {
+      throw new Error("Not Implemented");
+    },
+    estimateFees: (_transactionIntent): Promise<FeeEstimation<never>> => {
+      throw new Error("Not Implemented");
+    },
+    getBalance: (_address): Promise<Balance<AptosAsset>[]> => {
+      throw new Error("Not Implemented");
+    },
+    lastBlock: () => client.getLastBlock(),
+    listOperations: (_address, _pagination): Promise<[Operation<AptosAsset>[], string]> => {
+      throw new Error("Not Implemented");
+    },
+  };
 }

package/src/bridge/broadcast.ts

@@ -1,16 +1,16 @@
 import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 
-const broadcast = async ({
-  signedOperation,
-  account,
-}: {
+type broadcastFunc = {
   signedOperation: SignedOperation;
   account: Account;
-}): Promise<Operation> => {
+};
+
+const broadcast = async ({ signedOperation, account }: broadcastFunc): Promise<Operation> => {
   const { signature, operation } = signedOperation;
-  const hash = await new AptosAPI(account.currency.id).broadcast(signature);
+  const client = new AptosAPI(account.currency.id);
+  const hash = await client.broadcast(signature);
   return patchOperationWithHash(operation, hash);
 };
 

package/src/bridge/buildTransaction.ts

@@ -1,8 +1,8 @@
 import { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
 import type { Account, TokenAccount } from "@ledgerhq/types-live";
 import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/index";
-import { AptosAPI } from "../api";
 import { APTOS_ASSET_ID, SUPPORTED_TOKEN_TYPES } from "../constants";
+import { AptosAPI } from "../network";
 import { normalizeTransactionOptions } from "./logic";
 import type { Transaction } from "../types";
 

package/src/bridge/estimateMaxSpendable.ts

@@ -1,7 +1,7 @@
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
 import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";
 import type { Transaction } from "../types";

package/src/bridge/getFeesForTransaction.ts

@@ -3,7 +3,7 @@ import { log } from "@ledgerhq/logs";
 import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 import buildTransaction from "./buildTransaction";
 import { DEFAULT_GAS, DEFAULT_GAS_PRICE, ESTIMATE_GAS_MUL, getTokenAccount } from "./logic";
 import type { Transaction, TransactionErrors } from "../types";

package/src/bridge/index.ts

@@ -6,7 +6,7 @@ import {
   updateTransaction,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import resolver from "../signer";
 import type { Transaction, TransactionStatus, AptosSigner } from "../types";

package/src/bridge/prepareTransaction.ts

@@ -1,6 +1,7 @@
 import type { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
-import { AptosAPI } from "../api";
+
+import { AptosAPI } from "../network";
 import { getEstimatedGas } from "./getFeesForTransaction";
 import type { Transaction } from "../types";
 import { DEFAULT_GAS, DEFAULT_GAS_PRICE, getMaxSendBalance } from "./logic";

package/src/bridge/signOperation.ts

@@ -4,7 +4,7 @@ import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import buildTransaction from "./buildTransaction";
 import BigNumber from "bignumber.js";
 import type { Account, AccountBridge, Operation, OperationType } from "@ledgerhq/types-live";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { AptosSigner } from "../types";

package/src/bridge/synchronisation.ts

@@ -2,7 +2,7 @@ import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index
 import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account";
 import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { AptosAPI } from "../api";
+import { AptosAPI } from "../network";
 import { txsToOps } from "./logic";
 import type { AptosAccount } from "../types";
 import { Account, Operation, TokenAccount } from "@ledgerhq/types-live";

package/src/config.ts

@@ -0,0 +1,19 @@
+import { type AptosSettings } from "@aptos-labs/ts-sdk";
+import buildCoinConfig, {
+  type CoinConfig,
+  type CurrencyConfig,
+} from "@ledgerhq/coin-framework/config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+export type AptosConfig = {
+  aptosSettings: AptosSettings;
+};
+
+export type AptosCoinConfig = CurrencyConfig & AptosConfig;
+
+const coinConfig: {
+  setCoinConfig: (config: CoinConfig<AptosCoinConfig>) => void;
+  getCoinConfig: (currency?: CryptoCurrency) => AptosCoinConfig;
+} = buildCoinConfig<AptosCoinConfig>();
+
+export default coinConfig;

package/src/network/client.ts

@@ -0,0 +1,265 @@
+import { ApolloClient, InMemoryCache } from "@apollo/client";
+
+import {
+  AccountData,
+  Aptos,
+  AptosApiType,
+  AptosConfig,
+  Ed25519PublicKey,
+  GasEstimation,
+  InputEntryFunctionData,
+  InputGenerateTransactionOptions,
+  MimeType,
+  post,
+  RawTransaction,
+  SimpleTransaction,
+  TransactionResponse,
+  UserTransactionResponse,
+  PostRequestOptions,
+  Block,
+  AptosSettings,
+} from "@aptos-labs/ts-sdk";
+import { getEnv } from "@ledgerhq/live-env";
+import network from "@ledgerhq/live-network";
+import BigNumber from "bignumber.js";
+import isUndefined from "lodash/isUndefined";
+import { APTOS_ASSET_ID } from "../constants";
+import { isTestnet } from "../bridge/logic";
+import type { AptosTransaction, TransactionOptions } from "../types";
+import { GetAccountTransactionsData, GetAccountTransactionsDataGt } from "./graphql/queries";
+import {
+  GetAccountTransactionsDataQuery,
+  GetAccountTransactionsDataGtQueryVariables,
+} from "./graphql/types";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { BlockInfo } from "@ledgerhq/coin-framework/api/types";
+
+const getApiEndpoint = (currencyId: string) =>
+  isTestnet(currencyId) ? getEnv("APTOS_TESTNET_API_ENDPOINT") : getEnv("APTOS_API_ENDPOINT");
+const getIndexerEndpoint = (currencyId: string) =>
+  isTestnet(currencyId)
+    ? getEnv("APTOS_TESTNET_INDEXER_ENDPOINT")
+    : getEnv("APTOS_INDEXER_ENDPOINT");
+
+export class AptosAPI {
+  private aptosConfig: AptosConfig;
+  private aptosClient: Aptos;
+  private apolloClient: ApolloClient<object>;
+
+  constructor(currencyIdOrSettings: AptosSettings | string) {
+    if (typeof currencyIdOrSettings === "string") {
+      this.aptosConfig = new AptosConfig({
+        fullnode: getApiEndpoint(currencyIdOrSettings),
+        indexer: getIndexerEndpoint(currencyIdOrSettings),
+      });
+    } else {
+      this.aptosConfig = new AptosConfig(currencyIdOrSettings);
+    }
+
+    this.aptosClient = new Aptos(this.aptosConfig);
+    this.apolloClient = new ApolloClient({
+      uri: this.aptosConfig.indexer || "",
+      cache: new InMemoryCache(),
+      headers: {
+        "x-client": "ledger-live",
+      },
+    });
+  }
+
+  async getAccount(address: string): Promise<AccountData> {
+    return this.aptosClient.getAccountInfo({ accountAddress: address });
+  }
+
+  async getAccountInfo(address: string, startAt?: string) {
+    const [balance, transactions, blockHeight] = await Promise.all([
+      this.getCoinBalance(address, APTOS_ASSET_ID),
+      this.fetchTransactions(address, startAt),
+      this.getHeight(),
+    ]);
+
+    return {
+      balance,
+      transactions,
+      blockHeight,
+    };
+  }
+
+  async estimateGasPrice(): Promise<GasEstimation> {
+    return this.aptosClient.getGasPriceEstimation();
+  }
+
+  async generateTransaction(
+    address: string,
+    payload: InputEntryFunctionData,
+    options: TransactionOptions,
+  ): Promise<RawTransaction> {
+    const opts: Partial<InputGenerateTransactionOptions> = {};
+    if (!isUndefined(options.maxGasAmount)) {
+      opts.maxGasAmount = Number(options.maxGasAmount);
+    }
+
+    if (!isUndefined(options.gasUnitPrice)) {
+      opts.gasUnitPrice = Number(options.gasUnitPrice);
+    }
+
+    try {
+      const { ledger_timestamp } = await this.aptosClient.getLedgerInfo();
+      opts.expireTimestamp = Number(Math.ceil(+ledger_timestamp / 1_000_000 + 2 * 60)); // in milliseconds
+    } catch {
+      // skip
+    }
+
+    return this.aptosClient.transaction.build
+      .simple({
+        sender: address,
+        data: payload,
+        options: opts,
+      })
+      .then(t => t.rawTransaction)
+      .catch(error => {
+        throw error;
+      });
+  }
+
+  async simulateTransaction(
+    address: Ed25519PublicKey,
+    tx: RawTransaction,
+    options = {
+      estimateGasUnitPrice: true,
+      estimateMaxGasAmount: true,
+      estimatePrioritizedGasUnitPrice: false,
+    },
+  ): Promise<UserTransactionResponse[]> {
+    return this.aptosClient.transaction.simulate.simple({
+      signerPublicKey: address,
+      transaction: { rawTransaction: tx } as SimpleTransaction,
+      options,
+    });
+  }
+
+  async broadcast(signature: string): Promise<string> {
+    const txBytes = Uint8Array.from(Buffer.from(signature, "hex"));
+    const pendingTx = await post<PostRequestOptions, TransactionResponse>({
+      contentType: MimeType.BCS_SIGNED_TRANSACTION,
+      aptosConfig: this.aptosClient.config,
+      body: txBytes,
+      path: "transactions",
+      type: AptosApiType.FULLNODE,
+      originMethod: "",
+    });
+    return pendingTx.data.hash;
+  }
+
+  async getBalance(address: string, token: TokenCurrency): Promise<BigNumber> {
+    let balance = new BigNumber(0);
+    if (token.tokenType === "coin") {
+      balance = await this.getCoinBalance(address, token.contractAddress);
+    } else {
+      balance = await this.getFABalance(address, token.contractAddress);
+    }
+    return balance;
+  }
+
+  async getLastBlock(): Promise<BlockInfo> {
+    const { block_height } = await this.aptosClient.getLedgerInfo();
+    const block = await this.aptosClient.getBlockByHeight({ blockHeight: Number(block_height) });
+    return {
+      height: Number(block.block_height),
+      hash: block.block_hash,
+      time: new Date(Number(block.block_timestamp)),
+    };
+  }
+
+  async getCoinBalance(address: string, contract_address: string): Promise<BigNumber> {
+    try {
+      const [balanceStr] = await this.aptosClient.view<[string]>({
+        payload: {
+          function: "0x1::coin::balance",
+          typeArguments: [contract_address],
+          functionArguments: [address],
+        },
+      });
+      const balance = parseInt(balanceStr, 10);
+      return new BigNumber(balance);
+    } catch (_) {
+      return new BigNumber(0);
+    }
+  }
+
+  async getFABalance(address: string, contract_address: string): Promise<BigNumber> {
+    try {
+      const [balanceStr] = await this.aptosClient.view<[string]>({
+        payload: {
+          function: "0x1::primary_fungible_store::balance",
+          typeArguments: ["0x1::object::ObjectCore"],
+          functionArguments: [address, contract_address],
+        },
+      });
+      const balance = parseInt(balanceStr, 10);
+      return new BigNumber(balance);
+    } catch (_) {
+      return new BigNumber(0);
+    }
+  }
+
+  private async fetchTransactions(address: string, gt?: string) {
+    if (!address) {
+      return [];
+    }
+
+    let query = GetAccountTransactionsData;
+    if (gt) {
+      query = GetAccountTransactionsDataGt;
+    }
+
+    const queryResponse = await this.apolloClient.query<
+      GetAccountTransactionsDataQuery,
+      GetAccountTransactionsDataGtQueryVariables
+    >({
+      query,
+      variables: {
+        address,
+        limit: 1000,
+        gt,
+      },
+      fetchPolicy: "network-only",
+    });
+
+    return Promise.all(
+      queryResponse.data.account_transactions.map(({ transaction_version }) => {
+        return this.richItemByVersion(transaction_version);
+      }),
+    );
+  }
+
+  private async richItemByVersion(version: number): Promise<AptosTransaction | null> {
+    try {
+      const tx: TransactionResponse = await this.aptosClient.getTransactionByVersion({
+        ledgerVersion: version,
+      });
+      const block = await this.getBlock(version);
+      return {
+        ...tx,
+        block,
+      } as AptosTransaction;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private async getHeight(): Promise<number> {
+    const { data } = await network<Block>({
+      method: "GET",
+      url: this.aptosConfig.fullnode || "",
+    });
+    return parseInt(data.block_height);
+  }
+
+  private async getBlock(version: number) {
+    const block = await this.aptosClient.getBlockByVersion({ ledgerVersion: version });
+    return {
+      height: parseInt(block.block_height),
+      hash: block.block_hash,
+    };
+  }
+}

package/src/network/index.ts

@@ -9,10 +9,11 @@ import {
   RawTransaction,
   SimpleTransaction,
 } from "@aptos-labs/ts-sdk";
-import { SignerContext } from "@ledgerhq/coin-framework/lib/signer";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { Account } from "@ledgerhq/types-live";
 import { AptosSigner } from "../types";
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
+export * from "./client";
 
 export async function signTransaction(
   signerContext: SignerContext<AptosSigner>,

package/src/types/assets.ts

@@ -0,0 +1,3 @@
+import type { Asset } from "@ledgerhq/coin-framework/api/types";
+
+export type AptosAsset = Asset;

package/lib/api/graphql/queries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/api/graphql/queries.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B,uCAczC,CAAC;AACF,eAAO,MAAM,0BAA0B,uCAWtC,CAAC;AACF,eAAO,MAAM,4BAA4B,uCAWxC,CAAC;AACF,eAAO,MAAM,4BAA4B,uCAWxC,CAAC"}