@stryke-xyz/premarket-sdk 1.0.0

package/dist/ponder/client/types/serializers.js

@@ -0,0 +1,248 @@
+/**
+ * Serialize raw GraphQL query result into MarketStrategy type
+ */
+export function serializeMarketStrategy(data) {
+    return {
+        id: String(data.id),
+        finalFDV: BigInt(data.finalFDV ?? 0),
+        deadline: BigInt(data.deadline ?? 0),
+        bandPrecision: BigInt(data.bandPrecision ?? 0),
+        collateralPerBandPrecision: BigInt(data.collateralPerBandPrecision ?? 0),
+        premiumRate: BigInt(data.premiumRate ?? 0),
+        depositFeeRate: BigInt(data.depositFeeRate ?? 0),
+        purchaseFeeRate: BigInt(data.purchaseFeeRate ?? 0),
+        settlementFeeRate: BigInt(data.settlementFeeRate ?? 0),
+        collateralToken: data.collateralToken,
+    };
+}
+/**
+ * Serialize raw GraphQL query result into OptionParams type
+ */
+export function serializeOptionParams(data) {
+    return {
+        id: String(data.id),
+        marketId: BigInt(data.marketId ?? 0),
+        strikeLowerLimit: BigInt(data.strikeLowerLimit ?? 0),
+        strikeUpperLimit: BigInt(data.strikeUpperLimit ?? 0),
+        isPut: Boolean(data.isPut),
+        collateralPerShare: data.collateralPerShare != null ? BigInt(data.collateralPerShare) : undefined,
+    };
+}
+/**
+ * Serialize raw GraphQL query result into OptionMarket type
+ */
+export function serializeOptionMarket(data) {
+    return {
+        id: String(data.id),
+        callToken: data.callToken,
+        putToken: data.putToken,
+        expiry: BigInt(data.expiry ?? 0),
+        maxTTL: BigInt(data.maxTTL ?? 0),
+        strategy: serializeMarketStrategy(data.strategy),
+        collateralToken: data.collateralToken,
+        totalCollateral: BigInt(data.totalCollateral ?? 0),
+        totalCollateralAmount: BigInt(data.totalCollateralAmount ?? 0),
+        protocolFees: BigInt(data.protocolFees ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into HourlyVolume type
+ */
+export function serializeHourlyVolume(data) {
+    return {
+        id: String(data.id),
+        marketId: BigInt(data.marketId ?? 0),
+        optionId: String(data.optionId ?? ""),
+        hourTimestamp: BigInt(data.hourTimestamp ?? 0),
+        depositVolume: BigInt(data.depositVolume ?? 0),
+        tradeVolume: BigInt(data.tradeVolume ?? 0),
+        unwindVolume: BigInt(data.unwindVolume ?? 0),
+        withdrawVolume: BigInt(data.withdrawVolume ?? 0),
+        exerciseVolume: BigInt(data.exerciseVolume ?? 0),
+        totalVolume: BigInt(data.totalVolume ?? 0),
+        tradeCount: Number(data.tradeCount ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into CollateralPosition type
+ */
+export function serializeCollateralPosition(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        optionMarketId: String(data.optionMarketId ?? ""),
+        totalCollateral: BigInt(data.totalCollateral ?? 0),
+        optionsMinted: BigInt(data.optionsMinted ?? 0),
+        optionsExercised: BigInt(data.optionsExercised ?? 0),
+        premiumEarned: BigInt(data.premiumEarned ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        settled: Boolean(data.settled),
+        updatedAt: BigInt(data.updatedAt ?? 0),
+        updatedAtBlock: BigInt(data.updatedAtBlock ?? 0),
+        optionMarket: data.optionMarket
+            ? serializeOptionMarket(data.optionMarket)
+            : undefined,
+        optionParams: data.optionParams
+            ? serializeOptionParams(data.optionParams)
+            : undefined,
+    };
+}
+/**
+ * Serialize raw GraphQL query result into OptionPosition type
+ */
+export function serializeOptionPosition(data) {
+    return {
+        id: String(data.id),
+        tokenId: BigInt(data.tokenId ?? 0),
+        address: data.address,
+        optionId: String(data.optionId ?? ""),
+        optionMarketId: String(data.optionMarketId ?? ""),
+        premium: BigInt(data.premium ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        profit: BigInt(data.profit ?? 0),
+        amount: BigInt(data.amount ?? 0),
+        averagePrice: BigInt(data.averagePrice ?? 0),
+        updatedAt: BigInt(data.updatedAt ?? 0),
+        updatedAtBlock: BigInt(data.updatedAtBlock ?? 0),
+        optionMarket: data.optionMarket
+            ? serializeOptionMarket(data.optionMarket)
+            : undefined,
+        optionParams: data.optionParams
+            ? serializeOptionParams(data.optionParams)
+            : undefined,
+    };
+}
+/**
+ * Serialize raw GraphQL query result into DepositHistory type
+ */
+export function serializeDepositHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        marketId: BigInt(data.marketId ?? 0),
+        receiver: data.receiver,
+        amount: BigInt(data.amount ?? 0),
+        collateralAmount: BigInt(data.collateralAmount ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into TransferDepositHistory type
+ */
+export function serializeTransferDepositHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        marketId: BigInt(data.marketId ?? 0),
+        amount: BigInt(data.amount ?? 0),
+        collateralAmount: BigInt(data.collateralAmount ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into PurchaseHistory type
+ */
+export function serializePurchaseHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        purchaser: data.purchaser,
+        amount: BigInt(data.amount ?? 0),
+        premiumAmount: BigInt(data.premiumAmount ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        optionShares: BigInt(data.optionShares ?? 0),
+        sharesUtilized: BigInt(data.sharesUtilized ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into TransferPositionHistory type
+ */
+export function serializeTransferPositionHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        purchaser: data.purchaser,
+        amount: BigInt(data.amount ?? 0),
+        premiumAmount: BigInt(data.premiumAmount ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        optionShares: BigInt(data.optionShares ?? 0),
+        sharesUtilized: BigInt(data.sharesUtilized ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into ExerciseHistory type
+ */
+export function serializeExerciseHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        exerciser: data.exerciser,
+        amount: BigInt(data.amount ?? 0),
+        profitAmount: BigInt(data.profitAmount ?? 0),
+        fee: BigInt(data.fee ?? 0),
+        optionTokensBurnt: BigInt(data.optionTokensBurnt ?? 0),
+        sharesUnutilized: BigInt(data.sharesUnutilized ?? 0),
+        makerLoss: data.makerLoss != null ? BigInt(data.makerLoss) : null,
+        purchaserProfit: data.purchaserProfit != null ? BigInt(data.purchaserProfit) : null,
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into UnwindHistory type
+ */
+export function serializeUnwindHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        marketId: BigInt(data.marketId ?? 0),
+        amount: BigInt(data.amount ?? 0),
+        collateralTokensToReturn: BigInt(data.collateralTokensToReturn ?? 0),
+        collateralSharesToBurn: BigInt(data.collateralSharesToBurn ?? 0),
+        optionSharesToBurn: BigInt(data.optionSharesToBurn ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into SettlementHistory type
+ */
+export function serializeSettlementHistory(data) {
+    return {
+        id: String(data.id),
+        optionId: String(data.optionId ?? ""),
+        optionMarketId: String(data.optionMarketId ?? ""),
+        totalCollateralSettled: BigInt(data.totalCollateralSettled ?? 0),
+        transactionHash: data.transactionHash,
+        blockNumber: BigInt(data.blockNumber ?? 0),
+        timestamp: BigInt(data.timestamp ?? 0),
+    };
+}
+/**
+ * Serialize raw GraphQL query result into UserHistories type
+ */
+export function serializeUserHistories(data) {
+    return {
+        depositHistory: (data.depositHistory || []).map(serializeDepositHistory),
+        transferDepositHistory: (data.transferDepositHistory || []).map(serializeTransferDepositHistory),
+        purchaseHistory: (data.purchaseHistory || []).map(serializePurchaseHistory),
+        transferPositionHistory: (data.transferPositionHistory || []).map(serializeTransferPositionHistory),
+        exerciseHistory: (data.exerciseHistory || []).map(serializeExerciseHistory),
+        unwindHistory: (data.unwindHistory || []).map(serializeUnwindHistory),
+        settlementHistory: (data.settlementHistory || []).map(serializeSettlementHistory),
+    };
+}

package/dist/ponder/client/types/user.d.ts

@@ -0,0 +1,5 @@
+export interface User {
+    id: string;
+    updatedAt: bigint;
+    updatedAtBlock: bigint;
+}

package/dist/ponder/client/types/user.js

@@ -0,0 +1 @@
+export {};

package/dist/ponder/client/utils.d.ts

@@ -0,0 +1 @@
+export declare function convertBigIntFields<T>(obj: T): T;

package/dist/ponder/client/utils.js

@@ -0,0 +1,32 @@
+export function convertBigIntFields(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => typeof item === "object" && item !== null
+            ? convertBigIntFields(item)
+            : item);
+    }
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    const result = { ...obj };
+    for (const key in result) {
+        if (typeof result[key] === "string" && /^\d+$/.test(result[key])) {
+            try {
+                result[key] = BigInt(result[key]);
+            }
+            catch {
+                // Not a valid bigint string, leave as is
+            }
+        }
+        else if (typeof result[key] === "object" && result[key] !== null) {
+            if (Array.isArray(result[key])) {
+                result[key] = result[key].map((item) => typeof item === "object" && item !== null
+                    ? convertBigIntFields(item)
+                    : item);
+            }
+            else {
+                result[key] = convertBigIntFields(result[key]);
+            }
+        }
+    }
+    return result;
+}

package/dist/ponder/generated/index.d.ts

@@ -0,0 +1,18 @@
+import type { QueryGenqlSelection, Query } from './schema';
+import { type FieldsSelection, type GraphqlOperation, type ClientOptions, GenqlError } from './runtime';
+export type { FieldsSelection } from './runtime';
+export { GenqlError };
+export * from './schema';
+export interface Client {
+    query<R extends QueryGenqlSelection>(request: R & {
+        __name?: string;
+    }): Promise<FieldsSelection<Query, R>>;
+}
+export declare const createClient: (options?: ClientOptions) => Client;
+export declare const everything: {
+    __scalar: boolean;
+};
+export type QueryResult<fields extends QueryGenqlSelection> = FieldsSelection<Query, fields>;
+export declare const generateQueryOp: (fields: QueryGenqlSelection & {
+    __name?: string;
+}) => GraphqlOperation;

package/dist/ponder/generated/index.js

@@ -0,0 +1,20 @@
+import { linkTypeMap, createClient as createClientOriginal, generateGraphqlOperation, GenqlError, } from './runtime';
+export { GenqlError };
+import types from './types';
+export * from './schema';
+const typeMap = linkTypeMap(types);
+export const createClient = function (options) {
+    return createClientOriginal({
+        url: undefined,
+        ...options,
+        queryRoot: typeMap.Query,
+        mutationRoot: typeMap.Mutation,
+        subscriptionRoot: typeMap.Subscription,
+    });
+};
+export const everything = {
+    __scalar: true,
+};
+export const generateQueryOp = function (fields) {
+    return generateGraphqlOperation('query', typeMap.Query, fields);
+};

package/dist/ponder/generated/runtime/batcher.d.ts

@@ -0,0 +1,105 @@
+import type { GraphqlOperation } from './generateGraphqlOperation';
+type Variables = Record<string, any>;
+type QueryError = Error & {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: any;
+    rid: string;
+    details?: Record<string, any>;
+};
+type Result = {
+    data: Record<string, any>;
+    errors: Array<QueryError>;
+};
+type Fetcher = (batchedQuery: GraphqlOperation | Array<GraphqlOperation>) => Promise<Array<Result>>;
+type Options = {
+    batchInterval?: number;
+    shouldBatch?: boolean;
+    maxBatchSize?: number;
+};
+type Queue = Array<{
+    request: GraphqlOperation;
+    resolve: (...args: Array<any>) => any;
+    reject: (...args: Array<any>) => any;
+}>;
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+export declare class QueryBatcher {
+    fetcher: Fetcher;
+    _options: Options;
+    _queue: Queue;
+    constructor(fetcher: Fetcher, { batchInterval, shouldBatch, maxBatchSize, }?: Options);
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+}
+export {};

package/dist/ponder/generated/runtime/batcher.js

@@ -0,0 +1,188 @@
+import { GenqlError } from './error';
+/**
+ * takes a list of requests (queue) and batches them into a single server request.
+ * It will then resolve each individual requests promise with the appropriate data.
+ * @private
+ * @param {QueryBatcher}   client - the client to use
+ * @param {Queue} queue  - the list of requests to batch
+ */
+function dispatchQueueBatch(client, queue) {
+    let batchedQuery = queue.map((item) => item.request);
+    if (batchedQuery.length === 1) {
+        batchedQuery = batchedQuery[0];
+    }
+    client.fetcher(batchedQuery).then((responses) => {
+        if (queue.length === 1 && !Array.isArray(responses)) {
+            if (responses.errors && responses.errors.length) {
+                queue[0].reject(new GenqlError(responses.errors, responses.data));
+                return;
+            }
+            queue[0].resolve(responses);
+            return;
+        }
+        else if (responses.length !== queue.length) {
+            throw new Error('response length did not match query length');
+        }
+        for (let i = 0; i < queue.length; i++) {
+            if (responses[i].errors && responses[i].errors.length) {
+                queue[i].reject(new GenqlError(responses[i].errors, responses[i].data));
+            }
+            else {
+                queue[i].resolve(responses[i]);
+            }
+        }
+    });
+}
+/**
+ * creates a list of requests to batch according to max batch size.
+ * @private
+ * @param {QueryBatcher} client - the client to create list of requests from from
+ * @param {Options} options - the options for the batch
+ */
+function dispatchQueue(client, options) {
+    const queue = client._queue;
+    const maxBatchSize = options.maxBatchSize || 0;
+    client._queue = [];
+    if (maxBatchSize > 0 && maxBatchSize < queue.length) {
+        for (let i = 0; i < queue.length / maxBatchSize; i++) {
+            dispatchQueueBatch(client, queue.slice(i * maxBatchSize, (i + 1) * maxBatchSize));
+        }
+    }
+    else {
+        dispatchQueueBatch(client, queue);
+    }
+}
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+export class QueryBatcher {
+    constructor(fetcher, { batchInterval = 6, shouldBatch = true, maxBatchSize = 0, } = {}) {
+        this.fetcher = fetcher;
+        this._options = {
+            batchInterval,
+            shouldBatch,
+            maxBatchSize,
+        };
+        this._queue = [];
+    }
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(query, variables, operationName, overrides = {}) {
+        const request = {
+            query,
+        };
+        const options = Object.assign({}, this._options, overrides);
+        if (variables) {
+            request.variables = variables;
+        }
+        if (operationName) {
+            request.operationName = operationName;
+        }
+        const promise = new Promise((resolve, reject) => {
+            this._queue.push({
+                request,
+                resolve,
+                reject,
+            });
+            if (this._queue.length === 1) {
+                if (options.shouldBatch) {
+                    setTimeout(() => dispatchQueue(this, options), options.batchInterval);
+                }
+                else {
+                    dispatchQueue(this, options);
+                }
+            }
+        });
+        return promise;
+    }
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(query, variables, operationName, overrides = {}) {
+        const request = {
+            query,
+        };
+        const options = Object.assign({}, this._options, overrides, {
+            shouldBatch: false,
+        });
+        if (variables) {
+            request.variables = variables;
+        }
+        if (operationName) {
+            request.operationName = operationName;
+        }
+        const promise = new Promise((resolve, reject) => {
+            const client = new QueryBatcher(this.fetcher, this._options);
+            client._queue = [
+                {
+                    request,
+                    resolve,
+                    reject,
+                },
+            ];
+            dispatchQueue(client, options);
+        });
+        return promise;
+    }
+}

package/dist/ponder/generated/runtime/createClient.d.ts

@@ -0,0 +1,17 @@
+import { type BatchOptions } from './fetcher';
+import type { ExecutionResult, LinkedType } from './types';
+import { type GraphqlOperation } from './generateGraphqlOperation';
+export type Headers = HeadersInit | (() => HeadersInit) | (() => Promise<HeadersInit>);
+export type BaseFetcher = (operation: GraphqlOperation | GraphqlOperation[]) => Promise<ExecutionResult | ExecutionResult[]>;
+export type ClientOptions = Omit<RequestInit, 'body' | 'headers'> & {
+    url?: string;
+    batch?: BatchOptions | boolean;
+    fetcher?: BaseFetcher;
+    fetch?: Function;
+    headers?: Headers;
+};
+export declare const createClient: ({ queryRoot, mutationRoot, subscriptionRoot, ...options }: ClientOptions & {
+    queryRoot?: LinkedType;
+    mutationRoot?: LinkedType;
+    subscriptionRoot?: LinkedType;
+}) => any;

package/dist/ponder/generated/runtime/createClient.js

@@ -0,0 +1,24 @@
+// @ts-nocheck
+import { createFetcher } from './fetcher';
+import { generateGraphqlOperation, } from './generateGraphqlOperation';
+export const createClient = ({ queryRoot, mutationRoot, subscriptionRoot, ...options }) => {
+    const fetcher = createFetcher(options);
+    const client = {};
+    if (queryRoot) {
+        client.query = (request) => {
+            if (!queryRoot)
+                throw new Error('queryRoot argument is missing');
+            const resultPromise = fetcher(generateGraphqlOperation('query', queryRoot, request));
+            return resultPromise;
+        };
+    }
+    if (mutationRoot) {
+        client.mutation = (request) => {
+            if (!mutationRoot)
+                throw new Error('mutationRoot argument is missing');
+            const resultPromise = fetcher(generateGraphqlOperation('mutation', mutationRoot, request));
+            return resultPromise;
+        };
+    }
+    return client;
+};

package/dist/ponder/generated/runtime/error.d.ts

@@ -0,0 +1,18 @@
+export declare class GenqlError extends Error {
+    errors: Array<GraphqlError>;
+    /**
+     * Partial data returned by the server
+     */
+    data?: any;
+    constructor(errors: any[], data: any);
+}
+interface GraphqlError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: string[];
+    extensions?: Record<string, any>;
+}
+export {};