@solana/rpc-graphql 2.0.0-experimental.f7d1af1 → 2.0.0-experimental.fafdfb2

package/dist/types/resolvers/instruction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/instruction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAwXQ,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2XzD,CAAC"}

package/dist/types/resolvers/program-accounts.d.ts

@@ -0,0 +1,19 @@
+import { Address } from '@solana/addresses';
+import { Commitment, Slot } from '@solana/rpc-types';
+import type { GraphQLResolveInfo } from 'graphql';
+import { RpcGraphQLContext } from '../context.js';
+import { AccountResult } from './account.js';
+export declare function resolveProgramAccounts(fieldName?: string): (parent: {
+    [x: string]: Address;
+}, args: {
+    commitment?: Commitment;
+    filters?: readonly {
+        memcmp: {
+            offset: number;
+            bytes: string;
+        };
+    }[];
+    minContextSlot?: Slot;
+    programAddress: Address;
+}, context: RpcGraphQLContext, info: GraphQLResolveInfo) => Promise<AccountResult[] | null>;
+//# sourceMappingURL=program-accounts.d.ts.map

package/dist/types/resolvers/program-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program-accounts.d.ts","sourceRoot":"","sources":["../../../src/resolvers/program-accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,wBAAgB,sBAAsB,CAAC,SAAS,CAAC,EAAE,MAAM;;SAG3C;IACF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,SAAS;QAAE,MAAM,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAC;IACnE,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;CAC3B,WACQ,iBAAiB,QACpB,kBAAkB,KACzB,QAAQ,aAAa,EAAE,GAAG,IAAI,CAAC,CAkErC"}

package/dist/types/resolvers/resolve-info/account.d.ts

@@ -0,0 +1,15 @@
+import { Address } from '@solana/addresses';
+import { Commitment, Slot } from '@solana/rpc-types';
+import { GraphQLResolveInfo } from 'graphql';
+import { AccountLoaderArgs, ProgramAccountsLoaderArgs } from '../../loaders/index.js';
+export declare function buildAccountArgSetWithVisitor<TArgs extends AccountLoaderArgs | ProgramAccountsLoaderArgs>(args: TArgs, info: GraphQLResolveInfo): TArgs[];
+/**
+ * Build a set of account loader args by inspecting which fields have
+ * been requested in the query (ie. `data` or inline fragments).
+ */
+export declare function buildAccountLoaderArgSetFromResolveInfo(args: {
+    address: Address;
+    commitment?: Commitment;
+    minContextSlot?: Slot;
+}, info: GraphQLResolveInfo): AccountLoaderArgs[];
+//# sourceMappingURL=account.d.ts.map

package/dist/types/resolvers/resolve-info/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/account.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAa,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAmB,MAAM,SAAS,CAAC;AAE5E,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAmE7E,wBAAgB,6BAA6B,CAAC,KAAK,SAAS,iBAAiB,GAAG,yBAAyB,EACrG,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,kBAAkB,GACzB,KAAK,EAAE,CAsCT;AAED;;;GAGG;AACH,wBAAgB,uCAAuC,CACnD,IAAI,EAAE;IACF,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,cAAc,CAAC,EAAE,IAAI,CAAC;CACzB,EACD,IAAI,EAAE,kBAAkB,GACzB,iBAAiB,EAAE,CAErB"}

package/dist/types/resolvers/resolve-info/block.d.ts

@@ -0,0 +1,13 @@
+import { Commitment, Slot } from '@solana/rpc-types';
+import { GraphQLResolveInfo } from 'graphql';
+import { BlockLoaderArgs } from '../../loaders/index.js';
+/**
+ * Build a set of block loader args by inspecting which fields have
+ * been requested in the query (ie. `data` or inline fragments).
+ */
+export declare function buildBlockLoaderArgSetFromResolveInfo(args: {
+    commitment?: Omit<Commitment, 'processed'>;
+    minContextSlot?: Slot;
+    slot: Slot;
+}, info: GraphQLResolveInfo): BlockLoaderArgs[];
+//# sourceMappingURL=block.d.ts.map

