@velora-dex/widget 0.1.0-rc.2 → 0.1.0

package/dist/hooks/batch/useCanBatchTxs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanBatchTxs.js","sources":["../../../src/hooks/batch/useCanBatchTxs.ts"],"sourcesContent":["import { type CapabilitiesSchema } from \"viem\";\nimport { useAccount, useCapabilities } from \"wagmi\";\nimport { useMemo } from \"react\";\nimport { useLogger } from \"@/core/logger\";\n\ntype AtomicCapabilities = Required<\n  Pick<CapabilitiesSchema[\"getCapabilities\"][\"ReturnType\"], \"atomic\">\n>;\n\ntype AtomicStatus = AtomicCapabilities[\"atomic\"][\"status\"];\n\ntype CanBatchTxsResult = {\n  byChain?: Record<number, AtomicStatus>;\n  forCurrentChain?: boolean;\n  currentChainStatus?: AtomicStatus;\n  isLoading: boolean;\n};\n\nexport function useCanBatchTxs(): CanBatchTxsResult {\n  const { address: account, chainId } = useAccount();\n\n  const { data, isLoading } = useCapabilities({\n    account,\n  });\n  const logger = useLogger(\"BATCH::useCanBatchTxs::wagmi\");\n\n  logger.once.log(\"capabilities\", data);\n\n  const byChain = useMemo<CanBatchTxsResult[\"byChain\"]>(() => {\n    if (!data) return;\n    return Object.fromEntries(\n      Object.entries(data).map(\n        ([chainId, capabilities]) =>\n          [\n            chainId,\n            // Safe returns atomicBatch.supported instead of atomic.status\n            (capabilities.atomicBatch?.supported && \"supported\") ||\n              capabilities.atomic?.status ||\n              \"unsupported\", // nothing returned --> consider unsupported\n          ] as const\n      )\n    );\n  }, [data]);\n\n  const currentChainStatus = chainId ? byChain?.[chainId] : undefined;\n\n  return {\n    byChain,\n    forCurrentChain:\n      // ready means the user will be asked to upgrade to delegated EOA\n      currentChainStatus === \"supported\" || currentChainStatus === \"ready\",\n    currentChainStatus,\n    isLoading,\n  };\n}\n"],"names":["useCanBatchTxs","$","_c","address","account","chainId","useAccount","t0","data","isLoading","useCapabilities","logger","useLogger","once","log","t1","bb0","undefined","t2","Object","fromEntries","entries","map","_temp","byChain","currentChainStatus","t3","forCurrentChain","chainId_0","capabilities","atomicBatch","supported","atomic","status"],"mappings":"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"}

package/dist/hooks/batch/useSendBatchTx.d.ts

@@ -0,0 +1,25 @@
+import { Config, UseSendCallsReturnType } from 'wagmi';
+import { SendCallsData, SendCallsVariables } from 'wagmi/query';
+import { SendCallsErrorType, SendTransactionParameters } from '@wagmi/core';
+import { MutationFilters } from '@tanstack/react-query';
+import { Call } from 'viem';
+import { SupportedChainId } from '../../lib/web3/wagmi/types';
+type SendCallsVars = SendCallsVariables<Config, SupportedChainId>;
+export type UseSendBatchTxInput = {
+    onMutate?: (vars: SendCallsVars) => void;
+    onSuccess?: (data: SendCallsData, variables: SendCallsVars) => void;
+    onError?: (error: Error, variables: SendCallsVars) => void;
+    onSettled?: (data: SendCallsData | undefined, error: SendCallsErrorType | null, variables: SendCallsVars) => void;
+};
+export type UseSendBatchTxResult = Pick<UseSendCallsReturnType<Config, unknown>, "isPending" | "error" | "data" | "isSuccess" | "isError" | "reset"> & {
+    sendCalls: SendCalls;
+};
+type SendCalls = (input: Omit<SendCallsVars, "calls"> & {
+    calls?: Call[];
+    txsParams?: SendTransactionParameters<Config, SupportedChainId>[];
+}, options?: Omit<UseSendBatchTxInput, "onMutate">) => Promise<SendCallsData>;
+export declare function useSendBatchTx(options?: UseSendBatchTxInput): UseSendBatchTxResult;
+type IsConfirmingBatchTxInput = Omit<MutationFilters<SendCallsData, SendCallsErrorType, SendCallsVariables<Config, number>>, "mutationKey">;
+export declare function useIsConfirmingBatchTx(options: IsConfirmingBatchTxInput): boolean;
+export {};
+//# sourceMappingURL=useSendBatchTx.d.ts.map

package/dist/hooks/batch/useSendBatchTx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSendBatchTx.d.ts","sourceRoot":"","sources":["../../../src/hooks/batch/useSendBatchTx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,KAAK,sBAAsB,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,uBAAuB,CAAC;AAG5E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,KAAK,aAAa,GAAG,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAElE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IACzC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,KAAK,IAAI,CAAC;IACpE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,KAAK,IAAI,CAAC;IAC3D,SAAS,CAAC,EAAE,CACV,IAAI,EAAE,aAAa,GAAG,SAAS,EAC/B,KAAK,EAAE,kBAAkB,GAAG,IAAI,EAChC,SAAS,EAAE,aAAa,KACrB,IAAI,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,sBAAsB,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CACnE,GAAG;IACF,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,KAAK,SAAS,GAAG,CACf,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG;IACpC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAEf,SAAS,CAAC,EAAE,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAAE,CAAC;CACnE,EACD,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,KAC5C,OAAO,CAAC,aAAa,CAAC,CAAC;AAE5B,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,oBAAoB,CAgCtB;AAED,KAAK,wBAAwB,GAAG,IAAI,CAClC,eAAe,CACb,aAAa,EACb,kBAAkB,EAClB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CACnC,EACD,aAAa,CACd,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAST"}

