@solana/rpc-graphql 2.0.0-experimental.dd2096e → 2.0.0-experimental.e15a66f

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

@@ -1 +1 @@
-{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/instruction.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA8VE;YAAE,WAAW,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4WlF,CAAC"}
+{"version":3,"file":"instruction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/instruction.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA8VE;YAAE,WAAW,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4WlF,CAAC"}

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

@@ -1,10 +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 { ProgramAccountsLoaderArgs } from '../loaders/index.js';
+import { AccountResult } from './account.js';
 export declare function resolveProgramAccounts(fieldName?: string): (parent: {
     [x: string]: Address;
-}, args: ProgramAccountsLoaderArgs, context: RpcGraphQLContext, info: GraphQLResolveInfo | undefined) => Promise<any[] | {
+}, args: {
+    commitment?: Commitment;
+    filters?: readonly {
+        memcmp: {
+            offset: number;
+            bytes: string;
+        };
+    }[];
+    minContextSlot?: Slot;
     programAddress: Address;
-} | null>;
+}, context: RpcGraphQLContext, info: GraphQLResolveInfo) => Promise<AccountResult[] | null>;
 //# sourceMappingURL=program-accounts.d.ts.map

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

@@ -1 +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,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAIvD,wBAAgB,sBAAsB,CAAC,SAAS,CAAC,EAAE,MAAM;;SAG3C,yBAAyB,WACtB,iBAAiB,QACpB,kBAAkB,GAAG,SAAS;;UAoB3C"}
+{"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,CA8DrC"}

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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './account.js';
+export * from './program-accounts.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,oBAAoB,CAAC;AACnC,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/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/transaction.d.ts