package/dist/types/resolvers/resolve-info/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAIhD;;;GAGG;AACH,wBAAgB,qCAAqC,CACjD,IAAI,EAAE;IACF,UAAU,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAC3C,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,IAAI,EAAE,IAAI,CAAC;CACd,EACD,IAAI,EAAE,kBAAkB,GACzB,eAAe,EAAE,CA0BnB"}

package/dist/types/resolvers/resolve-info/index.d.ts

@@ -0,0 +1,6 @@
+export * from './account.js';
+export * from './block.js';
+export * from './program-accounts.js';
+export * from './transaction.js';
+export * from './visitor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/resolvers/resolve-info/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC"}

package/dist/types/resolvers/resolve-info/program-accounts.d.ts

@@ -0,0 +1,20 @@
+import { Address } from '@solana/addresses';
+import { Commitment, Slot } from '@solana/rpc-types';
+import { GraphQLResolveInfo } from 'graphql';
+import { ProgramAccountsLoaderArgs } from '../../loaders/index.js';
+/**
+ * Build a set of account loader args by inspecting which fields have
+ * been requested in the query (ie. `data` or inline fragments).
+ */
+export declare function buildProgramAccountsLoaderArgSetFromResolveInfo(args: {
+    commitment?: Commitment;
+    filters?: readonly {
+        memcmp: {
+            offset: number;
+            bytes: string;
+        };
+    }[];
+    minContextSlot?: Slot;
+    programAddress: Address;
+}, info: GraphQLResolveInfo): ProgramAccountsLoaderArgs[];
+//# sourceMappingURL=program-accounts.d.ts.map

package/dist/types/resolvers/resolve-info/program-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program-accounts.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/program-accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAG1D;;;GAGG;AACH,wBAAgB,+CAA+C,CAC3D,IAAI,EAAE;IACF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,SAAS;QAAE,MAAM,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAC;IACnE,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;CAC3B,EACD,IAAI,EAAE,kBAAkB,GACzB,yBAAyB,EAAE,CAE7B"}

package/dist/types/resolvers/resolve-info/transaction.d.ts

@@ -0,0 +1,15 @@
+import { Signature } from '@solana/keys';
+import { Commitment, Slot } from '@solana/rpc-types';
+import { GraphQLResolveInfo } from 'graphql';
+import { BlockLoaderArgs, TransactionLoaderArgs } from '../../loaders/index.js';
+export declare function buildTransactionArgSetWithVisitor<TArgs extends BlockLoaderArgs | TransactionLoaderArgs>(args: TArgs, info: GraphQLResolveInfo): TArgs[];
+/**
+ * Build a set of transaction loader args by inspecting which fields have
+ * been requested in the query (ie. `data` or inline fragments).
+ */
+export declare function buildTransactionLoaderArgSetFromResolveInfo(args: {
+    commitment?: Omit<Commitment, 'processed'>;
+    minContextSlot?: Slot;
+    signature: Signature;
+}, info: GraphQLResolveInfo): TransactionLoaderArgs[];
+//# sourceMappingURL=transaction.d.ts.map

package/dist/types/resolvers/resolve-info/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAgB,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AA+BvE,wBAAgB,iCAAiC,CAAC,KAAK,SAAS,eAAe,GAAG,qBAAqB,EACnG,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,kBAAkB,GACzB,KAAK,EAAE,CAkCT;AAED;;;GAGG;AACH,wBAAgB,2CAA2C,CACvD,IAAI,EAAE;IACF,UAAU,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAC3C,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;CACxB,EACD,IAAI,EAAE,kBAAkB,GACzB,qBAAqB,EAAE,CAEzB"}

package/dist/types/resolvers/resolve-info/visitor.d.ts

