@superfluid-finance/sdk-redux 0.6.2-dev.ff65ead.0 → 0.7.1-dev.030d123.0

package/dist/module/sdkReduxInitialization.d.ts

@@ -1,6 +1,6 @@
-import { CreateApi } from '@reduxjs/toolkit/dist/query';
-import type { ModuleName } from '@reduxjs/toolkit/dist/query/apiTypes';
-import { Framework } from '@superfluid-finance/sdk-core';
+import { type CreateApi } from '@reduxjs/toolkit/query';
+import { type Framework } from '@superfluid-finance/sdk-core';
+import { type ModuleName } from './reduxSlices/rtkQuery/ModuleName';
 /**
  * For initializing "rpcApiSlice" Redux slice.
  *
@@ -19,42 +19,447 @@ export declare const initializeSubgraphApiSlice: <T extends ModuleName>(createAp
  * For initializing "sfTransaction" Redux slice.
  */
 export declare const initializeTransactionTrackerSlice: () => {
+    reducerPath: "superfluid_transactions";
     name: "superfluid_transactions";
-    reducer: import("redux").Reducer<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>;
+    reducer: import("redux").Reducer<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>>;
     actions: import("@reduxjs/toolkit").CaseReducerActions<{
         addTransaction: {
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, entity: import(".").TrackedTransaction): S;
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, action: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, entity: import(".").TrackedTransaction): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, action: {
                 payload: import(".").TrackedTransaction;
                 type: string;
             }): S;
         };
         updateTransaction: {
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction>): S;
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, update: {
-                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction>;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: {
+                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>;
                 type: string;
             }): S;
         };
     }, "superfluid_transactions">;
     caseReducers: {
         addTransaction: {
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, entity: import(".").TrackedTransaction): S;
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, action: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, entity: import(".").TrackedTransaction): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, action: {
                 payload: import(".").TrackedTransaction;
                 type: string;
             }): S;
         };
         updateTransaction: {
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction>): S;
-            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>>(state: import("@reduxjs/toolkit/dist/tsHelpers").IsAny<S, import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>, S>, update: {
-                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction>;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: {
+                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>;
                 type: string;
             }): S;
         };
     };