@@ -8,7 +8,7 @@ export declare function transformLoadedTransaction({ encoding, transaction, }: {
 }): any;
 export declare function resolveTransaction(fieldName?: string): (parent: {
     [x: string]: Signature;
-}, args: TransactionLoaderArgs, context: RpcGraphQLContext, info: GraphQLResolveInfo | undefined) => Promise<any>;
+}, args: TransactionLoaderArgs, context: RpcGraphQLContext, info: GraphQLResolveInfo) => Promise<any>;
 export declare const transactionResolvers: {
     Transaction: {
         __resolveType(transaction: {

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAoCnD,wBAAgB,0BAA0B,CAAC,EACvC,QAAuB,EACvB,WAAW,GACd,EAAE;IACC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAE5C,WAAW,EAAE,GAAG,CAAC;CACpB,OAWA;AAED,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM;;SAGvC,qBAAqB,WAClB,iBAAiB,QACpB,kBAAkB,GAAG,SAAS,kBA8B3C;AAED,eAAO,MAAM,oBAAoB;;mCAEE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE;;CAWtD,CAAC"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/resolvers/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAoCnD,wBAAgB,0BAA0B,CAAC,EACvC,QAAuB,EACvB,WAAW,GACd,EAAE;IACC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAE5C,WAAW,EAAE,GAAG,CAAC;CACpB,OAWA;AAED,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM;;SAGvC,qBAAqB,WAClB,iBAAiB,QACpB,kBAAkB,kBA8B/B;AAED,eAAO,MAAM,oBAAoB;;mCAEE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE;;CAWtD,CAAC"}

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

@@ -1,17 +1,92 @@
-export declare const commonTypeResolvers: {
+import { Kind } from 'graphql';
+export declare const typeTypeResolvers: {
     AccountEncoding: {
         BASE_58: string;
         BASE_64: string;
         BASE_64_ZSTD: string;
-        PARSED: 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;
+    };
+    BlockTransactionDetails: {
+        ACCOUNTS: string;
+        FULL: string;
+        NONE: string;
+        SIGNATURES: string;
+    };
+    Commitment: {
+        CONFIRMED: string;
+        FINALIZED: string;
+        PROCESSED: 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: import("../loaders").AccountLoaderArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any>;
+        }, 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: import("../loaders").AccountLoaderArgs, context: import("../context").RpcGraphQLContext, info: import("graphql").GraphQLResolveInfo | undefined) => Promise<any>;
+        }, 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;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolvers/types.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;CAoB/B,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CrC,CAAC"}

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

@@ -1,2 +1,2 @@
-export declare const accountTypeDefs = "\n    \"\"\"\n    Account interface\n    \"\"\"\n    interface Account {\n        address: Address\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n    }\n\n    \"\"\"\n    An account with base58 encoded data\n    \"\"\"\n    type AccountBase58 implements Account {\n        address: Address\n        data: Base58EncodedBytes\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n    }\n\n    \"\"\"\n    An account with base64 encoded data\n    \"\"\"\n    type AccountBase64 implements Account {\n        address: Address\n        data: Base64EncodedBytes\n        executable: Boolean\n        lamports: BigInt\n        ownerProgram: Account\n        space: BigInt\n        rentEpoch: BigInt\n    }\n\n    \"\"\"\n    An account with base64+zstd encoded data\n    \"\"\"\n    type AccountBase64Zstd implements Account {\n        address: Address\n        data: Base64ZstdEncodedBytes\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        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        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        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        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        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        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";
+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":"AAAA,eAAO,MAAM,eAAe,q3JAqM3B,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/index.d.ts.map

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

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

@@ -1,2 +1,2 @@
-export declare const rootTypeDefs = "\n    type Query {\n        account(\n            address: String!\n            commitment: Commitment\n            dataSlice: DataSlice\n            encoding: AccountEncoding\n            minContextSlot: BigInt\n        ): Account\n        block(\n            slot: BigInt!\n            commitment: Commitment\n            encoding: TransactionEncoding\n            transactionDetails: BlockTransactionDetails\n        ): Block\n        programAccounts(\n            programAddress: String!\n            commitment: Commitment\n            dataSlice: DataSlice\n            encoding: AccountEncoding\n            filters: [ProgramAccountsFilter]\n            minContextSlot: BigInt\n        ): [Account]\n        transaction(signature: String!, commitment: Commitment, encoding: TransactionEncoding): Transaction\n    }\n\n    schema {\n        query: Query\n    }\n";
+export declare const rootTypeDefs = "\n    type Query {\n        account(address: Address!, commitment: Commitment, minContextSlot: Slot): Account\n        block(\n            slot: Slot!\n            commitment: Commitment\n            encoding: TransactionEncoding\n            transactionDetails: BlockTransactionDetails\n        ): Block\n        programAccounts(\n            programAddress: Address!\n            commitment: Commitment\n            filters: [ProgramAccountsFilter]\n            minContextSlot: Slot\n        ): [Account]\n        transaction(signature: Signature!, commitment: Commitment, encoding: TransactionEncoding): Transaction\n    }\n\n    schema {\n        query: Query\n    }\n";
 //# sourceMappingURL=root.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/schema/root.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,w2BA6BxB,CAAC"}
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/schema/root.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,qqBAqBxB,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const typeTypeDefs = "\n    enum AccountEncoding {\n        BASE_58\n        BASE_64\n        BASE_64_ZSTD\n    }\n\n    scalar Address\n\n    scalar Base58EncodedBytes\n\n    scalar Base64EncodedBytes\n\n    scalar Base64ZstdEncodedBytes\n\n    scalar BigInt\n\n    enum BlockTransactionDetails {\n        ACCOUNTS\n        FULL\n        NONE\n        SIGNATURES\n    }\n\n    enum Commitment {\n        CONFIRMED\n        FINALIZED\n        PROCESSED\n    }\n\n    input DataSlice {\n        offset: Int!\n        length: Int!\n    }\n\n    input ProgramAccountsFilter {\n        bytes: BigInt\n        dataSize: BigInt\n        encoding: AccountEncoding\n        offset: BigInt\n    }\n\n    type ReturnData {\n        data: Base64EncodedBytes\n        programId: Address\n    }\n\n    type Reward {\n        commission: Int\n        lamports: BigInt\n        postBalance: BigInt\n        pubkey: Address\n        rewardType: String\n    }\n\n    scalar Signature\n\n    scalar Slot\n\n    type TokenAmount {\n        amount: String\n        decimals: Int\n        uiAmount: BigInt\n        uiAmountString: String\n    }\n\n    type TokenBalance {\n        accountIndex: Int\n        mint: Account\n        owner: Account\n        programId: Address\n        uiTokenAmount: TokenAmount\n    }\n\n    enum TransactionEncoding {\n        BASE_58\n        BASE_64\n        PARSED\n    }\n\n    enum TransactionVersion {\n        LEGACY\n        ZERO\n    }\n";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,i6CAoFxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/rpc-graphql",
-  "version": "2.0.0-experimental.dd2096e",
+  "version": "2.0.0-experimental.e15a66f",
   "description": "A library for resolving GraphQl query calls to the Solana JSON RPC API",
   "exports": {
     "browser": {
@@ -49,36 +49,8 @@
     "@graphql-tools/schema": "^10.0.0",
     "dataloader": "^2.2.2",
     "graphql": "^16.8.0",
-    "json-stable-stringify": "^1.1.0"
-  },
-  "devDependencies": {
-    "@solana/eslint-config-solana": "^1.0.2",
-    "@swc/jest": "^0.2.29",
-    "@types/jest": "^29.5.11",
-    "@typescript-eslint/eslint-plugin": "^6.13.2",
-    "@typescript-eslint/parser": "^6.3.0",
-    "agadoo": "^3.0.0",
-    "eslint": "^8.45.0",
-    "eslint-plugin-jest": "^27.4.2",
-    "eslint-plugin-sort-keys-fix": "^1.1.2",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-fetch-mock-fork": "^3.0.4",
-    "jest-runner-eslint": "^2.1.2",
-    "jest-runner-prettier": "^1.0.0",
-    "prettier": "^3.1",
-    "tsup": "^8.0.1",
-    "typescript": "^5.1.6",
-    "version-from-git": "^1.1.1",
-    "@solana/addresses": "2.0.0-experimental.dd2096e",
-    "@solana/keys": "2.0.0-experimental.dd2096e",
-    "@solana/rpc-core": "2.0.0-experimental.dd2096e",
-    "@solana/rpc-transport": "2.0.0-experimental.dd2096e",
-    "@solana/rpc-types": "2.0.0-experimental.dd2096e",
-    "@solana/transactions": "2.0.0-experimental.dd2096e",
-    "build-scripts": "0.0.0",
-    "test-config": "0.0.0",
-    "tsconfig": "0.0.0"
+    "json-stable-stringify": "^1.1.0",
+    "@solana/codecs-strings": "2.0.0-experimental.e15a66f"
   },
   "bundlewatch": {
     "defaultCompression": "gzip",
@@ -90,17 +62,18 @@
   },
   "scripts": {
     "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
-    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/build-scripts/add-js-extension-to-types.mjs",
-    "dev": "jest -c node_modules/test-config/jest-dev.config.ts --globalSetup test-config/test-validator-setup.js --globalTeardown test-config/test-validator-teardown.js --rootDir . --watch",
-    "publish-packages": "pnpm publish --tag experimental --access public --no-git-checks",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/@solana/build-scripts/add-js-extension-to-types.mjs",
+    "dev": "jest -c node_modules/@solana/test-config/jest-dev.config.ts --globalSetup @solana/test-config/test-validator-setup.js --globalTeardown @solana/test-config/test-validator-teardown.js --rootDir . --watch",
+    "publish-impl": "npm view $npm_package_name@$npm_package_version > /dev/null 2>&1 || pnpm publish --tag experimental --access public --no-git-checks",
+    "publish-packages": "pnpm prepublishOnly && pnpm publish-impl",
     "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",
-    "test:lint": "jest -c node_modules/test-config/jest-lint.config.ts --rootDir . --silent",
-    "test:prettier": "jest -c node_modules/test-config/jest-prettier.config.ts --rootDir . --silent",
+    "test:lint": "jest -c node_modules/@solana/test-config/jest-lint.config.ts --rootDir . --silent",
+    "test:prettier": "jest -c node_modules/@solana/test-config/jest-prettier.config.ts --rootDir . --silent",
     "test:treeshakability:browser": "agadoo dist/index.browser.js",
     "test:treeshakability:native": "agadoo dist/index.native.js",
     "test:treeshakability:node": "agadoo dist/index.node.js",
     "test:typecheck": "tsc --noEmit",
-    "test:unit:browser": "jest -c node_modules/test-config/jest-unit.config.browser.ts --globalSetup test-config/test-validator-setup.js --globalTeardown test-config/test-validator-teardown.js --rootDir . --silent",
-    "test:unit:node": "jest -c node_modules/test-config/jest-unit.config.node.ts --globalSetup test-config/test-validator-setup.js --globalTeardown test-config/test-validator-teardown.js --rootDir . --silent"
+    "test:unit:browser": "jest -c node_modules/@solana/test-config/jest-unit.config.browser.ts --globalSetup @solana/test-config/test-validator-setup.js --globalTeardown @solana/test-config/test-validator-teardown.js --rootDir . --silent",
+    "test:unit:node": "jest -c node_modules/@solana/test-config/jest-unit.config.node.ts --globalSetup @solana/test-config/test-validator-setup.js --globalTeardown @solana/test-config/test-validator-teardown.js --rootDir . --silent"
   }
 }

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

@@ -1,3 +0,0 @@
-import { GraphQLResolveInfo } from 'graphql';
-export declare function onlyPresentFieldRequested(fieldName: string, info?: GraphQLResolveInfo): boolean;
-//# sourceMappingURL=resolve-info.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-info.d.ts","sourceRoot":"","sources":["../../../src/resolvers/resolve-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAc/F"}

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

@@ -1,44 +0,0 @@
-import { Kind } from 'graphql';
-export declare const scalarResolvers: {
-    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;
-    };
-};
-//# sourceMappingURL=scalars.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/resolvers/scalars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAiB/B,eAAO,MAAM,eAAe;;4BAdJ;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;;;4BAWV;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;;CAIzC,CAAC"}

package/dist/types/schema/common/inputs.d.ts

@@ -1,2 +0,0 @@
-export declare const inputTypeDefs = "\n    input DataSlice {\n        offset: Int\n        length: Int\n    }\n\n    input ProgramAccountsFilter {\n        bytes: BigInt\n        dataSize: BigInt\n        encoding: AccountEncoding\n        offset: BigInt\n    }\n";
-//# sourceMappingURL=inputs.d.ts.map

package/dist/types/schema/common/inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../../../src/schema/common/inputs.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,uOAYzB,CAAC"}

package/dist/types/schema/common/scalars.d.ts

@@ -1,2 +0,0 @@
-export declare const scalarTypeDefs = "\n    scalar Address\n    scalar Base58EncodedBytes\n    scalar Base64EncodedBytes\n    scalar Base64ZstdEncodedBytes\n    scalar BigInt\n";
-//# sourceMappingURL=scalars.d.ts.map

package/dist/types/schema/common/scalars.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../../src/schema/common/scalars.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,+IAM1B,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const commonTypeDefs = "\n    enum AccountEncoding {\n        BASE_58\n        BASE_64\n        BASE_64_ZSTD\n        PARSED\n    }\n\n    enum BlockTransactionDetails {\n        accounts\n        full\n        none\n        signatures\n    }\n\n    enum Commitment {\n        confirmed\n        finalized\n        processed\n    }\n\n    type ReturnData {\n        data: Base64EncodedBytes\n        programId: Address\n    }\n\n    type Reward {\n        commission: Int\n        lamports: BigInt\n        postBalance: BigInt\n        pubkey: Address\n        rewardType: String\n    }\n\n    type TokenAmount {\n        amount: String\n        decimals: Int\n        uiAmount: BigInt\n        uiAmountString: String\n    }\n\n    type TokenBalance {\n        accountIndex: Int\n        mint: Account\n        owner: Account\n        programId: Address\n        uiTokenAmount: TokenAmount\n    }\n\n    enum TransactionEncoding {\n        BASE_58\n        BASE_64\n        PARSED\n    }\n\n    enum TransactionVersion {\n        LEGACY\n        ZERO\n    }\n";
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/schema/common/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,ghCA2D1B,CAAC"}