package/dist/hooks/batch/useSendBatchTx.js

@@ -0,0 +1,90 @@
+import { d as distExports } from '../../_virtual/index.js';
+import { useSendCalls } from 'wagmi';
+import 'wagmi/query';
+import '@wagmi/core';
+import '@tanstack/react-query';
+import 'react';
+import { assert } from 'ts-essentials';
+import { isTruthy } from '../../lib/utils/index.js';
+
+function useSendBatchTx(options) {
+  const $ = distExports.c(12);
+  let t0;
+  if ($[0] !== options) {
+    t0 = {
+      mutation: options
+    };
+    $[0] = options;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    data,
+    isPending,
+    isSuccess,
+    isError,
+    reset,
+    error,
+    sendCallsAsync
+  } = useSendCalls(t0);
+  let t1;
+  if ($[2] !== sendCallsAsync) {
+    t1 = (t22, options_0) => {
+      const {
+        txsParams,
+        ...input
+      } = t22;
+      const calls = input.calls || txsParams?.map(txParamsToCalls).filter(isTruthy);
+      assert(calls && calls.length > 0, "calls must be provided");
+      const chainId = input.chainId || txsParams?.[0]?.chainId;
+      return sendCallsAsync({
+        experimental_fallback: true,
+        ...input,
+        chainId,
+        calls
+      }, options_0);
+    };
+    $[2] = sendCallsAsync;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const sendCalls = t1;
+  let t2;
+  if ($[4] !== data || $[5] !== error || $[6] !== isError || $[7] !== isPending || $[8] !== isSuccess || $[9] !== reset || $[10] !== sendCalls) {
+    t2 = {
+      data,
+      isPending,
+      isSuccess,
+      isError,
+      reset,
+      error,
+      sendCalls
+    };
+    $[4] = data;
+    $[5] = error;
+    $[6] = isError;
+    $[7] = isPending;
+    $[8] = isSuccess;
+    $[9] = reset;
+    $[10] = sendCalls;
+    $[11] = t2;
+  } else {
+    t2 = $[11];
+  }
+  return t2;
+}
+function txParamsToCalls(txParams) {
+  if (!txParams.to) {
+    return null;
+  }
+  return {
+    to: txParams.to,
+    data: txParams.data,
+    value: txParams.value
+  };
+}
+
+export { useSendBatchTx };
+//# sourceMappingURL=useSendBatchTx.js.map

package/dist/hooks/batch/useSendBatchTx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSendBatchTx.js","sources":["../../../src/hooks/batch/useSendBatchTx.ts"],"sourcesContent":["import { type Config, useSendCalls, type UseSendCallsReturnType } from \"wagmi\";\nimport { type SendCallsData, type SendCallsVariables } from \"wagmi/query\";\nimport {\n  type SendCallsErrorType,\n  type SendTransactionParameters,\n} from \"@wagmi/core\";\nimport { type MutationFilters, useIsMutating } from \"@tanstack/react-query\";\nimport { useCallback } from \"react\";\nimport { assert } from \"ts-essentials\";\nimport type { Call } from \"viem\";\nimport type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport type { TxParams } from \"./useBatchWithApproveTxs\";\nimport { isTruthy } from \"@/lib/utils\";\n\ntype SendCallsVars = SendCallsVariables<Config, SupportedChainId>;\n\nexport type UseSendBatchTxInput = {\n  onMutate?: (vars: SendCallsVars) => void;\n  onSuccess?: (data: SendCallsData, variables: SendCallsVars) => void;\n  onError?: (error: Error, variables: SendCallsVars) => void;\n  onSettled?: (\n    data: SendCallsData | undefined,\n    error: SendCallsErrorType | null,\n    variables: SendCallsVars\n  ) => void;\n};\n\nexport type UseSendBatchTxResult = Pick<\n  UseSendCallsReturnType<Config, unknown>,\n  \"isPending\" | \"error\" | \"data\" | \"isSuccess\" | \"isError\" | \"reset\"\n> & {\n  sendCalls: SendCalls;\n};\n\ntype SendCalls = (\n  input: Omit<SendCallsVars, \"calls\"> & {\n    calls?: Call[]; // can pass expected Calls directly\n    // or txsParams to be converted to Calls\n    txsParams?: SendTransactionParameters<Config, SupportedChainId>[];\n  },\n  options?: Omit<UseSendBatchTxInput, \"onMutate\">\n) => Promise<SendCallsData>;\n\nexport function useSendBatchTx(\n  options?: UseSendBatchTxInput\n): UseSendBatchTxResult {\n  const { data, isPending, isSuccess, isError, reset, error, sendCallsAsync } =\n    useSendCalls({\n      mutation: options,\n      // mutationKey = ['sendCalls'] inside\n    });\n\n  const sendCalls = useCallback<SendCalls>(\n    ({ txsParams, ...input }, options) => {\n      const calls: Call[] | undefined =\n        input.calls || txsParams?.map(txParamsToCalls).filter(isTruthy);\n\n      assert(calls && calls.length > 0, \"calls must be provided\");\n\n      const chainId = input.chainId || txsParams?.[0]?.chainId;\n\n      return sendCallsAsync(\n        {\n          // forceAtomic doesn't work together with experimental_fallback,\n          // and we care about Approve + Main tx to be performed sequentially more than atomically\n          experimental_fallback: true,\n          ...input,\n          chainId: chainId as SupportedChainId | undefined,\n          calls,\n        },\n        options\n      );\n    },\n    [sendCallsAsync]\n  );\n\n  return { data, isPending, isSuccess, isError, reset, error, sendCalls };\n}\n\ntype IsConfirmingBatchTxInput = Omit<\n  MutationFilters<\n    SendCallsData,\n    SendCallsErrorType,\n    SendCallsVariables<Config, number>\n  >,\n  \"mutationKey\"\n>;\n\nexport function useIsConfirmingBatchTx(\n  options: IsConfirmingBatchTxInput\n): boolean {\n  return (\n    useIsMutating({\n      mutationKey: [\"sendCalls\"],\n      exact: options.exact,\n      status: options.status,\n      predicate: options.predicate as MutationFilters[\"predicate\"],\n    }) > 0\n  );\n}\n\nfunction txParamsToCalls(\n  txParams: Pick<TxParams, \"to\" | \"data\" | \"value\">\n): Call | null {\n  if (!txParams.to) {\n    return null;\n  }\n\n  return {\n    to: txParams.to,\n    data: txParams.data,\n    value: txParams.value,\n  };\n}\n"],"names":["useSendBatchTx","options","$","_c","t0","mutation","data","isPending","isSuccess","isError","reset","error","sendCallsAsync","useSendCalls","t1","t2","options_0","txsParams","input","calls","map","txParamsToCalls","filter","isTruthy","assert","length","chainId","experimental_fallback","sendCalls","txParams","to","value"],"mappings":"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"}