-    getInitialState: () => import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction>;
-    reducerPath: "superfluid_transactions";
+    getInitialState: () => import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>;
+    getSelectors(): {};
+    getSelectors<RootState>(selectState: (rootState: RootState) => import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>): {};
+    selectors: {};
+    injectInto<NewReducerPath extends string = "superfluid_transactions">(this: import("@reduxjs/toolkit").Slice<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>, {
+        addTransaction: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, entity: import(".").TrackedTransaction): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, action: {
+                payload: import(".").TrackedTransaction;
+                type: string;
+            }): S;
+        };
+        updateTransaction: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: {
+                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>;
+                type: string;
+            }): S;
+        };
+    }, "superfluid_transactions", "superfluid_transactions", import("@reduxjs/toolkit").SliceSelectors<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>>>, injectable: {
+        inject: (slice: {
+            reducerPath: string;
+            reducer: import("redux").Reducer;
+        }, config?: {
+            overrideExisting?: boolean;
+        }) => void;
+    }, config?: ({
+        overrideExisting?: boolean;
+    } & {
+        reducerPath?: NewReducerPath | undefined;
+    }) | undefined): Omit<import("@reduxjs/toolkit").Slice<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>, {
+        addTransaction: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, entity: import(".").TrackedTransaction): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, action: {
+                payload: import(".").TrackedTransaction;
+                type: string;
+            }): S;
+        };
+        updateTransaction: {
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>): S;
+            <S extends import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | {
+                ids: string[];
+                entities: {
+                    [x: string]: {
+                        id: string;
+                        chainId: number;
+                        hash: string;
+                        signerAddress: string;
+                        timestampMs: number;
+                        status: import(".").TransactionStatus;
+                        transactionResponse?: string | undefined;
+                        transactionReceipt?: string | undefined;
+                        ethersErrorCode?: import("ethers").errors | undefined;
+                        ethersErrorMessage?: string | undefined;
+                        title: import(".").TransactionTitle;
+                        extraData: {
+                            [x: string]: unknown;
+                        };
+                        isSubgraphInSync?: true | undefined;
+                        blockTransactionSucceededIn?: number | undefined;
+                    };
+                };
+            }>(state: boolean extends (S extends never ? true : false) ? import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> : S, update: {
+                payload: import("@reduxjs/toolkit").Update<import(".").TrackedTransaction, string>;
+                type: string;
+            }): S;
+        };
+    }, "superfluid_transactions", NewReducerPath, import("@reduxjs/toolkit").SliceSelectors<import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>>>, "getSelectors" | "selectors"> & {
+        getSelectors(): {};
+        getSelectors<RootState>(selectState: (rootState: RootState) => import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | undefined): {};
+        readonly selectors: {};
+        selectSlice(state: { [K in NewReducerPath]?: import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string> | undefined; }): import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>;
+    };
+    selectSlice(state: {
+        superfluid_transactions: import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>;
+    }): import("@reduxjs/toolkit").EntityState<import(".").TrackedTransaction, string>;
 };
 /**
  * SDK-Redux needs to know where to get SDK-Core's Framework for data querying.

package/dist/module/sdkReduxInitialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdkReduxInitialization.d.ts","sourceRoot":"","sources":["../../src/sdkReduxInitialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAC,SAAS,EAAC,MAAM,8BAA8B,CAAC;AAOvD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,UAAU,aAAa,SAAS,CAAC,CAAC,CAAC,8NAIlF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,UAAU,aAAa,SAAS,CAAC,CAAC,CAAC,mOAIvF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,YAAa,MAAM,aAAa,CAAC,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,SAC1D,CAAC"}
+{"version":3,"file":"sdkReduxInitialization.d.ts","sourceRoot":"","sources":["../../src/sdkReduxInitialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,SAAS,EAAC,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAC,KAAK,SAAS,EAAC,MAAM,8BAA8B,CAAC;AAE5D,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,mCAAmC,CAAC;AAMlE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,UAAU,EAAE,WAAW,SAAS,CAAC,CAAC,CAAC,8NAIlF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,UAAU,EAAE,WAAW,SAAS,CAAC,CAAC,CAAC,mOAIvF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAay9mE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CATvgnE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,EAAE,WAAW,CAAC,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,SAC1D,CAAC"}

package/dist/module/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAO,CAAC,MAAQ,CAAC;AAE5C;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,CAErF;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IACxB,SAAS,OAAO;IAChB,WAAW,OAAO;IAClB,aAAa,QAAQ;IACrB,SAAS,QAAQ;IACjB,UAAU,SAAS;IACnB,YAAY,SAAS;IACrB,WAAW,SAAS;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,aAAuB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAAoB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,KAAK,CAAC,MAAQ,CAAC;AAE5C;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,CAErF;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IACxB,SAAS,OAAO;IAChB,WAAW,OAAO;IAClB,aAAa,QAAQ;IACrB,SAAS,QAAQ;IACjB,UAAU,SAAS;IACnB,YAAY,SAAS;IACrB,WAAW,SAAS;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAG,WAAoB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAG,QAAiB,CAAC"}

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@superfluid-finance/sdk-redux",
     "description": "SDK Redux for streamlined front-end application development with Superfluid Protocol",
-    "version": "0.6.2-dev.ff65ead.0",
-    "bugs": "https://github.com/superfluid-finance/protocol-monorepo/issues",
+    "version": "0.7.1-dev.030d123.0",
+    "bugs": "https://github.com/superfluid-org/protocol-monorepo/issues",
     "config": {
         "commitizen": {
             "path": "cz-conventional-changelog"
@@ -10,26 +10,25 @@
     },
     "dependencies": {
         "graphql-request": "6.1.0",
-        "lodash": "4.17.21",
+        "lodash.memoize": "4.1.2",
+        "lodash.uniqby": "4.7.0",
         "promise-retry": "2.0.1"
     },
     "devDependencies": {
-        "@reduxjs/toolkit": "^1.9.7",
+        "@reduxjs/toolkit": "^2",
+        "@types/lodash.memoize": "^4.1.9",
+        "@types/lodash.uniqby": "^4.7.9",
         "@types/promise-retry": "^1.1.6",
-        "@types/react": "^18",
-        "@types/react-dom": "^18",
-        "react": "^18",
-        "react-dom": "^18",
-        "react-redux": "^8.1.3"
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+        "react": "^19",
+        "react-dom": "^19",
+        "react-redux": "^9"
     },
     "directories": {
         "test": "test"
     },
-    "engines": {
-        "node": ">=12"
-    },
     "files": [
-        "dist/main",
         "dist/module",
         "CHANGELOG.md",
         "LICENSE",
@@ -38,21 +37,19 @@
     "homepage": "https://docs.superfluid.finance/",
     "keywords": [],
     "license": "MIT",
-    "main": "dist/main/index.js",
     "module": "dist/module/index.js",
     "peerDependencies": {
-        "@reduxjs/toolkit": "^1.7.0 || ^1.8.0 || ^1.9.0",
-        "@superfluid-finance/sdk-core": ">0.7.0"
+        "@reduxjs/toolkit": ">=2",
+        "@superfluid-finance/sdk-core": ">=0.7.0"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/superfluid-finance/protocol-monorepo.git",
+        "url": "https://github.com/superfluid-org/protocol-monorepo.git",
         "directory": "packages/sdk-redux"
     },
     "scripts": {
         "build": "rm -rf dist && run-p -l build:*",
-        "build:main": "tsc -p tsconfig.json",
-        "build:module": "tsc -p tsconfig.module.json",
+        "build:module": "tsc -p tsconfig.json",
         "lint": "run-s lint:*",
         "lint:eslint": "eslint src --ext .ts",
         "fix": "run-s fix:*",
@@ -66,7 +63,7 @@
         "cloc": "sh tasks/cloc.sh"
     },
     "sideEffects": [
-        "./src/sdkReduxConfig.ts"
+        "./dist/module/sdkReduxConfig.js"
     ],
     "typings": "dist/module/index.d.ts"
 }

package/LICENSE

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright © 2020-2023 Superfluid Finance Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/main/index.d.ts

@@ -1,39 +0,0 @@
-export * as _sdkCore from '@superfluid-finance/sdk-core';
-export * from './sdkReduxInitialization';
-export * from './sdkReduxConfig';
-export * from './reduxSlices/argTypes';
-export * from './reduxSlices/transactionTrackerSlice/ethersError';
-export * from './reduxSlices/transactionTrackerSlice/registerNewTransaction';
-export * from './reduxSlices/transactionTrackerSlice/transactionTitle';
-export * from './reduxSlices/transactionTrackerSlice/trackedTransaction';
-export * from './reduxSlices/transactionTrackerSlice/transactionTrackerAdapter';
-export * from './reduxSlices/transactionTrackerSlice/thunks/initiateNewTransactionTrackingThunk';
-export * from './reduxSlices/transactionTrackerSlice/thunks/initiateOldPendingTransactionsTrackingThunk';
-export * from './reduxSlices/transactionTrackerSlice/thunks/trackPendingTransactionThunk';
-export * from './reduxSlices/rtkQuery/createApiWithReactHooks';
-export * from './reduxSlices/rtkQuery/createApiWithoutReactHooks';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/rpcApiSlice';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/rpcBaseQuery';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/rpcEndpointBuilder';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/rpcReducerPath';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/allRpcEndpoints';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/flowArgs';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/flowEndpoints';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/indexEndpoints';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/indexArgs';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/superTokenArgs';
-export * from './reduxSlices/rtkQuery/rpcApiSlice/endpoints/superTokenEndpoints';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/provideSpecificCacheTagsFromRelevantAddresses';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/subgraphApiSlice';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/subgraphBaseQuery';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/subgraphEndpointBuilder';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/allSubgraphEndpoints';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/baseArgs';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/baseEndpoints';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/entityArgs';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/entityEndpoints';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/eventArgs';
-export * from './reduxSlices/rtkQuery/subgraphApiSlice/endpoints/eventEndpoints';
-export * from './reduxSlices/rtkQuery/cacheTags/CacheTagTypes';
-export * from './reduxSlices/rtkQuery/getSerializeQueryArgs';
-//# sourceMappingURL=index.d.ts.map

package/dist/main/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,8BAA8B,CAAC;AAEzD,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,mDAAmD,CAAC;AAClE,cAAc,8DAA8D,CAAC;AAC7E,cAAc,wDAAwD,CAAC;AACvE,cAAc,0DAA0D,CAAC;AACzE,cAAc,iEAAiE,CAAC;AAChF,cAAc,kFAAkF,CAAC;AACjG,cAAc,0FAA0F,CAAC;AACzG,cAAc,2EAA2E,CAAC;AAE1F,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC;AAElE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC;AAChE,cAAc,uDAAuD,CAAC;AACtE,cAAc,mDAAmD,CAAC;AAClE,cAAc,8DAA8D,CAAC;AAC7E,cAAc,uDAAuD,CAAC;AACtE,cAAc,4DAA4D,CAAC;AAC3E,cAAc,6DAA6D,CAAC;AAC5E,cAAc,wDAAwD,CAAC;AACvE,cAAc,6DAA6D,CAAC;AAC5E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,uFAAuF,CAAC;AACtG,cAAc,0DAA0D,CAAC;AACzE,cAAc,2DAA2D,CAAC;AAC1E,cAAc,iEAAiE,CAAC;AAChF,cAAc,wEAAwE,CAAC;AACvF,cAAc,4DAA4D,CAAC;AAC3E,cAAc,iEAAiE,CAAC;AAChF,cAAc,8DAA8D,CAAC;AAC7E,cAAc,mEAAmE,CAAC;AAClF,cAAc,6DAA6D,CAAC;AAC5E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,gDAAgD,CAAC;AAC/D,cAAc,8CAA8C,CAAC"}