@@ -0,0 +1,18 @@
+import { ASTVisitFn, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLResolveInfo, InlineFragmentNode } from 'graphql';
+type InjectableVisitorOperations = {
+    fieldNodeOperation: (info: GraphQLResolveInfo, ...args: Parameters<ASTVisitFn<FieldNode>>) => void;
+    fragmentSpreadNodeOperation: (info: GraphQLResolveInfo, fragment: FragmentDefinitionNode, ...args: Parameters<ASTVisitFn<FragmentSpreadNode>>) => void;
+    inlineFragmentNodeOperation: (info: GraphQLResolveInfo, ...args: Parameters<ASTVisitFn<InlineFragmentNode>>) => void;
+};
+type RootNode = FieldNode | FragmentDefinitionNode | InlineFragmentNode;
+/**
+ * An AST visitor that keys on the root field provided.
+ * This visitor can be injected with custom logic for various types of nodes.
+ */
+export declare function injectableRootVisitor(info: GraphQLResolveInfo, rootNode: RootNode | null, operations: InjectableVisitorOperations): void;
+/**
+ * Determine if the query only requests the provided field names
+ */
+export declare function onlyFieldsRequested(fieldNames: string[], info: GraphQLResolveInfo, rootNode?: RootNode): boolean;
+export {};
+//# sourceMappingURL=visitor.d.ts.map

package/dist/types/resolvers/resolve-info/visitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/resolve-info/visitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,UAAU,EAEV,SAAS,EACT,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAErB,MAAM,SAAS,CAAC;AAEjB,KAAK,2BAA2B,GAAG;IAC/B,kBAAkB,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,IAAI,CAAC;IACnG,2BAA2B,EAAE,CACzB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,sBAAsB,EAChC,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,KAClD,IAAI,CAAC;IACV,2BAA2B,EAAE,CACzB,IAAI,EAAE,kBAAkB,EACxB,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,KAClD,IAAI,CAAC;CACb,CAAC;AACF,KAAK,QAAQ,GAAG,SAAS,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;AAExE;;;GAGG;AACH,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,QAAQ,GAAG,IAAI,EACzB,UAAU,EAAE,2BAA2B,QAoB1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAuBhH"}

package/dist/types/resolvers/root.d.ts

@@ -0,0 +1,3 @@
+import type { makeExecutableSchema } from '@graphql-tools/schema';
+export declare const rootResolvers: Parameters<typeof makeExecutableSchema>[0]['resolvers'];
+//# sourceMappingURL=root.d.ts.map

package/dist/types/resolvers/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/resolvers/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAOlE,eAAO,MAAM,aAAa,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAOjF,CAAC"}

package/dist/types/resolvers/transaction.d.ts

@@ -0,0 +1,42 @@
+import { Address } from '@solana/addresses';
+import { Signature } from '@solana/keys';
+import { Commitment } from '@solana/rpc-types';
+import type { GraphQLResolveInfo } from 'graphql';
+import { RpcGraphQLContext } from '../context.js';
+import { TransactionLoaderValue } from '../loaders/index.js';
+export type EncodedTransactionData = {
+    [key: string]: string;
+};
+export type InstructionResult = {
+    jsonParsedConfigs?: {
+        instructionType: string;
+        programId: Address;
+        programName: string;
+    };
+    programId?: Address;
+} & {
+    [key: string]: unknown;
+};
+export type TransactionResult = {
+    signature?: Signature;
+    encodedData?: EncodedTransactionData;
+} & Partial<TransactionLoaderValue>;
+export declare function mapJsonParsedInstructions(instructions: readonly any[]): InstructionResult[];
+export declare function mapJsonParsedInnerInstructions(innerInstructions: readonly any[]): {
+    index: number;
+    instructions: InstructionResult[];
+}[];
+export declare function resolveTransaction(fieldName?: string): (parent: {
+    [x: string]: Signature;
+}, args: {
+    signature?: Signature;
+    commitment?: Omit<Commitment, 'processed'>;
+}, context: RpcGraphQLContext, info: GraphQLResolveInfo) => Promise<TransactionResult | null>;
+export declare const transactionResolvers: {
+    Transaction: {
+        data: (parent: TransactionResult | null, args: {
+            encoding: 'base58' | 'base64';
+        }) => string | null;
+    };
+};
+//# sourceMappingURL=transaction.d.ts.map