package/dist/hooks/batch/useShouldBatchTxs.d.ts

@@ -0,0 +1,18 @@
+import { TokenApprovalProps } from './useBatchWithApproveTxs';
+type TokenApprovalPropsWithLoading = TokenApprovalProps & {
+    isLoadingPrerequisites: boolean;
+    needsApproval: boolean;
+};
+type ShouldBatchTxsInput = {
+    approveProps1?: TokenApprovalPropsWithLoading;
+    approveProps2?: TokenApprovalPropsWithLoading;
+};
+export type ShouldBatchTxsResult = {
+    canBatchTxs?: boolean;
+    shouldBatchTxs: boolean;
+    isLoading: boolean;
+    approveProps: TokenApprovalProps[];
+};
+export declare function useShouldBatchTxs({ approveProps1, approveProps2, }: ShouldBatchTxsInput): ShouldBatchTxsResult;
+export {};
+//# sourceMappingURL=useShouldBatchTxs.d.ts.map

package/dist/hooks/batch/useShouldBatchTxs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useShouldBatchTxs.d.ts","sourceRoot":"","sources":["../../../src/hooks/batch/useShouldBatchTxs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,KAAK,6BAA6B,GAAG,kBAAkB,GAAG;IACxD,sBAAsB,EAAE,OAAO,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,aAAa,CAAC,EAAE,6BAA6B,CAAC;IAC9C,aAAa,CAAC,EAAE,6BAA6B,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,kBAAkB,EAAE,CAAC;CACpC,CAAC;AAOF,wBAAgB,iBAAiB,CAAC,EAEhC,aAAqC,EACrC,aAAqC,GACtC,EAAE,mBAAmB,GAAG,oBAAoB,CA6B5C"}

package/dist/hooks/connectors/useIsConnectedSafe.d.ts

@@ -0,0 +1,3 @@
+export declare function useConnectedSafe(): boolean;
+export declare function connectedSafe(): Promise<boolean>;
+//# sourceMappingURL=useIsConnectedSafe.d.ts.map

package/dist/hooks/connectors/useIsConnectedSafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsConnectedSafe.d.ts","sourceRoot":"","sources":["../../../src/hooks/connectors/useIsConnectedSafe.ts"],"names":[],"mappings":"AAgBA,wBAAgB,gBAAgB,IAAI,OAAO,CAK1C;AAGD,wBAAsB,aAAa,qBAalC"}

package/dist/hooks/connectors/useIsConnectedSafe.js

