@graphprotocol/graph-auth-kit 7.9.0 → 7.10.0

package/README.md

@@ -302,3 +302,49 @@ export function LetMeSwitchChain() {
 - [`wagmi`](https://wagmi.sh/)
 - [`viem`](https://viem.sh/)
 - [Engineering Plan](https://www.notion.so/edgeandnode/Replace-Wallet-Connection-Library-0e4c5e1e015b428dbb52b1f627b712f0)
+
+## Durable Safe submissions
+
+`SafeEthersSigner.withSubmissionCallbacks` returns a separate signer scoped to an application's
+publication operation. Use it on the publication contract only, not on an approval contract:
+
+```ts
+const publicationSigner = signer.withSubmissionCallbacks({
+  beforeSubmit: async (proposal) => {
+    await savePreparedProposal(proposal)
+  },
+  afterSubmit: async (proposal) => {
+    await confirmSubmittedProposal(proposal.safeTxHash)
+  },
+})
+const transaction = await publicationContract.connect(publicationSigner).publishNewSubgraph(/* arguments */)
+```
+
+The wallet signs before `beforeSubmit`. The callback receives a serializable unsigned snapshot,
+including the Safe address, decimal chain ID, proposal hash and complete transaction data (nonce
+as a decimal string). Its successful completion must mean durable persistence. If it rejects,
+nothing is submitted to Safe. The original shared signer remains unchanged.
+
+After reconciling the saved attempt, retry an absent proposal with an available nonce using
+`publicationSigner.sendPreparedTransaction(proposal)`. This requests a fresh signature but keeps
+the original nonce, gas fields, calldata and hash; it does not select a new nonce or estimate gas.
+Consumed nonces or mismatched hashes/Safes/chains fail before signing. SDK numeric nonce limits
+are checked without rounding. Applications must validate stored data and determine retry eligibility.
+
+`SafeSubmissionAcknowledgementError` means Safe accepted the proposal but `afterSubmit` failed.
+Its `proposal` and `cause` permit recovery; it does not mean the proposal failed. Safe API failures
+preserve `statusCode` and `data` (`SafeApiHttpError` is exported from the `/safe` entry point).
+Network failures may have no HTTP status. Keep uncertain attempts and reconcile their exact hashes;
+never infer execution failure from a browser exception. These optional callbacks do not change
+polling settings. This release upgrades Safe API/Protocol/Types Kit to 5.0.3/8.0.7/4.0.1.
+
+## Live integration tests
+
+Live RPC tests read `INFURA_KEY` from the test process environment. For local runs,
+you can instead put it in the ignored repository-root `.env.test.local` file;
+shell exports take precedence. Never commit credentials. Run the suite with
+`pnpm --filter @graphprotocol/graph-auth-kit test` from the repository root.
+
+The focused Safe submission, HTTP error, and polling tests mock external services.
+They do not require an RPC key. The complete suite also calls live RPC, ENS and
+Graph services, so passing the focused tests alone does not validate those integrations.

package/dist/{GraphAuthKitInner.context-DFDaC5w3.js → GraphAuthKitInner.context-DLfbf-o4.js}

@@ -9,6 +9,7 @@ import { l1Mainnet, l1Testnet, l2Mainnet, l2Testnet } from "@graphprotocol/commo
 import { mainnet, sepolia, arbitrum, arbitrumSepolia } from "viem/chains";
 import { injected, coinbaseWallet, walletConnect } from "wagmi/connectors";
 import "@safe-global/protocol-kit";
+import "@safe-global/api-kit";
 import { providers } from "ethers";
 const AUTH_STORAGE_KEY = "thegraph__authstate";
 const MULTISIG_AUTH_STORAGE_KEY = "multisig";

package/dist/client.d.ts

@@ -819,10 +819,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         gasUsed: bigint;
     }>;
     createBlockFilter: () => Promise<import('viem').CreateBlockFilterReturnType>;
-    createContractEventFilter: <const abi extends import('abitype').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi> | undefined, args extends import('viem').MaybeExtractEventArgsFromAbi<abi, eventName> | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').CreateContractEventFilterParameters<abi, eventName, args, strict, fromBlock, toBlock>) => Promise<import('viem').CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>;
-    createEventFilter: <const abiEvent extends import('abitype').AbiEvent | undefined = undefined, const abiEvents extends readonly import('abitype').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('abitype').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, _EventName extends string | undefined = import('viem').MaybeAbiEventName<abiEvent>, _Args extends import('viem').MaybeExtractEventArgsFromAbi<abiEvents, _EventName> | undefined = undefined>(args?: import('viem').CreateEventFilterParameters<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args> | undefined) => Promise<import('viem').CreateEventFilterReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args>>;
+    createContractEventFilter: <const abi extends import('viem').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi> | undefined, args extends import('viem').MaybeExtractEventArgsFromAbi<abi, eventName> | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').CreateContractEventFilterParameters<abi, eventName, args, strict, fromBlock, toBlock>) => Promise<import('viem').CreateContractEventFilterReturnType<abi, eventName, args, strict, fromBlock, toBlock>>;
+    createEventFilter: <const abiEvent extends import('viem').AbiEvent | undefined = undefined, const abiEvents extends readonly import('viem').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('viem').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, _EventName extends string | undefined = import('viem').MaybeAbiEventName<abiEvent>, _Args extends import('viem').MaybeExtractEventArgsFromAbi<abiEvents, _EventName> | undefined = undefined>(args?: import('viem').CreateEventFilterParameters<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args> | undefined) => Promise<import('viem').CreateEventFilterReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock, _EventName, _Args>>;
     createPendingTransactionFilter: () => Promise<import('viem').CreatePendingTransactionFilterReturnType>;
-    estimateContractGas: <chain extends import('viem').Chain | undefined, const abi extends import('abitype').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "nonpayable" | "payable">, args extends import('viem').ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>>(args: import('viem').EstimateContractGasParameters<abi, functionName, args, chain>) => Promise<import('viem').EstimateContractGasReturnType>;
+    estimateContractGas: <chain extends import('viem').Chain | undefined, const abi extends import('viem').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "nonpayable" | "payable">, args extends import('viem').ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>>(args: import('viem').EstimateContractGasParameters<abi, functionName, args, chain>) => Promise<import('viem').EstimateContractGasReturnType>;
     estimateGas: (args: import('viem').EstimateGasParameters<{
         graphCliName: string;
         caip2Id: `eip155:${string}` | `eip155:${number}` | `osmosis:${string}` | `osmosis:${number}` | `arweave:${string}` | `arweave:${number}` | `antelope:${string}` | `antelope:${number}` | `bip122:${string}` | `bip122:${number}` | `cosmos:${string}` | `cosmos:${number}` | `gear:${string}` | `gear:${number}` | `near:${string}` | `near:${number}` | `beacon:${string}` | `beacon:${number}` | `solana:${string}` | `solana:${number}` | `starknet:${string}` | `starknet:${number}` | `stellar:${string}` | `stellar:${number}`;
@@ -994,7 +994,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         extraData: import('viem').Hex;
         gasLimit: bigint;
         gasUsed: bigint;
-        miner: import('abitype').Address;
+        miner: import('viem').Address;
         mixHash: import('viem').Hash;
         parentBeaconBlockRoot?: `0x${string}` | undefined;
         parentHash: import('viem').Hash;
@@ -1010,10 +1010,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         withdrawals?: import('viem').Withdrawal[] | undefined | undefined;
         withdrawalsRoot?: `0x${string}` | undefined;
         transactions: includeTransactions extends true ? ({
-            from: import('abitype').Address;
+            from: import('viem').Address;
             gas: bigint;
             nonce: number;
-            to: import('abitype').Address | null;
+            to: import('viem').Address | null;
             type: "legacy";
             value: bigint;
             r: import('viem').Hex;
@@ -1035,10 +1035,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
             blockNumber: (blockTag extends "pending" ? true : false) extends infer T_1 ? T_1 extends (blockTag extends "pending" ? true : false) ? T_1 extends true ? null : bigint : never : never;
             transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_2 ? T_2 extends (blockTag extends "pending" ? true : false) ? T_2 extends true ? null : number : never : never;
         } | {
-            from: import('abitype').Address;
+            from: import('viem').Address;
             gas: bigint;
             nonce: number;
-            to: import('abitype').Address | null;
+            to: import('viem').Address | null;
             type: "eip2930";
             value: bigint;
             r: import('viem').Hex;
@@ -1060,10 +1060,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
             blockNumber: (blockTag extends "pending" ? true : false) extends infer T_4 ? T_4 extends (blockTag extends "pending" ? true : false) ? T_4 extends true ? null : bigint : never : never;
             transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_5 ? T_5 extends (blockTag extends "pending" ? true : false) ? T_5 extends true ? null : number : never : never;
         } | {
-            from: import('abitype').Address;
+            from: import('viem').Address;
             gas: bigint;
             nonce: number;
-            to: import('abitype').Address | null;
+            to: import('viem').Address | null;
             type: "eip1559";
             value: bigint;
             r: import('viem').Hex;
@@ -1085,10 +1085,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
             blockNumber: (blockTag extends "pending" ? true : false) extends infer T_7 ? T_7 extends (blockTag extends "pending" ? true : false) ? T_7 extends true ? null : bigint : never : never;
             transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_8 ? T_8 extends (blockTag extends "pending" ? true : false) ? T_8 extends true ? null : number : never : never;
         } | {
-            from: import('abitype').Address;
+            from: import('viem').Address;
             gas: bigint;
             nonce: number;
-            to: import('abitype').Address | null;
+            to: import('viem').Address | null;
             type: "eip4844";
             value: bigint;
             r: import('viem').Hex;
@@ -1110,10 +1110,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
             blockNumber: (blockTag extends "pending" ? true : false) extends infer T_10 ? T_10 extends (blockTag extends "pending" ? true : false) ? T_10 extends true ? null : bigint : never : never;
             transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_11 ? T_11 extends (blockTag extends "pending" ? true : false) ? T_11 extends true ? null : number : never : never;
         } | {
-            from: import('abitype').Address;
+            from: import('viem').Address;
             gas: bigint;
             nonce: number;
-            to: import('abitype').Address | null;
+            to: import('viem').Address | null;
             type: "eip7702";
             value: bigint;
             r: import('viem').Hex;
@@ -1141,7 +1141,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
     getBytecode: (args: import('viem').GetBytecodeParameters) => Promise<import('viem').GetBytecodeReturnType>;
     getChainId: () => Promise<import('viem').GetChainIdReturnType>;
     getCode: (args: import('viem').GetBytecodeParameters) => Promise<import('viem').GetBytecodeReturnType>;
-    getContractEvents: <const abi extends import('abitype').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi> | undefined = undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
+    getContractEvents: <const abi extends import('viem').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi> | undefined = undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
     getEip712Domain: (args: import('viem').GetEip712DomainParameters) => Promise<import('viem').GetEip712DomainReturnType>;
     getEnsAddress: (args: import('viem').GetEnsAddressParameters) => Promise<import('viem').GetEnsAddressReturnType>;
     getEnsAvatar: (args: import('viem').GetEnsAvatarParameters) => Promise<import('viem').GetEnsAvatarReturnType>;
@@ -1306,20 +1306,20 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         formatters?: undefined;
         serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
     }, chainOverride, type> | undefined) => Promise<import('viem').EstimateFeesPerGasReturnType<type>>;
-    getFilterChanges: <filterType extends import('viem').FilterType, const abi extends import('abitype').Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetFilterChangesParameters<filterType, abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>;
-    getFilterLogs: <const abi extends import('abitype').Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetFilterLogsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
+    getFilterChanges: <filterType extends import('viem').FilterType, const abi extends import('viem').Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetFilterChangesParameters<filterType, abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetFilterChangesReturnType<filterType, abi, eventName, strict, fromBlock, toBlock>>;
+    getFilterLogs: <const abi extends import('viem').Abi | readonly unknown[] | undefined, eventName extends string | undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args: import('viem').GetFilterLogsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<import('viem').GetFilterLogsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
     getGasPrice: () => Promise<import('viem').GetGasPriceReturnType>;
-    getLogs: <const abiEvent extends import('abitype').AbiEvent | undefined = undefined, const abiEvents extends readonly import('abitype').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('abitype').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args?: import('viem').GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock> | undefined) => Promise<import('viem').GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>;
+    getLogs: <const abiEvent extends import('viem').AbiEvent | undefined = undefined, const abiEvents extends readonly import('viem').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('viem').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined, fromBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined, toBlock extends import('viem').BlockNumber | import('viem').BlockTag | undefined = undefined>(args?: import('viem').GetLogsParameters<abiEvent, abiEvents, strict, fromBlock, toBlock> | undefined) => Promise<import('viem').GetLogsReturnType<abiEvent, abiEvents, strict, fromBlock, toBlock>>;
     getProof: (args: import('viem').GetProofParameters) => Promise<import('viem').GetProofReturnType>;
     estimateMaxPriorityFeePerGas: <chainOverride extends import('viem').Chain | undefined = undefined>(args?: {
         chain?: chainOverride | null | undefined;
     } | undefined) => Promise<import('viem').EstimateMaxPriorityFeePerGasReturnType>;
     getStorageAt: (args: import('viem').GetStorageAtParameters) => Promise<import('viem').GetStorageAtReturnType>;
     getTransaction: <blockTag extends import('viem').BlockTag = "latest">(args: import('viem').GetTransactionParameters<blockTag>) => Promise<{
-        from: import('abitype').Address;
+        from: import('viem').Address;
         gas: bigint;
         nonce: number;
-        to: import('abitype').Address | null;
+        to: import('viem').Address | null;
         type: "legacy";
         value: bigint;
         r: import('viem').Hex;
@@ -1341,10 +1341,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         blockNumber: (blockTag extends "pending" ? true : false) extends infer T_1 ? T_1 extends (blockTag extends "pending" ? true : false) ? T_1 extends true ? null : bigint : never : never;
         transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_2 ? T_2 extends (blockTag extends "pending" ? true : false) ? T_2 extends true ? null : number : never : never;
     } | {
-        from: import('abitype').Address;
+        from: import('viem').Address;
         gas: bigint;
         nonce: number;
-        to: import('abitype').Address | null;
+        to: import('viem').Address | null;
         type: "eip2930";
         value: bigint;
         r: import('viem').Hex;
@@ -1366,10 +1366,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         blockNumber: (blockTag extends "pending" ? true : false) extends infer T_4 ? T_4 extends (blockTag extends "pending" ? true : false) ? T_4 extends true ? null : bigint : never : never;
         transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_5 ? T_5 extends (blockTag extends "pending" ? true : false) ? T_5 extends true ? null : number : never : never;
     } | {
-        from: import('abitype').Address;
+        from: import('viem').Address;
         gas: bigint;
         nonce: number;
-        to: import('abitype').Address | null;
+        to: import('viem').Address | null;
         type: "eip1559";
         value: bigint;
         r: import('viem').Hex;
@@ -1391,10 +1391,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         blockNumber: (blockTag extends "pending" ? true : false) extends infer T_7 ? T_7 extends (blockTag extends "pending" ? true : false) ? T_7 extends true ? null : bigint : never : never;
         transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_8 ? T_8 extends (blockTag extends "pending" ? true : false) ? T_8 extends true ? null : number : never : never;
     } | {
-        from: import('abitype').Address;
+        from: import('viem').Address;
         gas: bigint;
         nonce: number;
-        to: import('abitype').Address | null;
+        to: import('viem').Address | null;
         type: "eip4844";
         value: bigint;
         r: import('viem').Hex;
@@ -1416,10 +1416,10 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         blockNumber: (blockTag extends "pending" ? true : false) extends infer T_10 ? T_10 extends (blockTag extends "pending" ? true : false) ? T_10 extends true ? null : bigint : never : never;
         transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_11 ? T_11 extends (blockTag extends "pending" ? true : false) ? T_11 extends true ? null : number : never : never;
     } | {
-        from: import('abitype').Address;
+        from: import('viem').Address;
         gas: bigint;
         nonce: number;
-        to: import('abitype').Address | null;
+        to: import('viem').Address | null;
         type: "eip7702";
         value: bigint;
         r: import('viem').Hex;
@@ -1757,7 +1757,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         fees?: import('viem').ChainFees<undefined> | undefined;
         formatters?: undefined;
         serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
-    }, chainOverride>, chainOverride extends import('viem').Chain | undefined = undefined, accountOverride extends import('viem').Account | import('abitype').Address | undefined = undefined>(args: import('viem').PrepareTransactionRequestParameters<{
+    }, chainOverride>, chainOverride extends import('viem').Chain | undefined = undefined, accountOverride extends import('viem').Account | import('viem').Address | undefined = undefined>(args: import('viem').PrepareTransactionRequestParameters<{
         graphCliName: string;
         caip2Id: `eip155:${string}` | `eip155:${number}` | `osmosis:${string}` | `osmosis:${number}` | `arweave:${string}` | `arweave:${number}` | `antelope:${string}` | `antelope:${number}` | `bip122:${string}` | `bip122:${number}` | `cosmos:${string}` | `cosmos:${number}` | `gear:${string}` | `gear:${number}` | `near:${string}` | `near:${number}` | `beacon:${string}` | `beacon:${number}` | `solana:${string}` | `solana:${number}` | `starknet:${string}` | `starknet:${number}` | `stellar:${string}` | `stellar:${number}`;
         blockExplorers: {
@@ -2387,7 +2387,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         chain?: undefined;
     } : never : never) & (import('viem').DeriveAccount<import('viem').Account | undefined, accountOverride> extends infer T_15 ? T_15 extends import('viem').DeriveAccount<import('viem').Account | undefined, accountOverride> ? T_15 extends import('viem').Account ? {
         account: T_15;
-        from: import('abitype').Address;
+        from: import('viem').Address;
     } : {
         account?: undefined;
         from?: undefined;
@@ -6107,7 +6107,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         chain?: undefined;
     } : never : never) & (import('viem').DeriveAccount<import('viem').Account | undefined, accountOverride> extends infer T_2 ? T_2 extends import('viem').DeriveAccount<import('viem').Account | undefined, accountOverride> ? T_2 extends import('viem').Account ? {
         account: T_2;
-        from: import('abitype').Address;
+        from: import('viem').Address;
     } : {
         account?: undefined;
         from?: undefined;
@@ -9354,12 +9354,12 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
     } ? "eip7702" : never) | (request["type"] extends string | undefined ? Extract<request["type"], string> : never)>) ? T_12 extends "eip7702" ? import('viem').TransactionRequestEIP7702 : never : never : never)>> & {
         chainId?: number | undefined;
     }, (request["parameters"] extends readonly import('viem').PrepareTransactionRequestParameterType[] ? request["parameters"][number] : "gas" | "nonce" | "type" | "blobVersionedHashes" | "chainId" | "fees") extends infer T_13 ? T_13 extends (request["parameters"] extends readonly import('viem').PrepareTransactionRequestParameterType[] ? request["parameters"][number] : "gas" | "nonce" | "type" | "blobVersionedHashes" | "chainId" | "fees") ? T_13 extends "fees" ? "gasPrice" | "maxFeePerGas" | "maxPriorityFeePerGas" : T_13 : never : never> & (unknown extends request["kzg"] ? {} : Pick<request, "kzg">))[K]; } : never>;
-    readContract: <const abi extends import('abitype').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "pure" | "view">, const args extends import('viem').ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: import('viem').ReadContractParameters<abi, functionName, args>) => Promise<import('viem').ReadContractReturnType<abi, functionName, args>>;
+    readContract: <const abi extends import('viem').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "pure" | "view">, const args extends import('viem').ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: import('viem').ReadContractParameters<abi, functionName, args>) => Promise<import('viem').ReadContractReturnType<abi, functionName, args>>;
     sendRawTransaction: (args: import('viem').SendRawTransactionParameters) => Promise<import('viem').SendRawTransactionReturnType>;
     simulate: <const calls extends readonly unknown[]>(args: import('viem').SimulateBlocksParameters<calls>) => Promise<import('viem').SimulateBlocksReturnType<calls>>;
     simulateBlocks: <const calls extends readonly unknown[]>(args: import('viem').SimulateBlocksParameters<calls>) => Promise<import('viem').SimulateBlocksReturnType<calls>>;
     simulateCalls: <const calls extends readonly unknown[]>(args: import('viem').SimulateCallsParameters<calls>) => Promise<import('viem').SimulateCallsReturnType<calls>>;