package/dist/types/resolvers/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAc,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAGhE,MAAM,MAAM,sBAAsB,GAAG;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,iBAAiB,CAAC,EAAE;QAChB,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,OAAO,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG;IACA,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,WAAW,CAAC,EAAE,sBAAsB,CAAC;CACxC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAGpC,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,SAAS,GAAG,EAAE,GAAG,iBAAiB,EAAE,CA8B3F;AAED,wBAAgB,8BAA8B,CAE1C,iBAAiB,EAAE,SAAS,GAAG,EAAE,GAClC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,iBAAiB,EAAE,CAAA;CAAE,EAAE,CAMxD;AAaD,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM;;SAGvC;IACF,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,UAAU,EAAE,WAAW,CAAC,CAAC;CAC9C,WACQ,iBAAiB,QACpB,kBAAkB,KACzB,QAAQ,iBAAiB,GAAG,IAAI,CAAC,CAwEvC;AAED,eAAO,MAAM,oBAAoB;;uBA5FjB,iBAAiB,GAAG,IAAI,QAC1B;YACF,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC;SACjC;;CA6FR,CAAC"}

package/dist/types/resolvers/types.d.ts

@@ -0,0 +1,94 @@
+import { Kind } from 'graphql';
+export declare const typeTypeResolvers: {
+    AccountEncoding: {
+        BASE_58: string;
+        BASE_64: string;
+        BASE_64_ZSTD: string;
+    };
+    Address: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): string | null;
+        __parseValue(value: string): string;
+        __serialize(value: string): string;
+    };
+    Base58EncodedBytes: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): string | null;
+        __parseValue(value: string): string;
+        __serialize(value: string): string;
+    };
+    Base64EncodedBytes: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): string | null;
+        __parseValue(value: string): string;
+        __serialize(value: string): string;
+    };
+    Base64ZstdEncodedBytes: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): string | null;
+        __parseValue(value: string): string;
+        __serialize(value: string): string;
+    };
+    BigInt: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): bigint | null;
+        __parseValue(value: string): bigint;
+        __serialize(value: string): bigint;
+    };
+    Commitment: {
+        CONFIRMED: string;
+        FINALIZED: string;
+        PROCESSED: string;
+    };
+    CommitmentWithoutProcessed: {
+        CONFIRMED: string;
+        FINALIZED: string;
+    };
+    Signature: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): string | null;
+        __parseValue(value: string): string;
+        __serialize(value: string): string;
+    };
+    Slot: {
+        __parseLiteral(ast: {
+            kind: Kind;
+            value: string | number | bigint | boolean;
+        }): bigint | null;
+        __parseValue(value: string): bigint;
+        __serialize(value: string): bigint;
+    };
+    TokenBalance: {
+        mint: (parent: {
+            [x: string]: import("@solana/addresses").Address;
+        }, args: {
+            address?: import("@solana/addresses").Address | undefined;
+            commitment?: import("@solana/rpc-types").Commitment | undefined;
+            minContextSlot?: bigint | undefined;
+        }, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo) => Promise<import("./account").AccountResult | null>;
+        owner: (parent: {
+            [x: string]: import("@solana/addresses").Address;
+        }, args: {
+            address?: import("@solana/addresses").Address | undefined;
+            commitment?: import("@solana/rpc-types").Commitment | undefined;
+            minContextSlot?: bigint | undefined;
+        }, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo) => Promise<import("./account").AccountResult | null>;
+    };
+    TransactionEncoding: {
+        BASE_58: string;
+        BASE_64: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types/resolvers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolvers/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAkC/B,eAAO,MAAM,iBAAiB;;;;;;;4BA7BN;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;4BATd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;4BATd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;4BATd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;4BAMd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;;;;;;;;;;4BAxBd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;4BAMd;YAAE,IAAI,EAAE,IAAI,CAAC;YAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;SAAE,GAAG,MAAM,GAAG,IAAI;4BAMzE,MAAM,GAAG,MAAM;2BAGhB,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;CAmCrC,CAAC"}

package/dist/types/schema/account.d.ts

@@ -1,124 +1,2 @@
-import { Address } from '@solana/addresses';
-import { DataSlice, Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';
-export type AccountQueryArgs = {
-    address: Address;
-    dataSlice?: DataSlice;
-    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
-    commitment?: 'processed' | 'confirmed' | 'finalized';
-    minContextSlot?: Slot;
-};
-export declare const accountTypeDefs = "\n    # Account interface\n    interface Account {\n        address: String\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # An account with base58 encoded data\n    type AccountBase58 implements Account {\n        address: String\n        data: String\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # An account with base64 encoded data\n    type AccountBase64 implements Account {\n        address: String\n        data: String\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # An account with base64+zstd encoded data\n    type AccountBase64Zstd implements Account {\n        address: String\n        data: String\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # Interface for JSON-parsed meta\n    type JsonParsedAccountMeta {\n        program: String\n        space: BigInt\n        type: String\n    }\n    interface AccountJsonParsed {\n        meta: JsonParsedAccountMeta\n    }\n\n    # A nonce account\n    type NonceAccountFeeCalculator {\n        lamportsPerSignature: String\n    }\n    type NonceAccountData {\n        authority: Account\n        blockhash: String\n        feeCalculator: NonceAccountFeeCalculator\n    }\n    type NonceAccount implements Account & AccountJsonParsed {\n        address: String\n        data: NonceAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # A lookup table account\n    type LookupTableAccountData {\n        addresses: [String]\n        authority: Account\n        deactivationSlot: String\n        lastExtendedSlot: String\n        lastExtendedSlotStartIndex: Int\n    }\n    type LookupTableAccount implements Account & AccountJsonParsed {\n        address: String\n        data: LookupTableAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # A mint account\n    type MintAccountData {\n        decimals: Int\n        freezeAuthority: Account\n        isInitialized: Boolean\n        mintAuthority: Account\n        supply: String\n    }\n    type MintAccount implements Account & AccountJsonParsed {\n        address: String\n        data: MintAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # A token account\n    type TokenAccountData {\n        isNative: Boolean\n        mint: Account\n        owner: Account\n        state: String\n        tokenAmount: TokenAmount\n    }\n    type TokenAccount implements Account & AccountJsonParsed {\n        address: String\n        data: TokenAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # A stake account\n    type StakeAccountDataMetaAuthorized {\n        staker: Account\n        withdrawer: Account\n    }\n    type StakeAccountDataMetaLockup {\n        custodian: Account\n        epoch: BigInt\n        unixTimestamp: BigInt\n    }\n    type StakeAccountDataMeta {\n        authorized: StakeAccountDataMetaAuthorized\n        lockup: StakeAccountDataMetaLockup\n        rentExemptReserve: String\n    }\n    type StakeAccountDataStakeDelegation {\n        activationEpoch: BigInt\n        deactivationEpoch: BigInt\n        stake: String\n        voter: Account\n        warmupCooldownRate: Int\n    }\n    type StakeAccountDataStake {\n        creditsObserved: BigInt\n        delegation: StakeAccountDataStakeDelegation\n    }\n    type StakeAccountData {\n        meta: StakeAccountDataMeta\n        stake: StakeAccountDataStake\n    }\n    type StakeAccount implements Account & AccountJsonParsed {\n        address: String\n        data: StakeAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n\n    # A vote account\n    type VoteAccountDataAuthorizedVoter {\n        authorizedVoter: Account\n        epoch: BigInt\n    }\n    type VoteAccountDataEpochCredit {\n        credits: String\n        epoch: BigInt\n        previousCredits: String\n    }\n    type VoteAccountDataLastTimestamp {\n        slot: BigInt\n        timestamp: BigInt\n    }\n    type VoteAccountDataVote {\n        confirmationCount: Int\n        slot: BigInt\n    }\n    type VoteAccountData {\n        authorizedVoters: [VoteAccountDataAuthorizedVoter]\n        authorizedWithdrawer: Account\n        commission: Int\n        epochCredits: [VoteAccountDataEpochCredit]\n        lastTimestamp: VoteAccountDataLastTimestamp\n        node: Account\n        priorVoters: [String]\n        rootSlot: BigInt\n        votes: [VoteAccountDataVote]\n    }\n    type VoteAccount implements Account & AccountJsonParsed {\n        address: String\n        data: VoteAccountData\n        encoding: String\n        executable: Boolean\n        lamports: BigInt\n        meta: JsonParsedAccountMeta\n        owner: Account\n        rentEpoch: BigInt\n    }\n";
-export declare const accountResolvers: {
-    Account: {
-        __resolveType(account: {
-            encoding: string;
-            meta: {
-                program: string;
-                type: string;
-            };
-        }): "AccountBase58" | "AccountBase64" | "AccountBase64Zstd" | "NonceAccount" | "MintAccount" | "TokenAccount" | "StakeAccount" | "VoteAccount" | "LookupTableAccount";
-    };
-    AccountBase58: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    AccountBase64: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    AccountBase64Zstd: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    NonceAccountData: {
-        authority: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    NonceAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    LookupTableAccountData: {
-        authority: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    LookupTableAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    MintAccountData: {
-        freezeAuthority: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-        mintAuthority: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    MintAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    TokenAccountData: {
-        mint: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    TokenAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    StakeAccountDataMetaAuthorized: {
-        staker: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-        withdrawer: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    StakeAccountDataMetaLockup: {
-        custodian: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    StakeAccountDataStakeDelegation: {
-        voter: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    StakeAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    VoteAccountDataAuthorizedVoter: {
-        authorizedVoter: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    VoteAccountData: {
-        authorizedWithdrawer: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-        node: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-    VoteAccount: {
-        owner: (parent: {
-            [x: string]: Address;
-        }, args: AccountQueryArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any> | null;
-    };
-};
+export declare const accountTypeDefs = "\n    \"\"\"\n    Account interface\n    \"\"\"\n    interface Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n    }\n\n    \"\"\"\n    Generic base account type\n    \"\"\"\n    type GenericAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n    }\n\n    type NonceAccountFeeCalculator {\n        lamportsPerSignature: String\n    }\n    \"\"\"\n    A nonce account\n    \"\"\"\n    type NonceAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        authority: Account\n        blockhash: String\n        feeCalculator: NonceAccountFeeCalculator\n    }\n\n    \"\"\"\n    A lookup table account\n    \"\"\"\n    type LookupTableAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        addresses: [Address]\n        authority: Account\n        deactivationSlot: String\n        lastExtendedSlot: String\n        lastExtendedSlotStartIndex: Int\n    }\n\n    \"\"\"\n    A mint account\n    \"\"\"\n    type MintAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        decimals: Int\n        freezeAuthority: Account\n        isInitialized: Boolean\n        mintAuthority: Account\n        supply: String\n    }\n\n    \"\"\"\n    A token account\n    \"\"\"\n    type TokenAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        isNative: Boolean\n        mint: Account\n        owner: Account\n        state: String\n        tokenAmount: TokenAmount\n    }\n\n    type StakeAccountDataMetaAuthorized {\n        staker: Account\n        withdrawer: Account\n    }\n    type StakeAccountDataMetaLockup {\n        custodian: Account\n        epoch: BigInt\n        unixTimestamp: BigInt\n    }\n    type StakeAccountDataMeta {\n        authorized: StakeAccountDataMetaAuthorized\n        lockup: StakeAccountDataMetaLockup\n        rentExemptReserve: String\n    }\n    type StakeAccountDataStakeDelegation {\n        activationEpoch: BigInt\n        deactivationEpoch: BigInt\n        stake: String\n        voter: Account\n        warmupCooldownRate: Int\n    }\n    type StakeAccountDataStake {\n        creditsObserved: BigInt\n        delegation: StakeAccountDataStakeDelegation\n    }\n    \"\"\"\n    A stake account\n    \"\"\"\n    type StakeAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        meta: StakeAccountDataMeta\n        stake: StakeAccountDataStake\n    }\n\n    type VoteAccountDataAuthorizedVoter {\n        authorizedVoter: Account\n        epoch: BigInt\n    }\n    type VoteAccountDataEpochCredit {\n        credits: String\n        epoch: BigInt\n        previousCredits: String\n    }\n    type VoteAccountDataLastTimestamp {\n        slot: BigInt\n        timestamp: BigInt\n    }\n    type VoteAccountDataVote {\n        confirmationCount: Int\n        slot: BigInt\n    }\n    \"\"\"\n    A vote account\n    \"\"\"\n    type VoteAccount implements Account {\n        address: Address\n        data(encoding: AccountEncoding!, dataSlice: DataSlice): String\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n        authorizedVoters: [VoteAccountDataAuthorizedVoter]\n        authorizedWithdrawer: Account\n        commission: Int\n        epochCredits: [VoteAccountDataEpochCredit]\n        lastTimestamp: VoteAccountDataLastTimestamp\n        node: Account\n        priorVoters: [Address]\n        rootSlot: BigInt\n        votes: [VoteAccountDataVote]\n    }\n";
 //# sourceMappingURL=account.d.ts.map

package/dist/types/schema/account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../src/schema/account.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gDAAgD,CAAC;AAIjF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,CAAC;IAC9D,UAAU,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;IACrD,cAAc,CAAC,EAAE,IAAI,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,eAAe,yhLAmN3B,CAAC;AAEF,eAAO,MAAM,gBAAgB;;+BAEE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2F3F,CAAC"}
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../src/schema/account.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,uwJAkL3B,CAAC"}

package/dist/types/schema/block.d.ts

@@ -1,17 +1,2 @@
-import { Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';
-import { Commitment } from '@solana/rpc-types';
-export type BlockQueryArgs = {
-    slot: Slot;
-    commitment?: Commitment;
-    encoding?: 'base58' | 'base64' | 'jsonParsed';
-    transactionDetails?: 'accounts' | 'full' | 'none' | 'signatures';
-};
-export declare const blockTypeDefs = "\n    type TransactionMetaForAccounts {\n        err: String\n        fee: BigInt\n        postBalances: [BigInt]\n        postTokenBalances: [TokenBalance]\n        preBalances: [BigInt]\n        preTokenBalances: [TokenBalance]\n        status: TransactionStatus\n    }\n\n    type TransactionDataForAccounts {\n        accountKeys: [String]\n        signatures: [String]\n    }\n\n    type BlockTransactionAccounts {\n        meta: TransactionMetaForAccounts\n        data: TransactionDataForAccounts\n        version: String\n    }\n\n    # Block interface\n    interface Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: Int\n        parentSlot: BigInt\n        previousBlockhash: String\n        rewards: [Reward]\n        transactionDetails: String\n    }\n\n    # A block with account transaction details\n    type BlockWithAccounts implements Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: Int\n        parentSlot: BigInt\n        previousBlockhash: String\n        rewards: [Reward]\n        transactions: [BlockTransactionAccounts]\n        transactionDetails: String\n    }\n\n    # A block with full transaction details\n    type BlockWithFull implements Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: Int\n        parentSlot: BigInt\n        previousBlockhash: String\n        rewards: [Reward]\n        transactions: [Transaction]\n        transactionDetails: String\n    }\n\n    # A block with none transaction details\n    type BlockWithNone implements Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: Int\n        parentSlot: BigInt\n        previousBlockhash: String\n        rewards: [Reward]\n        transactionDetails: String\n    }\n\n    # A block with signature transaction details\n    type BlockWithSignatures implements Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: Int\n        parentSlot: BigInt\n        previousBlockhash: String\n        rewards: [Reward]\n        signatures: [String]\n        transactionDetails: String\n    }\n";
-export declare const blockResolvers: {
-    Block: {
-        __resolveType(block: {
-            transactionDetails: string;
-        }): "BlockWithAccounts" | "BlockWithNone" | "BlockWithSignatures" | "BlockWithFull";
-    };
-};
+export declare const blockTypeDefs = "\n    \"\"\"\n    A Solana block\n    \"\"\"\n    type Block {\n        blockhash: String\n        blockHeight: BigInt\n        blockTime: BigInt\n        parentSlot: Slot\n        previousBlockhash: String\n        rewards: [Reward]\n        signatures: [Signature]\n        transactions: [Transaction]\n    }\n";
 //# sourceMappingURL=block.d.ts.map

package/dist/types/schema/block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../src/schema/block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gDAAgD,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC9C,kBAAkB,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;CACpE,CAAC;AAEF,eAAO,MAAM,aAAa,smEA+EzB,CAAC;AAEF,eAAO,MAAM,cAAc;;6BAEE;YAAE,kBAAkB,EAAE,MAAM,CAAA;SAAE;;CAa1D,CAAC"}
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../src/schema/block.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,6TAczB,CAAC"}

package/dist/types/schema/index.d.ts

@@ -1,2 +1,2 @@
-export declare function createSolanaGraphQLSchema(): import("graphql").GraphQLSchema;
+export declare function createSolanaGraphQLTypeDefs(): string[];
 //# sourceMappingURL=index.d.ts.map

package/dist/types/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":"AAuFA,wBAAgB,yBAAyB,oCAuBxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":"AAOA,wBAAgB,2BAA2B,aAE1C"}