@@ -0,0 +1,26 @@
+import { wagmiConfig } from '../../lib/web3/wagmi/config.js';
+import { isSafeConnector, useIsSafeConnector } from './useIsGnosisSafeConnector.js';
+import { isSafeConnectorThroughWalletConnect, useIsSafeThroughWalletConnect } from './useIsSafeThroughWalletConnect.js';
+import { getAccount } from '@wagmi/core';
+import { getWalletMetadata, walletMetadataQueryKey } from '../../components/web3/ConnectWallets/walletIcons.js';
+import { queryClient } from '../../lib/queryClient.js';
+
+function useConnectedSafe() {
+  const isSafeConnector2 = useIsSafeConnector();
+  const isSafeThroughWalletConnect = useIsSafeThroughWalletConnect();
+  return isSafeConnector2 || isSafeThroughWalletConnect;
+}
+async function connectedSafe() {
+  const connector = getAccount(wagmiConfig).connector;
+  if (!connector) return false;
+  if (isSafeConnector(connector)) return true;
+  const walletMeta = await queryClient.ensureQueryData({
+    queryKey: walletMetadataQueryKey(connector.id),
+    queryFn: () => getWalletMetadata(connector),
+    gcTime: Infinity
+  });
+  return isSafeConnectorThroughWalletConnect(walletMeta);
+}
+
+export { connectedSafe, useConnectedSafe };
+//# sourceMappingURL=useIsConnectedSafe.js.map

package/dist/hooks/connectors/useIsConnectedSafe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsConnectedSafe.js","sources":["../../../src/hooks/connectors/useIsConnectedSafe.ts"],"sourcesContent":["import { wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport {\n  isSafeConnector,\n  useIsSafeConnector,\n} from \"./useIsGnosisSafeConnector\";\nimport {\n  isSafeConnectorThroughWalletConnect,\n  useIsSafeThroughWalletConnect,\n} from \"./useIsSafeThroughWalletConnect\";\nimport { getAccount } from \"@wagmi/core\";\nimport {\n  getWalletMetadata,\n  walletMetadataQueryKey,\n} from \"@/components/web3/ConnectWallets/walletIcons\";\nimport { queryClient } from \"@/lib/queryClient\";\n\nexport function useConnectedSafe(): boolean {\n  const isSafeConnector = useIsSafeConnector();\n  const isSafeThroughWalletConnect = useIsSafeThroughWalletConnect();\n\n  return isSafeConnector || isSafeThroughWalletConnect;\n}\n\n// for use outside of react\nexport async function connectedSafe() {\n  const connector = getAccount(wagmiConfig).connector;\n  if (!connector) return false;\n\n  if (isSafeConnector(connector)) return true;\n\n  const walletMeta = await queryClient.ensureQueryData({\n    queryKey: walletMetadataQueryKey(connector.id),\n    queryFn: () => getWalletMetadata(connector),\n    gcTime: Infinity,\n  });\n\n  return isSafeConnectorThroughWalletConnect(walletMeta);\n}\n"],"names":["useConnectedSafe","isSafeConnector","useIsSafeConnector","isSafeThroughWalletConnect","useIsSafeThroughWalletConnect","connectedSafe","connector","getAccount","wagmiConfig","walletMeta","queryClient","ensureQueryData","queryKey","walletMetadataQueryKey","id","queryFn","getWalletMetadata","gcTime","Infinity","isSafeConnectorThroughWalletConnect"],"mappings":";;;;;;;AAgBO,SAAAA,gBAAAA,GAAA;AACL,EAAA,MAAAC,mBAAwBC,kBAAAA,EAAmB;AAC3C,EAAA,MAAAC,6BAAmCC,6BAAAA,EAA8B;AAAE,EAAA,OAE5DH,gBAAAA,IAAmBE,0BAAAA;AAA0B;AAItD,eAAsBE,aAAAA,GAAgB;AACpC,EAAA,MAAMC,SAAAA,GAAYC,UAAAA,CAAWC,WAAW,CAAA,CAAEF,SAAAA;AAC1C,EAAA,IAAI,CAACA,WAAW,OAAO,KAAA;AAEvB,EAAA,IAAIL,eAAAA,CAAgBK,SAAS,CAAA,EAAG,OAAO,IAAA;AAEvC,EAAA,MAAMG,UAAAA,GAAa,MAAMC,WAAAA,CAAYC,eAAAA,CAAgB;AAAA,IACnDC,QAAAA,EAAUC,sBAAAA,CAAuBP,SAAAA,CAAUQ,EAAE,CAAA;AAAA,IAC7CC,OAAAA,EAASA,MAAMC,iBAAAA,CAAkBV,SAAS,CAAA;AAAA,IAC1CW,MAAAA,EAAQC;AAAAA,GACT,CAAA;AAED,EAAA,OAAOC,oCAAoCV,UAAU,CAAA;AACvD;;;;"}

package/dist/hooks/connectors/useIsGnosisSafeConnector.d.ts

@@ -0,0 +1,4 @@
+import { Connector } from 'wagmi';
+export declare function useIsSafeConnector(): boolean;
+export declare function isSafeConnector({ type }: Pick<Connector, "type">): boolean;
+//# sourceMappingURL=useIsGnosisSafeConnector.d.ts.map

package/dist/hooks/connectors/useIsGnosisSafeConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsGnosisSafeConnector.d.ts","sourceRoot":"","sources":["../../../src/hooks/connectors/useIsGnosisSafeConnector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEnD,wBAAgB,kBAAkB,IAAI,OAAO,CAI5C;AAED,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,OAAO,CAE1E"}

package/dist/hooks/connectors/useIsGnosisSafeConnector.js