-    simulateContract: <const abi extends import('abitype').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "nonpayable" | "payable">, const args_1 extends import('viem').ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>, chainOverride extends import('viem').Chain | undefined, accountOverride extends import('viem').Account | import('abitype').Address | undefined = undefined>(args: import('viem').SimulateContractParameters<abi, functionName, args_1, {
+    simulateContract: <const abi extends import('viem').Abi | readonly unknown[], functionName extends import('viem').ContractFunctionName<abi, "nonpayable" | "payable">, const args_1 extends import('viem').ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>, chainOverride extends import('viem').Chain | undefined, accountOverride extends import('viem').Account | import('viem').Address | undefined = undefined>(args: import('viem').SimulateContractParameters<abi, functionName, args_1, {
         graphCliName: string;
         caip2Id: `eip155:${string}` | `eip155:${number}` | `osmosis:${string}` | `osmosis:${number}` | `arweave:${string}` | `arweave:${number}` | `antelope:${string}` | `antelope:${number}` | `bip122:${string}` | `bip122:${number}` | `cosmos:${string}` | `cosmos:${number}` | `gear:${string}` | `gear:${number}` | `near:${string}` | `near:${number}` | `beacon:${string}` | `beacon:${number}` | `solana:${string}` | `solana:${number}` | `starknet:${string}` | `starknet:${number}` | `stellar:${string}` | `stellar:${number}`;
         blockExplorers: {
@@ -9678,7 +9678,7 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         blockNumber?: bigint | undefined | undefined;
         blockTag?: import('viem').BlockTag | undefined;
         nonce?: string | undefined | undefined;
-        address?: string | undefined;
+        address?: `0x${string}` | undefined;
         domain?: string | undefined | undefined;
         scheme?: string | undefined | undefined;
         time?: Date | undefined;
@@ -10002,8 +10002,8 @@ export declare function buildPublicClient({ chain, infuraKey }: BuildPublicClien
         formatters?: undefined;
         serializers?: import('viem').ChainSerializers<undefined, import('viem').TransactionSerializable> | undefined;
     }, includeTransactions, blockTag>) => import('viem').WatchBlocksReturnType;
-    watchContractEvent: <const abi extends import('abitype').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi>, strict extends boolean | undefined = undefined>(args: import('viem').WatchContractEventParameters<abi, eventName, strict, HttpTransport>) => import('viem').WatchContractEventReturnType;
-    watchEvent: <const abiEvent extends import('abitype').AbiEvent | undefined = undefined, const abiEvents extends readonly import('abitype').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('abitype').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined>(args: import('viem').WatchEventParameters<abiEvent, abiEvents, strict, HttpTransport>) => import('viem').WatchEventReturnType;
+    watchContractEvent: <const abi extends import('viem').Abi | readonly unknown[], eventName extends import('viem').ContractEventName<abi>, strict extends boolean | undefined = undefined>(args: import('viem').WatchContractEventParameters<abi, eventName, strict, HttpTransport>) => import('viem').WatchContractEventReturnType;
+    watchEvent: <const abiEvent extends import('viem').AbiEvent | undefined = undefined, const abiEvents extends readonly import('viem').AbiEvent[] | readonly unknown[] | undefined = abiEvent extends import('viem').AbiEvent ? [abiEvent] : undefined, strict extends boolean | undefined = undefined>(args: import('viem').WatchEventParameters<abiEvent, abiEvents, strict, HttpTransport>) => import('viem').WatchEventReturnType;
     watchPendingTransactions: (args: import('viem').WatchPendingTransactionsParameters<HttpTransport>) => import('viem').WatchPendingTransactionsReturnType;
     extend: <const client extends {
         [x: string]: unknown;
@@ -11492,7 +11492,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
     }, {
         Method: "eth_coinbase";
         Parameters?: undefined;
-        ReturnType: import('abitype').Address;
+        ReturnType: import('viem').Address;
     }, {
         Method: "eth_estimateGas";
         Parameters: [transaction: import('viem').RpcTransactionRequest] | [transaction: import('viem').RpcTransactionRequest, block: import('viem').RpcBlockNumber | import('viem').BlockTag] | [transaction: import('viem').RpcTransactionRequest, block: import('viem').RpcBlockNumber | import('viem').BlockTag, stateOverride: import('viem').RpcStateOverride];
@@ -11507,7 +11507,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').Quantity;
     }, {
         Method: "eth_getBalance";
-        Parameters: [address: import('abitype').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
+        Parameters: [address: import('viem').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
         ReturnType: import('viem').Quantity;
     }, {
         Method: "eth_getBlockByHash";
@@ -11527,7 +11527,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').Quantity;
     }, {
         Method: "eth_getCode";
-        Parameters: [address: import('abitype').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
+        Parameters: [address: import('viem').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_getFilterChanges";
@@ -11540,7 +11540,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
     }, {
         Method: "eth_getLogs";
         Parameters: [{
-            address?: import('abitype').Address | import('abitype').Address[] | undefined;
+            address?: import('viem').Address | import('viem').Address[] | undefined;
             topics?: import('viem').LogTopic[] | undefined;
         } & ({
             fromBlock?: import('viem').RpcBlockNumber | import('viem').BlockTag | undefined;
@@ -11554,11 +11554,11 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').RpcLog[];
     }, {
         Method: "eth_getProof";
-        Parameters: [address: import('abitype').Address, storageKeys: import('viem').Hash[], block: import('viem').RpcBlockNumber | import('viem').BlockTag];
+        Parameters: [address: import('viem').Address, storageKeys: import('viem').Hash[], block: import('viem').RpcBlockNumber | import('viem').BlockTag];
         ReturnType: import('viem').RpcProof;
     }, {
         Method: "eth_getStorageAt";
-        Parameters: [address: import('abitype').Address, index: import('viem').Quantity, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
+        Parameters: [address: import('viem').Address, index: import('viem').Quantity, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_getTransactionByBlockHashAndIndex";
@@ -11574,7 +11574,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').RpcTransaction | null;
     }, {
         Method: "eth_getTransactionCount";
-        Parameters: [address: import('abitype').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
+        Parameters: [address: import('viem').Address, block: import('viem').RpcBlockNumber | import('viem').BlockTag | import('viem').RpcBlockIdentifier];
         ReturnType: import('viem').Quantity;
     }, {
         Method: "eth_getTransactionReceipt";
@@ -11609,7 +11609,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         Parameters: [filter: {
             fromBlock?: import('viem').RpcBlockNumber | import('viem').BlockTag | undefined;
             toBlock?: import('viem').RpcBlockNumber | import('viem').BlockTag | undefined;
-            address?: import('abitype').Address | import('abitype').Address[] | undefined;
+            address?: import('viem').Address | import('viem').Address[] | undefined;
             topics?: import('viem').LogTopic[] | undefined;
         }];
         ReturnType: import('viem').Quantity;
@@ -11657,7 +11657,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
     }, {
         Method: "eth_accounts";
         Parameters?: undefined;
-        ReturnType: import('abitype').Address[];
+        ReturnType: import('viem').Address[];
     }, {
         Method: "eth_chainId";
         Parameters?: undefined;
@@ -11669,7 +11669,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
     }, {
         Method: "eth_requestAccounts";
         Parameters?: undefined;
-        ReturnType: import('abitype').Address[];
+        ReturnType: import('viem').Address[];
     }, {
         Method: "eth_sendTransaction";
         Parameters: [transaction: import('viem').RpcTransactionRequest];
@@ -11680,7 +11680,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').Hash;
     }, {
         Method: "eth_sign";
-        Parameters: [address: import('abitype').Address, data: import('viem').Hex];
+        Parameters: [address: import('viem').Address, data: import('viem').Hex];
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_signTransaction";
@@ -11688,7 +11688,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_signTypedData_v4";
-        Parameters: [address: import('abitype').Address, message: string];
+        Parameters: [address: import('viem').Address, message: string];
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_syncing";
@@ -11696,7 +11696,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').NetworkSync | false;
     }, {
         Method: "personal_sign";
-        Parameters: [data: import('viem').Hex, address: import('abitype').Address];
+        Parameters: [data: import('viem').Hex, address: import('viem').Address];
         ReturnType: import('viem').Hex;
     }, {
         Method: "wallet_addEthereumChain";
@@ -11712,21 +11712,21 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
                 }[];
                 type: "create";
             } | {
-                address: import('abitype').Address;
+                address: import('viem').Address;
                 chainId?: number | undefined;
                 type: "deployed";
             } | {
-                address: import('abitype').Address;
+                address: import('viem').Address;
                 chainId?: number | undefined;
-                factory: import('abitype').Address;
+                factory: import('viem').Address;
                 factoryData: import('viem').Hex;
                 type: "undeployed";
             }>;
             version: string;
         }];
         ReturnType: {
-            address: import('abitype').Address;
-            factory?: import('abitype').Address | undefined;
+            address: import('viem').Address;
+            factory?: import('viem').Address | undefined;
             factoryData?: import('viem').Hex | undefined;
         };
     }, {
@@ -11737,7 +11737,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         }];
         ReturnType: {
             accounts: readonly {
-                address: import('abitype').Address;
+                address: import('viem').Address;
                 capabilities?: import('viem').Capabilities | undefined;
             }[];
         };
@@ -11755,7 +11755,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').WalletGetCallsStatusReturnType;
     }, {
         Method: "wallet_getCapabilities";
-        Parameters?: readonly [] | readonly [import('abitype').Address | undefined] | readonly [import('abitype').Address | undefined, readonly import('viem').Hex[] | undefined] | undefined;
+        Parameters?: readonly [] | readonly [import('viem').Address | undefined] | readonly [import('viem').Address | undefined, readonly import('viem').Hex[] | undefined] | undefined;
         ReturnType: import('viem').Prettify<import('viem').WalletCapabilitiesRecord>;
     }, {
         Method: "wallet_getPermissions";
@@ -11805,7 +11805,7 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').Hex;
     }, {
         Method: "eth_estimateUserOperationGas";
-        Parameters: [userOperation: import('viem').RpcUserOperation, entrypoint: import('abitype').Address] | [userOperation: import('viem').RpcUserOperation, entrypoint: import('abitype').Address, stateOverrideSet: import('viem').RpcStateOverride];
+        Parameters: [userOperation: import('viem').RpcUserOperation, entrypoint: import('viem').Address] | [userOperation: import('viem').RpcUserOperation, entrypoint: import('viem').Address, stateOverrideSet: import('viem').RpcStateOverride];
         ReturnType: import('viem').RpcEstimateUserOperationGasReturnType;
     }, {
         Method: "eth_getUserOperationByHash";
@@ -11817,19 +11817,19 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         ReturnType: import('viem').RpcUserOperationReceipt | null;
     }, {
         Method: "eth_sendUserOperation";
-        Parameters: [userOperation: import('viem').RpcUserOperation, entrypoint: import('abitype').Address];
+        Parameters: [userOperation: import('viem').RpcUserOperation, entrypoint: import('viem').Address];
         ReturnType: import('viem').Hash;
     }, {
         Method: "eth_supportedEntryPoints";
         Parameters?: undefined;
-        ReturnType: readonly import('abitype').Address[];
+        ReturnType: readonly import('viem').Address[];
     }, {
         Method: "pm_getPaymasterStubData";
-        Parameters?: [userOperation: import('viem').OneOf<import('viem').PartialBy<Pick<import('viem').RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit"> | import('viem').PartialBy<Pick<import('viem').RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit">>, entrypoint: import('abitype').Address, chainId: import('viem').Hex, context: unknown];
+        Parameters?: [userOperation: import('viem').OneOf<import('viem').PartialBy<Pick<import('viem').RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit"> | import('viem').PartialBy<Pick<import('viem').RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "preVerificationGas" | "verificationGasLimit">>, entrypoint: import('viem').Address, chainId: import('viem').Hex, context: unknown];
         ReturnType: import('viem').OneOf<{
             paymasterAndData: import('viem').Hex;
         } | {
-            paymaster: import('abitype').Address;
+            paymaster: import('viem').Address;
             paymasterData: import('viem').Hex;
             paymasterVerificationGasLimit: import('viem').Hex;
             paymasterPostOpGasLimit: import('viem').Hex;
@@ -11842,11 +11842,11 @@ export declare function buildClient({ chain, infuraKey }: BuildClientArgs): {
         };
     }, {
         Method: "pm_getPaymasterData";
-        Parameters?: [userOperation: Pick<import('viem').RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit"> | Pick<import('viem').RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, entrypoint: import('abitype').Address, chainId: import('viem').Hex, context: unknown];
+        Parameters?: [userOperation: Pick<import('viem').RpcUserOperation<"0.6">, "callData" | "callGasLimit" | "initCode" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit"> | Pick<import('viem').RpcUserOperation<"0.7">, "callData" | "callGasLimit" | "factory" | "factoryData" | "maxFeePerGas" | "maxPriorityFeePerGas" | "nonce" | "sender" | "preVerificationGas" | "verificationGasLimit">, entrypoint: import('viem').Address, chainId: import('viem').Hex, context: unknown];
         ReturnType: import('viem').OneOf<{
             paymasterAndData: import('viem').Hex;
         } | {
-            paymaster: import('abitype').Address;
+            paymaster: import('viem').Address;
             paymasterData: import('viem').Hex;
             paymasterVerificationGasLimit: import('viem').Hex;
             paymasterPostOpGasLimit: import('viem').Hex;

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,MAAM,CAAA;AACjF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAYvB,QAAA,MAAM,4BAA4B;;;iBAEhC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACvF,wBAAgB,wBAAwB,CAAC,EACvC,KAAmB,EACnB,SAAS,GACV,EAAE,4BAA4B,GAAG,aAAa,CAe9C;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACzE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,eAAe,CAE1E;AAED,wBAAgB,iBAAiB,CAAC,EAAE,KAAgB,EAAE,SAAS,EAAE,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0rBA+BqvU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA+mP,CAAC;mCAA6lC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kfAA81mB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,MAAM,CAAA;AACjF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAYvB,QAAA,MAAM,4BAA4B;;;iBAEhC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACvF,wBAAgB,wBAAwB,CAAC,EACvC,KAAmB,EACnB,SAAS,GACV,EAAE,4BAA4B,GAAG,aAAa,CAe9C;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACzE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,eAAe,CAE1E;AAED,wBAAgB,iBAAiB,CAAC,EAAE,KAAgB,EAAE,SAAS,EAAE,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;irBA+BqvU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA+mP,CAAC;mCAA6lC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yeAA81mB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EArB13sC;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE/D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,wBAAgB,WAAW,CAAC,EAAE,KAAgB,EAAE,SAAS,EAAE,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAaittB,CAAC;kBAAyD,CAAC;;qBAAsE,CAAC;mBAA6D,CAAC;qBAA+D,CAAC;;qBAAwD,CAAC;mBAAoC,CAAC;qBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAy3M,CAAC;mBAA6D,CAAC;mBAA6D,CAAC;kBAAyD,CAAC;;;;;;;;;;;;;;;;;;;8BAA6qD,CAAC;qBAA2D,CAAC;8BAA6F,CAAC;;kCAA2F,CAAC;0BAAqD,CAAC;sBAAiD,CAAC;;;;qBAA+K,CAAC;wBAA4B,CAAC;;;;oBAA6I,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAm+mB,CAAC;;;;uBAAmJ,CAAC;;;;;;;;;mBAA+R,CAAC;uBAA8C,CAAC;;;;;wBAAyZ,CAAC;;;;;;4BAA2M,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAprzC,CAAC;;oBAAsD,CAAC;;mBAAoE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAH9iW;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/ens/index.js

@@ -1,4 +1,4 @@
-import { u, a, b, c } from "../useGraphAuthKitEnsNames-BOTbNQrR.js";
+import { u, a, b, c } from "../useGraphAuthKitEnsNames-Bl3soyKU.js";
 export {
   u as useGraphAuthKitAvatar,
   a as useGraphAuthKitAvatars,

package/dist/{hooks-DeU86P4k.js → hooks-N_8StIGc.js}

@@ -8,7 +8,7 @@ import { useMemo, useState, useEffect } from "react";
 import { encodeFunctionData, getAddress, isAddress } from "viem";
 import { useChainId, useConnectorClient, useAccount, useConfig, useAccountEffect, useWalletClient } from "wagmi";
 import { writeContractMutationOptions } from "wagmi/query";
-import { b as createSafe, c as createApiKit, K as useGraphAuthKitInnerContext, I as clientToProvider, w as GraphAuthKitConnector, M as MULTISIG_AUTH_STORAGE_KEY, N as MultisigSchema } from "./GraphAuthKitInner.context-DFDaC5w3.js";
+import { b as createSafe, c as createApiKit, K as useGraphAuthKitInnerContext, I as clientToProvider, w as GraphAuthKitConnector, M as MULTISIG_AUTH_STORAGE_KEY, N as MultisigSchema } from "./GraphAuthKitInner.context-DLfbf-o4.js";
 import { VoidSigner } from "@ethersproject/abstract-signer";
 import "@safe-global/protocol-kit";
 import { OperationType } from "@safe-global/types-kit";
@@ -103,6 +103,21 @@ const mapReceipt = (receipt, safeTx) => {
   return receipt;
 };
 const sleep = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+class SafeSubmissionAcknowledgementError extends Error {
+  constructor(proposal, cause) {
+    super("Safe accepted the proposal, but persisting its acknowledgement failed");
+    __publicField(this, "cause");
+    this.proposal = proposal;
+    this.name = "SafeSubmissionAcknowledgementError";
+    this.cause = cause;
+  }
+}
+function safeNonce(value) {
+  if (!/^\d+$/.test(String(value)) || !Number.isSafeInteger(Number(value))) {
+    throw new RangeError("Safe nonce exceeds the SDK supported integer range");
+  }
+  return Number(value);
+}
 class SafeEthersSigner extends VoidSigner {
   constructor(safeAddress, provider, signerAddress, chainId, options) {
     super(safeAddress, provider);
@@ -110,6 +125,7 @@ class SafeEthersSigner extends VoidSigner {
     __publicField(this, "signerAddress");
     __publicField(this, "chainId");
     __publicField(this, "options");
+    __publicField(this, "submissionCallbacks", {});
     __publicField(this, "safe");
     __publicField(this, "apiKit");
     this.signerAddress = signerAddress;
@@ -150,14 +166,23 @@ class SafeEthersSigner extends VoidSigner {
     }
     return this.apiKit;
   }
+  /** Return a scoped signer; never change callbacks on the shared wallet signer. */
+  withSubmissionCallbacks(callbacks) {
+    const signer = new SafeEthersSigner(
+      this.safeAddress,
+      this.provider,
+      this.signerAddress,
+      this.chainId,
+      this.options
+    );
+    signer.submissionCallbacks = { ...callbacks };
+    signer.safe = this.safe;
+    signer.apiKit = this.apiKit;
+    return signer;
+  }
   async getNextNonce() {
-    try {
-      const apiKit = await this.getApiKitInstance();
-      const nonce = await apiKit.getNextNonce(this.safeAddress);
-      return parseInt(nonce, 10);
-    } catch (error) {
-      throw new Error(`Failed to get next nonce: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    const apiKit = await this.getApiKitInstance();
+    return safeNonce(await apiKit.getNextNonce(this.safeAddress));
   }
   async buildTransactionResponse(safeTxHash, safeTx) {
     const connectedSafe = await this.getSafeInstance();
@@ -226,17 +251,83 @@ class SafeEthersSigner extends VoidSigner {
     const estimateTx = await apiKit.estimateSafeTransaction(this.safeAddress, safeTransactionData);
     safeTransactionData.safeTxGas = estimateTx.safeTxGas;
     const connectedSafe = await this.getSafeInstance();
-    const safeTransaction = await connectedSafe.createTransaction({ transactions: [safeTransactionData] });
+    const safeTransaction = await connectedSafe.createTransaction({
+      transactions: [safeTransactionData],
+      options: { nonce, safeTxGas: estimateTx.safeTxGas }
+    });
     const safeTxHash = await connectedSafe.getTransactionHash(safeTransaction);
-    const senderSignature = await connectedSafe.signHash(safeTxHash);
-    await apiKit.proposeTransaction({
+    return this.sendPreparedTransaction({
+      schemaVersion: 1,
       safeAddress: this.safeAddress,
-      safeTransactionData: safeTransaction.data,
+      chainId: String(this.chainId),
       safeTxHash,
+      transaction: { ...safeTransaction.data, nonce: String(safeTransaction.data.nonce) }
+    });
+  }
+  /** Retry the exact proposal, without nonce selection, estimation, or metadata reconstruction. */
+  async sendPreparedTransaction(input) {
+    var _a, _b, _c, _d;
+    const proposal = Object.freeze({
+      schemaVersion: input.schemaVersion,
+      safeAddress: input.safeAddress,
+      chainId: input.chainId,
+      safeTxHash: input.safeTxHash,
+      transaction: Object.freeze({
+        to: input.transaction.to,
+        value: input.transaction.value,
+        data: input.transaction.data,
+        operation: input.transaction.operation,
+        safeTxGas: input.transaction.safeTxGas,
+        baseGas: input.transaction.baseGas,
+        gasPrice: input.transaction.gasPrice,
+        gasToken: input.transaction.gasToken,
+        refundReceiver: input.transaction.refundReceiver,
+        nonce: input.transaction.nonce
+      })
+    });
+    if (proposal.schemaVersion !== 1 || proposal.safeAddress.toLowerCase() !== this.safeAddress.toLowerCase() || proposal.chainId !== String(this.chainId) || !utils.isHexString(proposal.safeTxHash, 32)) {
+      throw new Error("Prepared Safe proposal does not match the connected Safe and chain");
+    }
+    const connectedSafe = await this.getSafeInstance();
+    if ((await connectedSafe.getChainId()).toString() !== proposal.chainId) {
+      throw new Error("Connected wallet chain changed before Safe submission");
+    }
+    const data = { ...proposal.transaction, nonce: safeNonce(proposal.transaction.nonce) };
+    const safeTransaction = await connectedSafe.createTransaction({
+      transactions: [{ to: data.to, value: data.value, data: data.data, operation: data.operation }],
+      options: {
+        nonce: data.nonce,
+        safeTxGas: data.safeTxGas,
+        baseGas: data.baseGas,
+        gasPrice: data.gasPrice,
+        gasToken: data.gasToken,
+        refundReceiver: data.refundReceiver
+      }
+    });
+    const hash = await connectedSafe.getTransactionHash(safeTransaction);
+    if (hash.toLowerCase() !== proposal.safeTxHash.toLowerCase()) {
+      throw new Error("Prepared Safe proposal hash does not match its transaction data");
+    }
+    if (BigNumber.from(await connectedSafe.getNonce()).gt(data.nonce)) {
+      throw new Error("Prepared Safe proposal nonce has been consumed; reconcile before retrying");
+    }
+    const senderSignature = await connectedSafe.signHash(hash);
+    const response = await this.buildTransactionResponse(hash, data);
+    const apiKit = await this.getApiKitInstance();
+    await ((_b = (_a = this.submissionCallbacks).beforeSubmit) == null ? void 0 : _b.call(_a, proposal));
+    await apiKit.proposeTransaction({
+      safeAddress: this.safeAddress,
+      safeTransactionData: data,
+      safeTxHash: hash,
       senderAddress: this.signerAddress,
       senderSignature: senderSignature.data
     });
-    return this.buildTransactionResponse(safeTxHash, safeTransaction.data);
+    try {
+      await ((_d = (_c = this.submissionCallbacks).afterSubmit) == null ? void 0 : _d.call(_c, proposal));
+    } catch (error) {
+      throw new SafeSubmissionAcknowledgementError(proposal, error);
+    }
+    return response;
   }
 }
 function safeViemActions(safeAddress, chainId, safeApiKey) {
@@ -502,14 +593,15 @@ function useGraphAuthKitWriteContract(parameters = {}) {
   };
 }
 export {
-  SafeEthersSigner as S,
-  useGraphAuthKitAccount as a,
-  useGraphAuthKitConnector as b,
-  useClientToEthersSigner as c,
-  useAuthAccount as d,
-  useGraphAuthKitAccountEffect as e,
-  useGraphAuthKitWalletClient as f,
-  useGraphAuthKitWriteContract as g,
+  SafeSubmissionAcknowledgementError as S,
+  SafeEthersSigner as a,
+  useGraphAuthKitAccount as b,
+  useGraphAuthKitConnector as c,
+  useClientToEthersSigner as d,
+  useAuthAccount as e,
+  useGraphAuthKitAccountEffect as f,
+  useGraphAuthKitWalletClient as g,
+  useGraphAuthKitWriteContract as h,
   mapReceipt as m,
   useMultisigInfo as u
 };

package/dist/index.js

@@ -1,13 +1,14 @@
 "use client";
-import { m, A, k, B, D, w, G, L, n, o, p, M, O, v, R, u, a, S, q, r, s, t, l, g, j, x, I, J, c, b, f, h, E, C, F, H, e, i, y, d, z } from "./GraphAuthKitInner.context-DFDaC5w3.js";
-import { G as G2, a as a2, M as M2, b as b2, d as d2, u as u2 } from "./utils-CHmOZz26.js";
-import { a as useGraphAuthKitAccount, b as useGraphAuthKitConnector } from "./hooks-DeU86P4k.js";
-import { S as S2, m as m2, d as d3, c as c2, e as e2, f as f2, g as g2, u as u3 } from "./hooks-DeU86P4k.js";
-import { g as g3, u as u4, w as w2 } from "./useWaitForSafeTransaction-DqUJ6JOu.js";
+import { m, A, k, B, D, w, G, L, n, o, p, M, O, v, R, u, a, S, q, r, s, t, l, g, j, x, I, J, c, b, f, h, E, C, F, H, e, i, y, d, z } from "./GraphAuthKitInner.context-DLfbf-o4.js";
+import { G as G2, a as a2, M as M2, b as b2, d as d2, u as u2 } from "./utils-Cjhggvka.js";
+import { b as useGraphAuthKitAccount, c as useGraphAuthKitConnector } from "./hooks-N_8StIGc.js";
+import { a as a3, S as S2, m as m2, e as e2, d as d3, f as f2, g as g2, h as h2, u as u3 } from "./hooks-N_8StIGc.js";
+import { g as g3, u as u4, w as w2 } from "./useWaitForSafeTransaction-CxGjZhJy.js";
+import { HttpError } from "@safe-global/api-kit";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Alert, ExperimentalButton } from "@graphprotocol/gds";
 import { useConfig, useSwitchChain } from "wagmi";
-import { u as u5, a as a3, b as b3, c as c3 } from "./useGraphAuthKitEnsNames-BOTbNQrR.js";
+import { u as u5, a as a4, b as b3, c as c2 } from "./useGraphAuthKitEnsNames-Bl3soyKU.js";
 function Connected({ children }) {
   const account = useGraphAuthKitAccount();
   const connector = useGraphAuthKitConnector();
@@ -92,7 +93,9 @@ export {
   v as OptionalSafeApiKey,
   R as RequiredInfuraKey,
   u as RequiredWalletConnectProjectId,
-  S2 as SafeEthersSigner,
+  HttpError as SafeApiHttpError,
+  a3 as SafeEthersSigner,
+  S2 as SafeSubmissionAcknowledgementError,
   a as SafeSupportedNetworkNames,
   S as SafeSupportedNetworks,
   q as SupportedClientChainId,
@@ -123,18 +126,18 @@ export {
   d as isValidSafe,
   z as mapChainIdToChain,
   m2 as mapReceipt,
-  d3 as useAuthAccount,
-  c2 as useClientToEthersSigner,
+  e2 as useAuthAccount,
+  d3 as useClientToEthersSigner,
   u2 as useGraphAuthKit,
   useGraphAuthKitAccount,
-  e2 as useGraphAuthKitAccountEffect,
+  f2 as useGraphAuthKitAccountEffect,
   u5 as useGraphAuthKitAvatar,
-  a3 as useGraphAuthKitAvatars,
+  a4 as useGraphAuthKitAvatars,
   useGraphAuthKitConnector,
   b3 as useGraphAuthKitEnsName,
-  c3 as useGraphAuthKitEnsNames,
-  f2 as useGraphAuthKitWalletClient,
-  g2 as useGraphAuthKitWriteContract,
+  c2 as useGraphAuthKitEnsNames,
+  g2 as useGraphAuthKitWalletClient,
+  h2 as useGraphAuthKitWriteContract,
   u3 as useMultisigInfo,
   u4 as useWaitForSafeTransaction,
   w2 as waitForSafeTransation

package/dist/inner/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/inner/hooks.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAyB,KAAK,wBAAwB,EAAE,MAAM,UAAU,CAAA;AAI/E;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,SAAS,wBAAwB,EAAE,CA8C9E;AAED,wBAAgB,yBAAyB,IAAI,SAAS,wBAAwB,EAAE,CAsC/E"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/inner/hooks.tsx"],"names":[],"mappings":"AASA,OAAO,EAAyB,KAAK,wBAAwB,EAAE,MAAM,UAAU,CAAA;AAI/E;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,SAAS,wBAAwB,EAAE,CA8C9E;AAED,wBAAgB,yBAAyB,IAAI,SAAS,wBAAwB,EAAE,CAsC/E"}

package/dist/safe/SafeEthersSigner.d.ts

@@ -10,6 +10,27 @@ export declare const mapReceipt: (receipt: providers.TransactionReceipt, safeTx:
 export interface SafeTransactionResponse extends TransactionResponse {
     operation: OperationType;
 }
+/** Serializable unsigned snapshot. Signatures deliberately never reach persistence callbacks. */
+export interface PreparedSafeTransaction {
+    schemaVersion: 1;
+    safeAddress: string;
+    chainId: string;
+    safeTxHash: string;
+    transaction: Omit<SafeTransactionData, 'nonce'> & {
+        nonce: string;
+    };
+}
+export interface SafeSubmissionCallbacks {
+    /** Must durably save the proposal before resolving. Rejection prevents submission. */
+    beforeSubmit?: (proposal: PreparedSafeTransaction) => Promise<void>;
+    /** Safe accepted the proposal; failure here does not mean submission failed. */
+    afterSubmit?: (proposal: PreparedSafeTransaction) => Promise<void>;
+}
+export declare class SafeSubmissionAcknowledgementError extends Error {
+    readonly proposal: PreparedSafeTransaction;
+    readonly cause: unknown;
+    constructor(proposal: PreparedSafeTransaction, cause: unknown);
+}
 export interface SafeEthersSignerOptions {
     /** Delay between Safe status requests in milliseconds (5,000–2,147,483,647). Defaults to 5,000. */
     pollingDelay?: number;
@@ -20,6 +41,7 @@ export declare class SafeEthersSigner extends VoidSigner {
     readonly signerAddress: string;
     readonly chainId: SafeSupportedNetworks;
     readonly options?: SafeEthersSignerOptions;
+    private submissionCallbacks;
     safe?: Safe;
     apiKit?: SafeApiKit;
     constructor(safeAddress: string, provider: providers.Web3Provider, signerAddress: string, chainId: SafeSupportedNetworks, options?: SafeEthersSignerOptions);
@@ -27,6 +49,8 @@ export declare class SafeEthersSigner extends VoidSigner {
     getSafeInstance(): Promise<Safe>;
     createApiKitInstance(): Promise<SafeApiKit>;
     getApiKitInstance(): Promise<SafeApiKit>;
+    /** Return a scoped signer; never change callbacks on the shared wallet signer. */
+    withSubmissionCallbacks(callbacks: SafeSubmissionCallbacks): SafeEthersSigner;
     getNextNonce(): Promise<number>;
     buildTransactionResponse(safeTxHash: string, safeTx: SafeTransactionData): Promise<SafeTransactionResponse>;
     /**
@@ -36,5 +60,7 @@ export declare class SafeEthersSigner extends VoidSigner {
      * @returns A promise that resolves to a SafeTransactionReponse, that contains all the information of the transaction.
      */
     sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<SafeTransactionResponse>;
+    /** Retry the exact proposal, without nonce selection, estimation, or metadata reconstruction. */
+    sendPreparedTransaction(input: PreparedSafeTransaction): Promise<SafeTransactionResponse>;
 }
 //# sourceMappingURL=SafeEthersSigner.d.ts.map

package/dist/safe/SafeEthersSigner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SafeEthersSigner.d.ts","sourceRoot":"","sources":["../../src/safe/SafeEthersSigner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AACnH,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,UAAU,MAAM,sBAAsB,CAAA;AAClD,OAAO,IAA8B,MAAM,2BAA2B,CAAA;AACtE,OAAO,EAAE,aAAa,EAAE,KAAK,mBAAmB,EAAmC,MAAM,wBAAwB,CAAA;AACjH,OAAO,EAAa,KAAK,SAAS,EAAS,MAAM,QAAQ,CAAA;AAEzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAgGxD,eAAO,MAAM,UAAU,GAAI,SAAS,SAAS,CAAC,kBAAkB,EAAE,QAAQ,mBAAmB,uBAK5F,CAAA;AAID,MAAM,WAAW,uBAAwB,SAAQ,mBAAmB;IAClE,SAAS,EAAE,aAAa,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,mGAAmG;IACnG,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAGD,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAA;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAA;IAC1C,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,MAAM,CAAC,EAAE,UAAU,CAAA;gBAGjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,SAAS,CAAC,YAAY,EAChC,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,CAAC,EAAE,uBAAuB;IAiB7B,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAcnC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtC,oBAAoB;IAId,iBAAiB;IAOjB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAU/B,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAqCjH;;;;;OAKG;IACY,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAkD9G"}
+{"version":3,"file":"SafeEthersSigner.d.ts","sourceRoot":"","sources":["../../src/safe/SafeEthersSigner.ts"],"names":[],"mappings":"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"}

package/dist/safe/index.d.ts

@@ -2,4 +2,5 @@ export * from './constants';
 export * from './SafeEthersSigner';
 export * from './useWaitForSafeTransaction';
 export * from './utils';
+export { HttpError as SafeApiHttpError } from '@safe-global/api-kit';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/safe/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/safe/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,SAAS,CAAA;AAEvB,OAAO,EAAE,SAAS,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/safe/index.js

@@ -1,9 +1,12 @@
-import { A, a, S, c, b, f, e, i, d } from "../GraphAuthKitInner.context-DFDaC5w3.js";
-import { S as S2, m } from "../hooks-DeU86P4k.js";
-import { g, u, w } from "../useWaitForSafeTransaction-DqUJ6JOu.js";
+import { A, a, S, c, b, f, e, i, d } from "../GraphAuthKitInner.context-DLfbf-o4.js";
+import { a as a2, S as S2, m } from "../hooks-N_8StIGc.js";
+import { g, u, w } from "../useWaitForSafeTransaction-CxGjZhJy.js";
+import { HttpError } from "@safe-global/api-kit";
 export {
   A as ApiKitUrlMap,
-  S2 as SafeEthersSigner,
+  HttpError as SafeApiHttpError,
+  a2 as SafeEthersSigner,
+  S2 as SafeSubmissionAcknowledgementError,
   a as SafeSupportedNetworkNames,
   S as SafeSupportedNetworks,
   c as createApiKit,

package/dist/test-harness/index.js

@@ -1,4 +1,4 @@
-import { M, b, d } from "../utils-CHmOZz26.js";
+import { M, b, d } from "../utils-Cjhggvka.js";
 export {
   M as MockGraphAuthKitProvider,
   b as buildMockProviderState,

package/dist/test-harness/utils.d.ts

@@ -16,13 +16,13 @@ declare const BuildMockProviderStateArgs: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"generated">;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"provided">;
-        address: z.ZodCustom<string, string>;
+        address: z.ZodCustom<`0x${string}`, `0x${string}`>;
         chain: z.ZodDefault<z.ZodOptional<z.ZodReadonly<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<11155111>, z.ZodLiteral<42161>, z.ZodLiteral<421614>]>>>>;
         connector: z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodUnion<readonly [z.ZodLiteral<"injected">, z.ZodLiteral<"coinbaseWallet">, z.ZodLiteral<"walletConnect">]>;
         }, z.core.$strip>, z.ZodObject<{
             type: z.ZodLiteral<"multisig">;
-            eoa: z.ZodCustom<string, string>;
+            eoa: z.ZodCustom<`0x${string}`, `0x${string}`>;
             network: z.ZodDefault<z.ZodOptional<z.ZodReadonly<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<11155111>, z.ZodLiteral<42161>]>>>>;
         }, z.core.$strip>]>;
     }, z.core.$strip>]>;

package/dist/{useGraphAuthKitEnsNames-BOTbNQrR.js → useGraphAuthKitEnsNames-Bl3soyKU.js}

@@ -2,8 +2,8 @@
 import { createIdenticon } from "@graphprotocol/gds";
 import { getEnsAvatarQueryKey, getEnsNameQueryKey } from "@wagmi/core/query";
 import { useQuery } from "wagmi/query";
-import { K as useGraphAuthKitInnerContext, y as isSupportedChainId, o as L2Chain, n as L1ChainTestnet, p as L2ChainTestnet, L as L1Chain } from "./GraphAuthKitInner.context-DFDaC5w3.js";
-import { a as useGraphAuthKitAccount } from "./hooks-DeU86P4k.js";
+import { K as useGraphAuthKitInnerContext, y as isSupportedChainId, o as L2Chain, n as L1ChainTestnet, p as L2ChainTestnet, L as L1Chain } from "./GraphAuthKitInner.context-DLfbf-o4.js";
+import { b as useGraphAuthKitAccount } from "./hooks-N_8StIGc.js";
 import { useChainId } from "wagmi";
 function useGraphAuthKitAvatar(args = {}) {
   const innerCtx = useGraphAuthKitInnerContext();

package/dist/{useWaitForSafeTransaction-DqUJ6JOu.js → useWaitForSafeTransaction-CxGjZhJy.js}

@@ -1,7 +1,7 @@
 import { useQuery } from "@tanstack/react-query";
 import { useConfig } from "wagmi";
-import { u as useMultisigInfo } from "./hooks-DeU86P4k.js";
-import { c as createApiKit } from "./GraphAuthKitInner.context-DFDaC5w3.js";
+import { u as useMultisigInfo } from "./hooks-N_8StIGc.js";
+import { c as createApiKit } from "./GraphAuthKitInner.context-DLfbf-o4.js";
 async function getSafeTransaction(safeTxHash, network, safeApiKey) {
   const apiKit = await createApiKit(network, safeApiKey);
   const txDetails = await apiKit.getTransaction(safeTxHash);

package/dist/{utils-CHmOZz26.js → utils-Cjhggvka.js}

@@ -3,13 +3,14 @@ import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { useConfig, WagmiProvider, useDisconnect, createConfig, createStorage, cookieStorage, cookieToInitialState } from "wagmi";
 import { injected, walletConnect, coinbaseWallet, mock } from "wagmi/connectors";
-import { K as useGraphAuthKitInnerContext, w as GraphAuthKitConnector, o as L2Chain, a as SafeSupportedNetworkNames, j as buildPublicClient, L as L1Chain, n as L1ChainTestnet, d as isValidSafe, S as SafeSupportedNetworks, P as GraphAuthKitInnerContextProvider, p as L2ChainTestnet, m as AUTH_STORAGE_KEY, x as chainIsSupportedChain, D as DefChain, l as buildClient, Q as GraphAuthKitInnerContext, T as defInnerState, R as RequiredInfuraKey, O as OptionalGatewayApiKey, q as SupportedClientChainId } from "./GraphAuthKitInner.context-DFDaC5w3.js";
+import { K as useGraphAuthKitInnerContext, w as GraphAuthKitConnector, o as L2Chain, a as SafeSupportedNetworkNames, j as buildPublicClient, L as L1Chain, n as L1ChainTestnet, d as isValidSafe, S as SafeSupportedNetworks, P as GraphAuthKitInnerContextProvider, p as L2ChainTestnet, m as AUTH_STORAGE_KEY, x as chainIsSupportedChain, D as DefChain, l as buildClient, Q as GraphAuthKitInnerContext, T as defInnerState, R as RequiredInfuraKey, O as OptionalGatewayApiKey, q as SupportedClientChainId } from "./GraphAuthKitInner.context-DLfbf-o4.js";
 import { useState, useReducer, useId, useEffect, createContext, useContext } from "react";
 import { Icon, ExperimentalModal, ExperimentalButton, Alert, Link, ExperimentalLoadingIndicator, ExperimentalSelect, ExperimentalInput, Divider, List } from "@graphprotocol/gds";
 import { addrShortener } from "@graphprotocol/common";
-import { isAddress } from "viem";
+import { getAddress, isAddress } from "viem";
 import { NetworkIcon } from "@graphprotocol/go";
 import { z } from "zod";
+import "@safe-global/api-kit";
 import { buildEnsResolver } from "@graphprotocol/ens";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 function usePrimaryConnectOptions() {
@@ -64,11 +65,11 @@ function useMultisigConnectOptions() {
         installed: curr.type === injected.type,
         Image: correctConnectOptionIcon(curr),
         async onConnect() {
-          var _a, _b;
+          var _a;
           void ctx._connectMultisig({
             connector: curr,
-            address: ((_a = ctx._enteredMultisigInfo) == null ? void 0 : _a.address) || "0x",
-            network: ((_b = ctx._enteredMultisigInfo) == null ? void 0 : _b.network) || L2Chain.id
+            address: getAddress(ctx._enteredMultisigInfo.address),
+            network: ((_a = ctx._enteredMultisigInfo) == null ? void 0 : _a.network) || L2Chain.id
           });
         }
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graphprotocol/graph-auth-kit",
   "private": false,
-  "version": "7.9.0",
+  "version": "7.10.0",
   "description": "Wallet authentication connect kit in The Graph suite of applications",
   "author": "Edge & Node",
   "license": "UNLICENSED",
@@ -38,9 +38,9 @@
   "dependencies": {
     "@ensdomains/ensjs": "^4.0.2",
     "@ethersproject/abstract-signer": "^5.8.0",
-    "@safe-global/api-kit": "^4.0.0",
-    "@safe-global/protocol-kit": "^6.1.1",
-    "@safe-global/types-kit": "^3.0.0",
+    "@safe-global/api-kit": "^5.0.3",
+    "@safe-global/protocol-kit": "^8.0.7",
+    "@safe-global/types-kit": "^4.0.1",
     "@wagmi/core": "^2.21.1",
     "tailwindcss": "^3.4.17",
     "zod": "^4.1.11"
@@ -54,10 +54,10 @@
     "theme-ui": ">=0.16",
     "viem": "^2.37",
     "wagmi": "^2.17",
+    "@graphprotocol/common": "^7.0.4",
     "@graphprotocol/ens": "^2.3.1",
-    "@graphprotocol/go": "^10.5.4",
     "@graphprotocol/gds": "^6.9.3",
-    "@graphprotocol/common": "^7.0.4"
+    "@graphprotocol/go": "^10.5.4"
   },
   "devDependencies": {
     "@emotion/react": "^11.14",
@@ -74,12 +74,12 @@
     "ts-node": "^10.9.2",
     "viem": "^2.37.8",
     "wagmi": "^2.17.2",
+    "@graphprotocol/common": "^7.0.4",
     "@graphprotocol/ens": "^2.3.1",
-    "@graphprotocol/go": "^10.5.4",
     "@graphprotocol/gds": "^6.9.3",
-    "@graphprotocol/common": "^7.0.4",
-    "@graphprotocol/test-utils": "^2.1.0",
-    "@graphprotocol/jsx": "^1.1.0"
+    "@graphprotocol/go": "^10.5.4",
+    "@graphprotocol/jsx": "^1.1.0",
+    "@graphprotocol/test-utils": "^2.1.0"
   },
   "scripts": {
     "build": "vite build",