@@ -0,0 +1,29 @@
+import { d as distExports } from '../../_virtual/index.js';
+import { useAccount } from 'wagmi';
+
+function useIsSafeConnector() {
+  const $ = distExports.c(2);
+  const {
+    connector
+  } = useAccount();
+  if (!connector) {
+    return false;
+  }
+  let t0;
+  if ($[0] !== connector) {
+    t0 = isSafeConnector(connector);
+    $[0] = connector;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+function isSafeConnector({
+  type
+}) {
+  return type === "safe";
+}
+
+export { isSafeConnector, useIsSafeConnector };
+//# sourceMappingURL=useIsGnosisSafeConnector.js.map

package/dist/hooks/connectors/useIsGnosisSafeConnector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsGnosisSafeConnector.js","sources":["../../../src/hooks/connectors/useIsGnosisSafeConnector.ts"],"sourcesContent":["import { useAccount, type Connector } from \"wagmi\";\n\nexport function useIsSafeConnector(): boolean {\n  const { connector } = useAccount();\n  if (!connector) return false;\n  return isSafeConnector(connector);\n}\n\nexport function isSafeConnector({ type }: Pick<Connector, \"type\">): boolean {\n  return type === \"safe\";\n}\n"],"names":["useIsSafeConnector","$","_c","connector","useAccount","t0","isSafeConnector","type"],"mappings":";;;AAEO,SAAAA,kBAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAA;AAAA,IAAAC;AAAAA,MAAsBC,UAAAA,EAAW;AAAE,EAAA,IAAA,CAC9BD,SAAAA,EAAS;AAAA,IAAA,OAAA,KAAA;AAAA,EAAA;AAAA,EAAA,IAAAE,EAAAA;AAAA,EAAA,IAAAJ,CAAAA,QAAAE,SAAAA,EAAA;AACPE,IAAAA,EAAAA,GAAAC,gBAAgBH,SAAS,CAAA;AAACF,IAAAA,CAAAA,MAAAE,SAAAA;AAAAF,IAAAA,CAAAA,MAAAI,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAJ,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAA1BI,EAAAA;AAA0B;AAG5B,SAASC,eAAAA,CAAgB;AAAA,EAAEC;AAA8B,CAAA,EAAY;AAC1E,EAAA,OAAOA,IAAAA,KAAS,MAAA;AAClB;;;;"}

package/dist/hooks/connectors/useIsSafeThroughWalletConnect.d.ts

@@ -0,0 +1,4 @@
+import { WalletMeta } from '../../components/web3/ConnectWallets/walletIcons';
+export declare function useIsSafeThroughWalletConnect(): boolean;
+export declare function isSafeConnectorThroughWalletConnect({ connectorType, name, }: Partial<Pick<WalletMeta, "connectorType" | "name">>): boolean;
+//# sourceMappingURL=useIsSafeThroughWalletConnect.d.ts.map

package/dist/hooks/connectors/useIsSafeThroughWalletConnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsSafeThroughWalletConnect.d.ts","sourceRoot":"","sources":["../../../src/hooks/connectors/useIsSafeThroughWalletConnect.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAChB,MAAM,8CAA8C,CAAC;AAWtD,wBAAgB,6BAA6B,YAI5C;AAED,wBAAgB,mCAAmC,CAAC,EAClD,aAAa,EACb,IAAI,GACL,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,CAAC,CAAC,GAAG,OAAO,CAO/D"}

package/dist/hooks/connectors/useIsSafeThroughWalletConnect.js

@@ -0,0 +1,44 @@
+import { d as distExports } from '../../_virtual/index.js';
+import { useWalletMetadata } from '../../components/web3/ConnectWallets/walletIcons.js';
+import { walletConnect } from 'wagmi/connectors';
+
+const GnosisSafeWConnectRegex = [
+  // matches `WalletConnect Safe App` (app in web Safe) and `Safe` (iOS Safe)
+  /^(?:WalletConnect)?\s*Safe\s*(?:App)?$/i,
+  // if there's word Safe surrounded by non-word characters or by nothing -> most likely it's Gnosis Safe
+  /([^a-zA-Z]|^)Safe([^a-zA-Z]|$)/i
+  // matches'Safe{Wallet}'
+];
+function useIsSafeThroughWalletConnect() {
+  const $ = distExports.c(3);
+  const {
+    connectorType,
+    name
+  } = useWalletMetadata() ?? {};
+  let t0;
+  if ($[0] !== connectorType || $[1] !== name) {
+    t0 = isSafeConnectorThroughWalletConnect({
+      connectorType,
+      name
+    });
+    $[0] = connectorType;
+    $[1] = name;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function isSafeConnectorThroughWalletConnect({
+  connectorType,
+  name
+}) {
+  if (connectorType !== walletConnect.type || !name) {
+    return false;
+  }
+  const isSafe = GnosisSafeWConnectRegex.some((rule) => rule.test(name));
+  return isSafe;
+}
+
+export { isSafeConnectorThroughWalletConnect, useIsSafeThroughWalletConnect };
+//# sourceMappingURL=useIsSafeThroughWalletConnect.js.map

package/dist/hooks/connectors/useIsSafeThroughWalletConnect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsSafeThroughWalletConnect.js","sources":["../../../src/hooks/connectors/useIsSafeThroughWalletConnect.ts"],"sourcesContent":["import {\n  useWalletMetadata,\n  type WalletMeta,\n} from \"@/components/web3/ConnectWallets/walletIcons\";\nimport { walletConnect } from \"wagmi/connectors\";\n\nconst GnosisSafeWConnectRegex = [\n  // matches `WalletConnect Safe App` (app in web Safe) and `Safe` (iOS Safe)\n  /^(?:WalletConnect)?\\s*Safe\\s*(?:App)?$/i,\n\n  // if there's word Safe surrounded by non-word characters or by nothing -> most likely it's Gnosis Safe\n  /([^a-zA-Z]|^)Safe([^a-zA-Z]|$)/i, // matches'Safe{Wallet}'\n];\n\nexport function useIsSafeThroughWalletConnect() {\n  const { connectorType, name } = useWalletMetadata() ?? {};\n\n  return isSafeConnectorThroughWalletConnect({ connectorType, name });\n}\n\nexport function isSafeConnectorThroughWalletConnect({\n  connectorType,\n  name,\n}: Partial<Pick<WalletMeta, \"connectorType\" | \"name\">>): boolean {\n  if (connectorType !== walletConnect.type || !name) {\n    return false;\n  }\n\n  const isSafe = GnosisSafeWConnectRegex.some((rule) => rule.test(name));\n  return isSafe;\n}\n"],"names":["GnosisSafeWConnectRegex","useIsSafeThroughWalletConnect","$","_c","connectorType","name","useWalletMetadata","t0","isSafeConnectorThroughWalletConnect","walletConnect","type","isSafe","some","rule","test"],"mappings":";;;;AAMA,MAAMA,uBAAAA,GAA0B;AAAA;AAAA,EAE9B,yCAAA;AAAA;AAAA,EAGA;AAAA;AAAmC,CAAA;AAG9B,SAAAC,6BAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAA;AAAA,IAAAC,aAAAA;AAAAA,IAAAC;AAAAA,GAAA,GAAgCC,iBAAAA,EAAkB,IAAC,EAAA;AAAO,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAL,EAAA,CAAA,CAAA,KAAAE,iBAAAF,CAAAA,QAAAG,IAAAA,EAAA;AAEnDE,IAAAA,EAAAA,GAAAC,mCAAAA,CAAA;AAAA,MAAAJ,aAAAA;AAAAA,MAAAC;AAAAA,KAA2D,CAAA;AAACH,IAAAA,CAAAA,MAAAE,aAAAA;AAAAF,IAAAA,CAAAA,MAAAG,IAAAA;AAAAH,IAAAA,CAAAA,MAAAK,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAL,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAA5DK,EAAAA;AAA4D;AAG9D,SAASC,mCAAAA,CAAoC;AAAA,EAClDJ,aAAAA;AAAAA,EACAC;AACmD,CAAA,EAAY;AAC/D,EAAA,IAAID,aAAAA,KAAkBK,aAAAA,CAAcC,IAAAA,IAAQ,CAACL,IAAAA,EAAM;AACjD,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAMM,SAASX,uBAAAA,CAAwBY,IAAAA,CAAMC,UAASA,IAAAA,CAAKC,IAAAA,CAAKT,IAAI,CAAC,CAAA;AACrE,EAAA,OAAOM,MAAAA;AACT;;;;"}

package/dist/hooks/gas/utils.js

@@ -1,4 +1,4 @@
-import { formatGwei, parseGwei } from 'viem';
+import { parseGwei, formatGwei } from 'viem';
 
 function isLegacyPriceResponse(legacy, response) {
   return legacy && typeof response.safeLow === "string";

package/dist/hooks/otc/mutations/useCancelLimitOrder.d.ts

@@ -0,0 +1,45 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { MinViemClient, LimitOrderFromApi, TxSendOverrides } from '@velora-dex/sdk';
+import { Address, Hash, TransactionReceipt } from 'viem';
+import { SupportedChainId } from '../../../lib/web3/wagmi/types';
+type CancelLimitOrderReturn = `0x${string}`;
+type CancelLimitOrderAndWaitReturn = TransactionReceipt;
+type CancelLimitOrderInput = {
+    orderHash: string;
+    overrides?: TxSendOverrides;
+    signal?: AbortSignal;
+};
+type CancelLimitOrderAndWaitInput = CancelLimitOrderInput & {
+    onTxSent?: (params: {
+        chainId: SupportedChainId;
+        transactionHash: Hash;
+        receiptPromise: Promise<TransactionReceipt>;
+    }) => void;
+};
+type CancelLimitOrderMutationOptions = Omit<UseMutationOptions<CancelLimitOrderReturn, Error, CancelLimitOrderInput>, "mutationFn">;
+type CancelLimitOrderAndWaitMutationOptions = Omit<UseMutationOptions<CancelLimitOrderAndWaitReturn, Error, CancelLimitOrderAndWaitInput>, "mutationFn">;
+type CancelLimitOrderMutInput = {
+    mutationOptions?: CancelLimitOrderMutationOptions;
+    chainId: SupportedChainId;
+    account?: Address;
+    client?: MinViemClient;
+};
+type CancelLimitOrderAndWaitMutInput = {
+    mutationOptions?: CancelLimitOrderAndWaitMutationOptions;
+    chainId: SupportedChainId;
+    account?: Address;
+    client?: MinViemClient;
+};
+export declare const CANCEL_LIMIT_ORDER_MUTATION_KEY = "cancelLimitOrder";
+export declare const CANCEL_LIMIT_ORDER_AND_WAIT_MUTATION_KEY = "cancelLimitOrderAndWait";
+export declare function useCancelLimitOrder({ mutationOptions, chainId, account, client, }: CancelLimitOrderMutInput): UseMutationResult<CancelLimitOrderReturn, Error, CancelLimitOrderInput>;
+export declare function useCancelOtcOrderAndWait({ mutationOptions, chainId, account, client, }: CancelLimitOrderAndWaitMutInput): UseMutationResult<CancelLimitOrderAndWaitReturn, Error, CancelLimitOrderAndWaitInput>;
+type MinVars = Pick<CancelLimitOrderInput, "orderHash">;
+type CancelOrderEventCallbacks = {
+    onMutate?: (variables: MinVars) => void;
+    onSuccess?: (data: CancelLimitOrderAndWaitReturn, variables: MinVars) => void;
+    onError?: (error: Error, variables: MinVars) => void;
+};
+export declare function useCancelOtcOrderEventCallbacks(order?: Pick<LimitOrderFromApi, "orderHash" | "type">): CancelOrderEventCallbacks;
+export {};
+//# sourceMappingURL=useCancelLimitOrder.d.ts.map

package/dist/hooks/otc/mutations/useCancelLimitOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCancelLimitOrder.d.ts","sourceRoot":"","sources":["../../../../src/hooks/otc/mutations/useCancelLimitOrder.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM/D,KAAK,sBAAsB,GAAG,KAAK,MAAM,EAAE,CAAC;AAC5C,KAAK,6BAA6B,GAAG,kBAAkB,CAAC;AAExD,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,KAAK,4BAA4B,GAAG,qBAAqB,GAAG;IAC1D,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE;QAClB,OAAO,EAAE,gBAAgB,CAAC;QAC1B,eAAe,EAAE,IAAI,CAAC;QACtB,cAAc,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;KAC7C,KAAK,IAAI,CAAC;CACZ,CAAC;AAEF,KAAK,+BAA+B,GAAG,IAAI,CACzC,kBAAkB,CAAC,sBAAsB,EAAE,KAAK,EAAE,qBAAqB,CAAC,EACxE,YAAY,CACb,CAAC;AACF,KAAK,sCAAsC,GAAG,IAAI,CAChD,kBAAkB,CAChB,6BAA6B,EAC7B,KAAK,EACL,4BAA4B,CAC7B,EACD,YAAY,CACb,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,eAAe,CAAC,EAAE,+BAA+B,CAAC;IAClD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF,KAAK,+BAA+B,GAAG;IACrC,eAAe,CAAC,EAAE,sCAAsC,CAAC;IACzD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,+BAA+B,qBAAqB,CAAC;AAClE,eAAO,MAAM,wCAAwC,4BAC1B,CAAC;AAE5B,wBAAgB,mBAAmB,CAAC,EAClC,eAAe,EACf,OAAO,EACP,OAAO,EACP,MAAM,GACP,EAAE,wBAAwB,GAAG,iBAAiB,CAC7C,sBAAsB,EACtB,KAAK,EACL,qBAAqB,CACtB,CAoBA;AAED,wBAAgB,wBAAwB,CAAC,EACvC,eAAe,EACf,OAAO,EACP,OAAO,EACP,MAAM,GACP,EAAE,+BAA+B,GAAG,iBAAiB,CACpD,6BAA6B,EAC7B,KAAK,EACL,4BAA4B,CAC7B,CA8CA;AAED,KAAK,OAAO,GAAG,IAAI,CAAC,qBAAqB,EAAE,WAAW,CAAC,CAAC;AAExD,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,6BAA6B,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CACtD,CAAC;AASF,wBAAgB,+BAA+B,CAC7C,KAAK,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,WAAW,GAAG,MAAM,CAAC,GACpD,yBAAyB,CAiD3B"}

package/dist/hooks/otc/mutations/useCancelLimitOrder.js

@@ -0,0 +1,258 @@
+import { d as distExports } from '../../../_virtual/index.js';
+import { useLimitOrdersSDK } from '../../useSDK.js';
+import { useMutation } from '@tanstack/react-query';
+import { assert } from 'ts-essentials';
+import { useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
+import { limitOrdersQueryKey } from '../queries/useLimitOrders.js';
+import { queryClient } from '../../../lib/queryClient.js';
+import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
+
+const CANCEL_LIMIT_ORDER_MUTATION_KEY = "cancelLimitOrder";
+const CANCEL_LIMIT_ORDER_AND_WAIT_MUTATION_KEY = "cancelLimitOrderAndWait";
+function useCancelLimitOrder(t0) {
+  const $ = distExports.c(10);
+  const {
+    mutationOptions,
+    chainId,
+    account,
+    client
+  } = t0;
+  let t1;
+  if ($[0] !== account || $[1] !== chainId || $[2] !== client) {
+    t1 = {
+      chainId,
+      account,
+      client
+    };
+    $[0] = account;
+    $[1] = chainId;
+    $[2] = client;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const {
+    sdk
+  } = useLimitOrdersSDK(t1);
+  let t2;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = [CANCEL_LIMIT_ORDER_MUTATION_KEY];
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== sdk) {
+    t3 = (t42) => {
+      const {
+        orderHash,
+        overrides,
+        signal
+      } = t42;
+      signal?.throwIfAborted();
+      assert("cancelLimitOrder" in sdk, "cancelLimitOrder is not available on this SDK");
+      return sdk.cancelLimitOrder(orderHash, overrides, {
+        signal
+      });
+    };
+    $[5] = sdk;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== mutationOptions || $[8] !== t3) {
+    t4 = {
+      mutationKey: t2,
+      mutationFn: t3,
+      ...mutationOptions
+    };
+    $[7] = mutationOptions;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return useMutation(t4);
+}
+function useCancelOtcOrderAndWait(t0) {
+  const $ = distExports.c(17);
+  const {
+    mutationOptions,
+    chainId,
+    account,
+    client
+  } = t0;
+  const ensureTxReceipt = useEnsureTxReceipt();
+  let t1;
+  if ($[0] !== account || $[1] !== chainId || $[2] !== client) {
+    t1 = {
+      chainId,
+      account,
+      client
+    };
+    $[0] = account;
+    $[1] = chainId;
+    $[2] = client;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const {
+    mutateAsync
+  } = useCancelLimitOrder(t1);
+  let t2;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = [CANCEL_LIMIT_ORDER_AND_WAIT_MUTATION_KEY];
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== chainId || $[6] !== ensureTxReceipt || $[7] !== mutateAsync) {
+    t3 = async (t42) => {
+      const {
+        orderHash,
+        overrides,
+        onTxSent,
+        signal
+      } = t42;
+      const transactionHash = await mutateAsync({
+        orderHash,
+        overrides,
+        signal
+      });
+      const receiptPromise = ensureTxReceipt({
+        chainId,
+        hash: transactionHash
+      });
+      onTxSent?.({
+        chainId,
+        transactionHash,
+        receiptPromise
+      });
+      return receiptPromise;
+    };
+    $[5] = chainId;
+    $[6] = ensureTxReceipt;
+    $[7] = mutateAsync;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  let t4;
+  if ($[9] !== account || $[10] !== chainId || $[11] !== mutationOptions) {
+    t4 = (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: limitOrdersQueryKey({
+          maker: account,
+          type: "P2P"
+        }, chainId),
+        exact: false
+      });
+      mutationOptions?.onSuccess?.(data, variables, context);
+    };
+    $[9] = account;
+    $[10] = chainId;
+    $[11] = mutationOptions;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  let t5;
+  if ($[13] !== mutationOptions || $[14] !== t3 || $[15] !== t4) {
+    t5 = {
+      mutationKey: t2,
+      mutationFn: t3,
+      ...mutationOptions,
+      onSuccess: t4
+    };
+    $[13] = mutationOptions;
+    $[14] = t3;
+    $[15] = t4;
+    $[16] = t5;
+  } else {
+    t5 = $[16];
+  }
+  return useMutation(t5);
+}
+function useCancelOtcOrderEventCallbacks(order) {
+  const $ = distExports.c(7);
+  const {
+    onCancelOrder
+  } = useWidgetEvents();
+  if (!order) {
+    let t02;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t02 = {};
+      $[0] = t02;
+    } else {
+      t02 = $[0];
+    }
+    return t02;
+  }
+  let t0;
+  if ($[1] !== order.orderHash || $[2] !== order.type) {
+    t0 = {
+      orderHash: order.orderHash,
+      orderType: "OTC",
+      orderSubType: order.type
+    };
+    $[1] = order.orderHash;
+    $[2] = order.type;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const params = t0;
+  let t1;
+  if ($[4] !== onCancelOrder || $[5] !== params) {
+    t1 = {
+      onMutate: (variables) => {
+        onCancelOrder?.({
+          event: {
+            name: "CancelOrder:request",
+            params: {
+              ...params,
+              orderHash: variables.orderHash
+            }
+          }
+        });
+      },
+      onSuccess: (data, variables_0) => {
+        onCancelOrder?.({
+          event: {
+            name: "CancelOrder:confirmed",
+            params: {
+              ...params,
+              orderHash: variables_0.orderHash,
+              txHash: data.transactionHash,
+              txReceipt: data
+            }
+          }
+        });
+      },
+      onError: (error, variables_1) => {
+        onCancelOrder?.({
+          event: {
+            name: "CancelOrder:failed",
+            params: {
+              ...params,
+              orderHash: variables_1.orderHash,
+              error
+            }
+          }
+        });
+      }
+    };
+    $[4] = onCancelOrder;
+    $[5] = params;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  return t1;
+}
+
+export { CANCEL_LIMIT_ORDER_AND_WAIT_MUTATION_KEY, CANCEL_LIMIT_ORDER_MUTATION_KEY, useCancelLimitOrder, useCancelOtcOrderAndWait, useCancelOtcOrderEventCallbacks };
+//# sourceMappingURL=useCancelLimitOrder.js.map