@velora-dex/widget 0.0.14 → 0.0.16

package/dist/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.d.ts

@@ -0,0 +1,76 @@
+import { QueryObserverResult, RefetchOptions } from '@tanstack/react-query';
+import { Address } from 'viem';
+/**
+ * Permit2 stores nonces using a nested bitmap structure:
+ *
+ * mapping(address => mapping(uint256 => uint256)) public nonceBitmap;
+ *
+ * - The outer key (`address`) is the permit signer (the `owner`)
+ * - The inner key (`uint256 word`) is the index of a 256-bit "page"
+ * - The value (`uint256`) is the bitmap for that page — each bit (0 to 255) represents a nonce
+ *     - If bit `i` is `0`, then nonce `word * 256 + i` is **unused**
+ *     - If bit `i` is `1`, then that nonce has **already been used**
+ *
+ * This is what enables Permit2 to support unordered nonces while saving gas.
+ */
+type NonceState = {
+    word: bigint;
+    bitmap: bigint;
+    nonce: bigint;
+};
+interface UsePermit2TransferFromNonceOptions {
+    owner?: Address;
+    chainId?: number;
+    initWord?: bigint;
+    enabled?: boolean;
+}
+export type UsePermit2TransferFromNonceResult = {
+    nonceToUse?: bigint | null;
+    nonceState?: NonceState | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<NonceState | null, Error>>;
+};
+/**
+ * React hook to find the next unused Permit2 nonce for `permitTransferFrom`.
+ *
+ * Permit2 stores nonces as a bitmap:
+ * - Each address has a mapping from uint256 => uint256
+ * - Each value is a 256-bit bitmap (called a "word")
+ * - If a bit is 1, the nonce (word * 256 + bit index) is used
+ * - If it's 0, it's free and can be used
+ */
+export declare function usePermit2TransferFromNonce({ owner, chainId, initWord, enabled, }: UsePermit2TransferFromNonceOptions): {
+    nonceState: NonceState | null | undefined;
+    nonceToUse: bigint | null | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<NonceState | null, Error>>;
+};
+type SetNonceInput = {
+    owner: Address;
+    chainId: number;
+    usedNonce: bigint;
+};
+type UseMarkNonceAsUsedResult = {
+    /**
+     * Mark a nonce as "used" in the local cache after submitting a transaction or order
+     * This prevents reuse of the same nonce while it's still pending on-chain.
+     */
+    markNonceAsUsed: (input: SetNonceInput) => void;
+};
+/**
+ * Hook to manually bump the locally cached Permit2 nonce to avoid reuse
+ *
+ * Permit2 allows unordered nonces, but while a tx is pending, it's safer to use
+ * a strictly increasing nonce to avoid accidental replays or reuse.
+ *
+ * clearing an unsued nonce is not necessary because nonces are unordered
+ */
+export declare function useMarkNonceAsUsed(): UseMarkNonceAsUsedResult;
+export {};
+//# sourceMappingURL=usePermit2TransferFromNonce.d.ts.map

package/dist/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePermit2TransferFromNonce.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,OAAO,EAAc,MAAM,MAAM,CAAC;AAOhD;;;;;;;;;;;;GAYG;AAGH,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAUF,UAAU,kCAAkC;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,iCAAiC,GAAG;IAE9C,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,CACP,OAAO,CAAC,EAAE,cAAc,KACrB,OAAO,CAAC,mBAAmB,CAAC,UAAU,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;CAC7D,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,KAAK,EACL,OAAO,EACP,QAAa,EACb,OAAc,GACf,EAAE,kCAAkC;;;;;;;;EAiFpC;AAyED,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B;;;OAGG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CACjD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,wBAAwB,CAmC7D"}

package/dist/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.js

@@ -0,0 +1,143 @@
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { maxUint256 } from 'viem';
+import { useConfig } from 'wagmi';
+import { readContract } from '@wagmi/core';
+import { assert } from 'ts-essentials';
+import { PERMIT2_ABI } from '../../utils/abi.js';
+import { PERMIT2_ADDRESS } from '../../utils/construct.js';
+
+const PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY = "permit2-nonce";
+function usePermit2TransferFromNonce({
+  owner,
+  chainId,
+  initWord = 0n,
+  enabled = true
+}) {
+  const queryClient = useQueryClient();
+  const config = useConfig();
+  const queryKey = [PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY, owner, chainId];
+  const {
+    data: nonceState_0,
+    isLoading,
+    isError,
+    isSuccess,
+    error,
+    refetch
+  } = useQuery({
+    enabled: enabled && !!(owner && chainId),
+    queryKey,
+    queryFn: async () => {
+      assert(owner, "owner is required");
+      assert(chainId, "chainId is required");
+      const last = queryClient.getQueryData(queryKey);
+      const nextOpenWord = await getNextOpenWord({
+        owner,
+        config,
+        startWord: last?.word ?? initWord
+      });
+      if (!nextOpenWord) {
+        console.warn("No available nonce found");
+        return null;
+      }
+      const {
+        word,
+        bitmap
+      } = nextOpenWord;
+      const bitPos = getFirstUnsetBit(bitmap);
+      if (bitPos === -1) {
+        console.warn("No available nonce found");
+        return null;
+      }
+      const nonceState = {
+        word,
+        bitmap,
+        nonce: word * 256n + BigInt(bitPos)
+      };
+      console.log("PERMIT2::nonceState", nonceState);
+      return nonceState;
+    },
+    // Useful defaults
+    refetchOnWindowFocus: false,
+    notifyOnChangeProps: ["data", "isLoading"]
+  });
+  return {
+    nonceState: nonceState_0,
+    nonceToUse: nonceState_0 === null ? null : nonceState_0?.nonce,
+    isLoading,
+    isError,
+    isSuccess,
+    error,
+    refetch
+  };
+}
+async function getNextOpenWord({
+  owner,
+  config,
+  startWord
+}) {
+  let word = startWord;
+  const MAX = maxUint256;
+  while (true) {
+    const bitmap = await readContract(config, {
+      address: PERMIT2_ADDRESS,
+      abi: PERMIT2_ABI,
+      functionName: "nonceBitmap",
+      args: [owner, word]
+    });
+    if (bitmap !== MAX) {
+      return {
+        word,
+        bitmap
+      };
+    }
+    word += 1n;
+    if (word - startWord > 1024n) {
+      console.warn("Exceeded nonce search limit");
+      return null;
+    }
+  }
+}
+function getFirstUnsetBit(bitmap) {
+  const mask = ~bitmap & bitmap + 1n;
+  if (mask === 0n) return -1;
+  return mask.toString(2).length - 1;
+}
+function useMarkNonceAsUsed() {
+  const queryClient = useQueryClient();
+  const markNonceAsUsed = ({
+    owner,
+    chainId,
+    usedNonce
+  }) => {
+    const queryKey = [PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY, owner, chainId];
+    queryClient.setQueryData(queryKey, (oldNonceState) => {
+      if (!oldNonceState) return oldNonceState;
+      if (oldNonceState.nonce > usedNonce) return oldNonceState;
+      const newNonce = oldNonceState.nonce + 1n;
+      const {
+        word,
+        bitPos
+      } = splitNonce(newNonce);
+      return {
+        word,
+        bitmap: 1n << bitPos,
+        // ✅ convert bit index to actual 256-bit bitmap
+        nonce: newNonce
+      };
+    });
+  };
+  return {
+    markNonceAsUsed
+  };
+}
+function splitNonce(nonce) {
+  const word = nonce / 256n;
+  const bitPos = nonce % 256n;
+  return {
+    word,
+    bitPos
+  };
+}
+
+export { useMarkNonceAsUsed, usePermit2TransferFromNonce };
+//# sourceMappingURL=usePermit2TransferFromNonce.js.map

package/dist/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePermit2TransferFromNonce.js","sources":["../../../../../src/hooks/permit/hooks/permit2/usePermit2TransferFromNonce.ts"],"sourcesContent":["import {\n  useQuery,\n  useQueryClient,\n  type QueryObserverResult,\n  type RefetchOptions,\n} from \"@tanstack/react-query\";\nimport { type Address, maxUint256 } from \"viem\";\nimport { useConfig, type Config } from \"wagmi\";\nimport { readContract } from \"@wagmi/core\";\nimport { assert } from \"ts-essentials\";\nimport { PERMIT2_ABI } from \"../../utils/abi\";\nimport { PERMIT2_ADDRESS } from \"../../utils/construct\";\n\n/**\n * Permit2 stores nonces using a nested bitmap structure:\n *\n * mapping(address => mapping(uint256 => uint256)) public nonceBitmap;\n *\n * - The outer key (`address`) is the permit signer (the `owner`)\n * - The inner key (`uint256 word`) is the index of a 256-bit \"page\"\n * - The value (`uint256`) is the bitmap for that page — each bit (0 to 255) represents a nonce\n *     - If bit `i` is `0`, then nonce `word * 256 + i` is **unused**\n *     - If bit `i` is `1`, then that nonce has **already been used**\n *\n * This is what enables Permit2 to support unordered nonces while saving gas.\n */\n\n// Result of finding an available nonce\ntype NonceState = {\n  word: bigint; // which 256-bit \"page\" of the bitmap we used\n  bitmap: bigint; // the bitmap for that word\n  nonce: bigint; // full 256-based offset: word * 256 + bit index\n};\n\nconst PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY = \"permit2-nonce\";\n\ntype Permit2TransferFromQueryKey = [\n  typeof PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY,\n  owner?: Address,\n  chainId?: number,\n];\n\ninterface UsePermit2TransferFromNonceOptions {\n  owner?: Address;\n  chainId?: number;\n  initWord?: bigint; // word offset to begin scanning from\n  enabled?: boolean;\n}\n\nexport type UsePermit2TransferFromNonceResult = {\n  // null when no can't calculate Permit2 nonce\n  nonceToUse?: bigint | null;\n  nonceState?: NonceState | null;\n  isLoading: boolean;\n  isError: boolean;\n  isSuccess: boolean;\n  error: Error | null;\n  refetch: (\n    options?: RefetchOptions\n  ) => Promise<QueryObserverResult<NonceState | null, Error>>;\n};\n\n/**\n * React hook to find the next unused Permit2 nonce for `permitTransferFrom`.\n *\n * Permit2 stores nonces as a bitmap:\n * - Each address has a mapping from uint256 => uint256\n * - Each value is a 256-bit bitmap (called a \"word\")\n * - If a bit is 1, the nonce (word * 256 + bit index) is used\n * - If it's 0, it's free and can be used\n */\nexport function usePermit2TransferFromNonce({\n  owner,\n  chainId,\n  initWord = 0n,\n  enabled = true,\n}: UsePermit2TransferFromNonceOptions) {\n  const queryClient = useQueryClient();\n  const config = useConfig();\n\n  const queryKey: Permit2TransferFromQueryKey = [\n    PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY,\n    owner,\n    chainId,\n  ];\n\n  const {\n    data: nonceState,\n    isLoading,\n    isError,\n    isSuccess,\n    error,\n    refetch,\n  } = useQuery<\n    NonceState | null,\n    Error,\n    NonceState | null,\n    Permit2TransferFromQueryKey\n  >({\n    enabled: enabled && !!(owner && chainId),\n\n    queryKey,\n\n    queryFn: async () => {\n      // Safety checks\n      assert(owner, \"owner is required\");\n      assert(chainId, \"chainId is required\");\n\n      // Try to resume scanning from last known state if available\n      const last = queryClient.getQueryData<NonceState>(queryKey);\n\n      // Find a bitmap word that has at least one unused bit (i.e. a usable nonce)\n      const nextOpenWord = await getNextOpenWord({\n        owner,\n        config,\n        startWord: last?.word ?? initWord,\n      });\n\n      if (!nextOpenWord) {\n        console.warn(\"No available nonce found\");\n        return null;\n      }\n\n      const { word, bitmap } = nextOpenWord;\n      // Identify the first 0-bit in the bitmap — that’s our next nonce\n      const bitPos = getFirstUnsetBit(bitmap);\n      if (bitPos === -1) {\n        console.warn(\"No available nonce found\");\n        return null;\n      }\n\n      const nonceState = {\n        word,\n        bitmap,\n        nonce: word * 256n + BigInt(bitPos),\n      };\n\n      console.log(\"PERMIT2::nonceState\", nonceState);\n\n      // The final usable nonce is: word * 256 + bit index\n      return nonceState;\n    },\n\n    // Useful defaults\n    refetchOnWindowFocus: false,\n    notifyOnChangeProps: [\"data\", \"isLoading\"],\n  });\n\n  return {\n    nonceState,\n    nonceToUse: nonceState === null ? null : nonceState?.nonce,\n    isLoading,\n    isError,\n    isSuccess,\n    error,\n    refetch,\n  };\n}\n\ninterface GetNextOpenWordInput {\n  owner: Address;\n  config: Config;\n  startWord: bigint;\n}\n\n/**\n * Scans bitmap word-by-word starting at `startWord` until it finds\n * one with at least one unused bit (i.e., not all bits are set to 1).\n */\nasync function getNextOpenWord({\n  owner,\n  config,\n  startWord,\n}: GetNextOpenWordInput): Promise<{ word: bigint; bitmap: bigint } | null> {\n  let word = startWord;\n  const MAX = maxUint256; // full 256-bit word (0xffff...ffff)\n\n  while (true) {\n    // Read the bitmap word for the given owner and word index\n    const bitmap = await readContract(config, {\n      address: PERMIT2_ADDRESS,\n      abi: PERMIT2_ABI,\n      functionName: \"nonceBitmap\",\n      args: [owner, word],\n    });\n\n    // If the bitmap is not fully used (i.e., not all bits are 1)\n    if (bitmap !== MAX) {\n      return { word, bitmap };\n    }\n\n    word += 1n;\n\n    // Fail-safe: don't scan more than 1024 words (262,144 nonces)\n    if (word - startWord > 1024n) {\n      console.warn(\"Exceeded nonce search limit\");\n      return null;\n    }\n  }\n}\n\n/**\n * Returns the index (0–255) of the first unset (zero) bit in a 256-bit bitmap.\n *\n * Uses a classic bit-hack: (~bitmap) & (bitmap + 1)\n *\n * This produces a bitmask with only the lowest 0-bit set to 1.\n * Example:\n *   bitmap = 0b1110       → unset bit at index 0\n *   ~bitmap = 0b...0001\n *   bitmap + 1 = 0b1111\n *   result = 0b0001 → bitmask for index 0\n *\n * We then convert the bitmask to binary and count how many bits it takes\n * to shift that 1 into place = its position.\n */\nfunction getFirstUnsetBit(bitmap: bigint): number {\n  // Create a bitmask with a 1 only at the first 0-bit (LSB side)\n  const mask = ~bitmap & (bitmap + 1n);\n\n  // If all bits are set (mask is zero), there are no available nonces\n  if (mask === 0n) return -1;\n\n  // Convert mask to binary and count digits – the length is the index + 1\n  // e.g. mask = 0b1000 → \"1000\" → length = 4 → index = 3\n  return mask.toString(2).length - 1;\n}\n\n/////// MARK NONCE AS USED ///////\n\ntype SetNonceInput = {\n  owner: Address;\n  chainId: number;\n  usedNonce: bigint;\n};\n\ntype UseMarkNonceAsUsedResult = {\n  /**\n   * Mark a nonce as \"used\" in the local cache after submitting a transaction or order\n   * This prevents reuse of the same nonce while it's still pending on-chain.\n   */\n  markNonceAsUsed: (input: SetNonceInput) => void;\n};\n\n/**\n * Hook to manually bump the locally cached Permit2 nonce to avoid reuse\n *\n * Permit2 allows unordered nonces, but while a tx is pending, it's safer to use\n * a strictly increasing nonce to avoid accidental replays or reuse.\n *\n * clearing an unsued nonce is not necessary because nonces are unordered\n */\nexport function useMarkNonceAsUsed(): UseMarkNonceAsUsedResult {\n  const queryClient = useQueryClient();\n\n  const markNonceAsUsed: UseMarkNonceAsUsedResult[\"markNonceAsUsed\"] = ({\n    owner,\n    chainId,\n    usedNonce,\n  }) => {\n    const queryKey: Permit2TransferFromQueryKey = [\n      PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY,\n      owner,\n      chainId,\n    ];\n\n    // Update cached nonce state if the used nonce was >= current one\n    queryClient.setQueryData<NonceState>(queryKey, (oldNonceState) => {\n      if (!oldNonceState) return oldNonceState; // should not happen unless cache was cleared\n\n      // If we're already past this nonce, nothing to do\n      if (oldNonceState.nonce > usedNonce) return oldNonceState;\n\n      const newNonce = oldNonceState.nonce + 1n;\n      const { word, bitPos } = splitNonce(newNonce);\n\n      return {\n        word,\n        bitmap: 1n << bitPos, // ✅ convert bit index to actual 256-bit bitmap\n        nonce: newNonce,\n      };\n    });\n  };\n\n  return {\n    markNonceAsUsed,\n  };\n}\n\n/**\n * Splits a Permit2 nonce into:\n * - `word`: which 256-bit bitmap page (nonce / 256)\n * - `bitPos`: position within that word (nonce % 256)\n */\nfunction splitNonce(nonce: bigint): { word: bigint; bitPos: bigint } {\n  const word = nonce / 256n;\n  const bitPos = nonce % 256n;\n  return { word, bitPos };\n}\n"],"names":["PERMIT2_TRANSFER_FROM_NONCE_QUERY_KEY","usePermit2TransferFromNonce","owner","chainId","initWord","enabled","queryClient","useQueryClient","config","useConfig","queryKey","data","nonceState","isLoading","isError","isSuccess","error","refetch","useQuery","queryFn","assert","last","getQueryData","nextOpenWord","getNextOpenWord","startWord","word","console","warn","bitmap","bitPos","getFirstUnsetBit","nonce","BigInt","log","refetchOnWindowFocus","notifyOnChangeProps","nonceToUse","MAX","maxUint256","readContract","address","PERMIT2_ADDRESS","abi","PERMIT2_ABI","functionName","args","mask","toString","length","useMarkNonceAsUsed","markNonceAsUsed","usedNonce","setQueryData","oldNonceState","newNonce","splitNonce"],"mappings":";;;;;;;;AAkCA,MAAMA,qCAAAA,GAAwC,eAAA;AAqCvC,SAASC,2BAAAA,CAA4B;AAAA,EAC1CC,KAAAA;AAAAA,EACAC,OAAAA;AAAAA,EACAC,QAAAA,GAAW,EAAA;AAAA,EACXC,OAAAA,GAAU;AACwB,CAAA,EAAG;AACrC,EAAA,MAAMC,cAAcC,cAAAA,EAAe;AACnC,EAAA,MAAMC,SAASC,SAAAA,EAAU;AAEzB,EAAA,MAAMC,QAAAA,GAAwC,CAC5CV,qCAAAA,EACAE,KAAAA,EACAC,OAAO,CAAA;AAGT,EAAA,MAAM;AAAA,IACJQ,IAAAA,EAAMC,YAAAA;AAAAA,IACNC,SAAAA;AAAAA,IACAC,OAAAA;AAAAA,IACAC,SAAAA;AAAAA,IACAC,KAAAA;AAAAA,IACAC;AAAAA,MACEC,QAAAA,CAKF;AAAA,IACAb,OAAAA,EAASA,OAAAA,IAAW,CAAC,EAAEH,KAAAA,IAASC,OAAAA,CAAAA;AAAAA,IAEhCO,QAAAA;AAAAA,IAEAS,SAAS,YAAY;AAEnBC,MAAAA,MAAAA,CAAOlB,OAAO,mBAAmB,CAAA;AACjCkB,MAAAA,MAAAA,CAAOjB,SAAS,qBAAqB,CAAA;AAGrC,MAAA,MAAMkB,IAAAA,GAAOf,WAAAA,CAAYgB,YAAAA,CAAyBZ,QAAQ,CAAA;AAG1D,MAAA,MAAMa,YAAAA,GAAe,MAAMC,eAAAA,CAAgB;AAAA,QACzCtB,KAAAA;AAAAA,QACAM,MAAAA;AAAAA,QACAiB,SAAAA,EAAWJ,MAAMK,IAAAA,IAAQtB;AAAAA,OAC1B,CAAA;AAED,MAAA,IAAI,CAACmB,YAAAA,EAAc;AACjBI,QAAAA,OAAAA,CAAQC,KAAK,0BAA0B,CAAA;AACvC,QAAA,OAAO,IAAA;AAAA;AAGT,MAAA,MAAM;AAAA,QAAEF,IAAAA;AAAAA,QAAMG;AAAAA,OAAO,GAAIN,YAAAA;AAEzB,MAAA,MAAMO,MAAAA,GAASC,iBAAiBF,MAAM,CAAA;AACtC,MAAA,IAAIC,WAAW,EAAA,EAAI;AACjBH,QAAAA,OAAAA,CAAQC,KAAK,0BAA0B,CAAA;AACvC,QAAA,OAAO,IAAA;AAAA;AAGT,MAAA,MAAMhB,UAAAA,GAAa;AAAA,QACjBc,IAAAA;AAAAA,QACAG,MAAAA;AAAAA,QACAG,KAAAA,EAAON,IAAAA,GAAO,IAAA,GAAOO,MAAAA,CAAOH,MAAM;AAAA,OACpC;AAEAH,MAAAA,OAAAA,CAAQO,GAAAA,CAAI,uBAAuBtB,UAAU,CAAA;AAG7C,MAAA,OAAOA,UAAAA;AAAAA,KACT;AAAA;AAAA,IAGAuB,oBAAAA,EAAsB,KAAA;AAAA,IACtBC,mBAAAA,EAAqB,CAAC,MAAA,EAAQ,WAAW;AAAA,GAC1C,CAAA;AAED,EAAA,OAAO;AAAA,IACLxB,UAAAA,EAAAA,YAAAA;AAAAA,IACAyB,UAAAA,EAAYzB,YAAAA,KAAe,IAAA,GAAO,IAAA,GAAOA,YAAAA,EAAYoB,KAAAA;AAAAA,IACrDnB,SAAAA;AAAAA,IACAC,OAAAA;AAAAA,IACAC,SAAAA;AAAAA,IACAC,KAAAA;AAAAA,IACAC;AAAAA,GACF;AACF;AAYA,eAAeO,eAAAA,CAAgB;AAAA,EAC7BtB,KAAAA;AAAAA,EACAM,MAAAA;AAAAA,EACAiB;AACoB,CAAA,EAAqD;AACzE,EAAA,IAAIC,IAAAA,GAAOD,SAAAA;AACX,EAAA,MAAMa,GAAAA,GAAMC,UAAAA;AAEZ,EAAA,OAAO,IAAA,EAAM;AAEX,IAAA,MAAMV,MAAAA,GAAS,MAAMW,YAAAA,CAAahC,MAAAA,EAAQ;AAAA,MACxCiC,OAAAA,EAASC,eAAAA;AAAAA,MACTC,GAAAA,EAAKC,WAAAA;AAAAA,MACLC,YAAAA,EAAc,aAAA;AAAA,MACdC,IAAAA,EAAM,CAAC5C,KAAAA,EAAOwB,IAAI;AAAA,KACnB,CAAA;AAGD,IAAA,IAAIG,WAAWS,GAAAA,EAAK;AAClB,MAAA,OAAO;AAAA,QAAEZ,IAAAA;AAAAA,QAAMG;AAAAA,OAAO;AAAA;AAGxBH,IAAAA,IAAAA,IAAQ,EAAA;AAGR,IAAA,IAAIA,IAAAA,GAAOD,YAAY,KAAA,EAAO;AAC5BE,MAAAA,OAAAA,CAAQC,KAAK,6BAA6B,CAAA;AAC1C,MAAA,OAAO,IAAA;AAAA;AACT;AAEJ;AAiBA,SAASG,iBAAiBF,MAAAA,EAAwB;AAEhD,EAAA,MAAMkB,IAAAA,GAAO,CAAClB,MAAAA,GAAUA,MAAAA,GAAS,EAAA;AAGjC,EAAA,IAAIkB,IAAAA,KAAS,IAAI,OAAO,EAAA;AAIxB,EAAA,OAAOA,IAAAA,CAAKC,QAAAA,CAAS,CAAC,CAAA,CAAEC,MAAAA,GAAS,CAAA;AACnC;AA0BO,SAASC,kBAAAA,GAA+C;AAC7D,EAAA,MAAM5C,cAAcC,cAAAA,EAAe;AAEnC,EAAA,MAAM4C,kBAA+DA,CAAC;AAAA,IACpEjD,KAAAA;AAAAA,IACAC,OAAAA;AAAAA,IACAiD;AAAAA,GACF,KAAM;AACJ,IAAA,MAAM1C,QAAAA,GAAwC,CAC5CV,qCAAAA,EACAE,KAAAA,EACAC,OAAO,CAAA;AAITG,IAAAA,WAAAA,CAAY+C,YAAAA,CAAyB3C,UAAW4C,CAAAA,aAAAA,KAAkB;AAChE,MAAA,IAAI,CAACA,eAAe,OAAOA,aAAAA;AAG3B,MAAA,IAAIA,aAAAA,CAActB,KAAAA,GAAQoB,SAAAA,EAAW,OAAOE,aAAAA;AAE5C,MAAA,MAAMC,QAAAA,GAAWD,cAActB,KAAAA,GAAQ,EAAA;AACvC,MAAA,MAAM;AAAA,QAAEN,IAAAA;AAAAA,QAAMI;AAAAA,OAAO,GAAI0B,WAAWD,QAAQ,CAAA;AAE5C,MAAA,OAAO;AAAA,QACL7B,IAAAA;AAAAA,QACAG,QAAQ,EAAA,IAAMC,MAAAA;AAAAA;AAAAA,QACdE,KAAAA,EAAOuB;AAAAA,OACT;AAAA,KACD,CAAA;AAAA,GACH;AAEA,EAAA,OAAO;AAAA,IACLJ;AAAAA,GACF;AACF;AAOA,SAASK,WAAWxB,KAAAA,EAAiD;AACnE,EAAA,MAAMN,OAAOM,KAAAA,GAAQ,IAAA;AACrB,EAAA,MAAMF,SAASE,KAAAA,GAAQ,IAAA;AACvB,EAAA,OAAO;AAAA,IAAEN,IAAAA;AAAAA,IAAMI;AAAAA,GAAO;AACxB;;;;"}

package/dist/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.d.ts

@@ -0,0 +1,52 @@
+import { Address, Hash, Hex } from 'viem';
+import { Permit2Input } from '../../utils/construct';
+import { Token } from '../../../../tokens/state/types';
+type UseSignTokenPermit2TransferFromParams = {
+    onSuccess?: (signature: Hex) => void;
+    onError?: (error: Error) => void;
+    token?: Pick<Token, "address" | "network">;
+    value?: bigint;
+    spender?: Address;
+    enabled?: boolean;
+};
+type QueryMutState = {
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+};
+export type SignedPermit2Result = {
+    signature: Hash;
+    permit2TransferFromEncodedArgs: Hash;
+    signedPermitData: Permit2Input & {
+        variant: "transferFrom";
+        owner: Address;
+    };
+};
+export type SignPermit2TransferFromInput = {
+    deadline?: bigint;
+} & Pick<UseSignTokenPermit2TransferFromParams, "value" | "spender">;
+export type UseSignTokenPermit2TransferFromResult = {
+    signPermit2: (params?: SignPermit2TransferFromInput) => void;
+    signPermit2Async: (params?: SignPermit2TransferFromInput) => Promise<SignedPermit2Result>;
+    encodePermitArgs: (params?: SignPermit2TransferFromInput) => Hash | undefined;
+    isPermitSupported: boolean;
+    isPermitReadyToSign: boolean;
+    permitFetchingState: QueryMutState;
+    permitSigningState: QueryMutState;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+    signature?: Hash;
+};
+export declare function useSignTokenPermit2TransferFrom({ onSuccess, onError, token, value, spender, enabled, }: UseSignTokenPermit2TransferFromParams): UseSignTokenPermit2TransferFromResult;
+type UseMarkPermit2NonceAsUsedResult = {
+    markNonceAsUsed: (signedPermitData: Permit2Input & {
+        owner: Address;
+    }) => void;
+};
+export declare function useMarkPermit2NonceAsUsed(): UseMarkPermit2NonceAsUsedResult;
+export {};
+//# sourceMappingURL=useSignTokenPermit2TransferFrom.d.ts.map

package/dist/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignTokenPermit2TransferFrom.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAWlD,KAAK,qCAAqC,GAAG;IAC3C,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,KAAK,IAAI,CAAC;IACrC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,IAAI,CAAC;IAChB,8BAA8B,EAAE,IAAI,CAAC;IACrC,gBAAgB,EAAE,YAAY,GAAG;QAC/B,OAAO,EAAE,cAAc,CAAC;QACxB,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IAEzC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAEnB,GAAG,IAAI,CAAC,qCAAqC,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC;AAErE,MAAM,MAAM,qCAAqC,GAAG;IAClD,WAAW,EAAE,CAAC,MAAM,CAAC,EAAE,4BAA4B,KAAK,IAAI,CAAC;IAC7D,gBAAgB,EAAE,CAChB,MAAM,CAAC,EAAE,4BAA4B,KAClC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClC,gBAAgB,EAAE,CAAC,MAAM,CAAC,EAAE,4BAA4B,KAAK,IAAI,GAAG,SAAS,CAAC;IAC9E,iBAAiB,EAAE,OAAO,CAAC;IAC3B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,mBAAmB,EAAE,aAAa,CAAC;IACnC,kBAAkB,EAAE,aAAa,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB,CAAC;AAEF,wBAAgB,+BAA+B,CAAC,EAC9C,SAAS,EACT,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAc,GACf,EAAE,qCAAqC,GAAG,qCAAqC,CA2J/E;AAED,KAAK,+BAA+B,GAAG;IACrC,eAAe,EAAE,CACf,gBAAgB,EAAE,YAAY,GAAG;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,KAChD,IAAI,CAAC;CACX,CAAC;AAEF,wBAAgB,yBAAyB,IAAI,+BAA+B,CAkB3E"}

package/dist/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.js

@@ -0,0 +1,299 @@
+import { d as distExports } from '../../../../_virtual/index.js';
+import { useAccount } from 'wagmi';
+import { isAddress, serializeCompactSignature, signatureToCompactSignature, parseSignature } from 'viem';
+import { useSignPermit } from '../common/useSignPermit.js';
+import { assert } from 'ts-essentials';
+import { encodePermit2TransferFromMethodArgs } from '../../utils/encodeArgs.js';
+import { usePermit2Allowance } from './usePermit2Allowance.js';
+import { useMarkNonceAsUsed, usePermit2TransferFromNonce } from './usePermit2TransferFromNonce.js';
+import { produceSignatureDeadline } from '../../utils/deadlines.js';
+import { useWalletSupportsPermit } from '../common/useWalletSupportsPermit.js';
+
+function useSignTokenPermit2TransferFrom(t0) {
+  const $ = distExports.c(56);
+  const {
+    onSuccess,
+    onError,
+    token,
+    value,
+    spender,
+    enabled: t1
+  } = t0;
+  const enabled = t1 === void 0 ? true : t1;
+  const {
+    permit2: isPermit2Supported
+  } = useWalletSupportsPermit();
+  const queriesEnabled = enabled && isPermit2Supported;
+  let t2;
+  if ($[0] !== queriesEnabled || $[1] !== spender || $[2] !== token || $[3] !== value) {
+    t2 = {
+      token,
+      spender,
+      amount: value,
+      enabled: queriesEnabled
+    };
+    $[0] = queriesEnabled;
+    $[1] = spender;
+    $[2] = token;
+    $[3] = value;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const permit2AllowanceQueryResult = usePermit2Allowance(t2);
+  const {
+    address: owner
+  } = useAccount();
+  const t3 = token?.network;
+  let t4;
+  if ($[5] !== owner || $[6] !== queriesEnabled || $[7] !== t3) {
+    t4 = {
+      owner,
+      chainId: t3,
+      enabled: queriesEnabled
+    };
+    $[5] = owner;
+    $[6] = queriesEnabled;
+    $[7] = t3;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const nonceQueryResult = usePermit2TransferFromNonce(t4);
+  const t5 = permit2AllowanceQueryResult.isLoading || nonceQueryResult.isLoading;
+  const t6 = permit2AllowanceQueryResult.isError || nonceQueryResult.isError;
+  const t7 = permit2AllowanceQueryResult.isSuccess || nonceQueryResult.isSuccess;
+  const t8 = permit2AllowanceQueryResult.error || nonceQueryResult.error;
+  let t9;
+  if ($[9] !== t5 || $[10] !== t6 || $[11] !== t7 || $[12] !== t8) {
+    t9 = {
+      isPending: t5,
+      isError: t6,
+      isSuccess: t7,
+      error: t8
+    };
+    $[9] = t5;
+    $[10] = t6;
+    $[11] = t7;
+    $[12] = t8;
+    $[13] = t9;
+  } else {
+    t9 = $[13];
+  }
+  const permitFetchingState = t9;
+  const isPermitSupported = permit2AllowanceQueryResult.canUsePermit2 && permit2AllowanceQueryResult.enoughAllowanceForPermit2 && isPermit2Supported;
+  const isPermitReadyToSign = isPermitSupported && !!owner && typeof nonceQueryResult.nonceToUse === "bigint";
+  let t10;
+  if ($[14] !== onError || $[15] !== onSuccess) {
+    t10 = {
+      onSuccess,
+      onError
+    };
+    $[14] = onError;
+    $[15] = onSuccess;
+    $[16] = t10;
+  } else {
+    t10 = $[16];
+  }
+  const signMut = useSignPermit(t10);
+  let t11;
+  if ($[17] !== signMut.error || $[18] !== signMut.isError || $[19] !== signMut.isPending || $[20] !== signMut.isSuccess) {
+    t11 = {
+      isPending: signMut.isPending,
+      isError: signMut.isError,
+      isSuccess: signMut.isSuccess,
+      error: signMut.error
+    };
+    $[17] = signMut.error;
+    $[18] = signMut.isError;
+    $[19] = signMut.isPending;
+    $[20] = signMut.isSuccess;
+    $[21] = t11;
+  } else {
+    t11 = $[21];
+  }
+  const permitSigningState = t11;
+  const isPending = permitFetchingState.isPending || permitSigningState.isPending;
+  const isError = permitFetchingState.isError || permitSigningState.isError;
+  const isSuccess = permitFetchingState.isSuccess || permitSigningState.isSuccess;
+  const error = permitFetchingState.error || permitSigningState.error;
+  const nonce = nonceQueryResult.nonceToUse;
+  let t12;
+  if ($[22] !== nonce || $[23] !== owner || $[24] !== spender || $[25] !== token || $[26] !== value) {
+    t12 = (params) => {
+      const _spender = params?.spender || spender;
+      const _value = params?.value || value;
+      const deadline = params?.deadline || produceSignatureDeadline();
+      assert(owner, "Account not connected");
+      assert(typeof nonce === "bigint", "Nonce not available");
+      assert(_spender, "Spender not available");
+      assert(_value, "Value not available or 0");
+      assert(token?.address && isAddress(token.address), "Token not available");
+      const permit2Input = {
+        type: "permit2",
+        variant: "transferFrom",
+        token: token.address,
+        spender: _spender,
+        nonce,
+        amount: _value,
+        expiration: deadline,
+        chainId: token.network
+      };
+      return permit2Input;
+    };
+    $[22] = nonce;
+    $[23] = owner;
+    $[24] = spender;
+    $[25] = token;
+    $[26] = value;
+    $[27] = t12;
+  } else {
+    t12 = $[27];
+  }
+  const producePermitInput = t12;
+  let t13;
+  if ($[28] !== owner || $[29] !== producePermitInput || $[30] !== signMut) {
+    t13 = async (params_0) => {
+      assert(owner, "Account not connected");
+      const _input = producePermitInput(params_0);
+      const input = {
+        ..._input,
+        owner
+      };
+      const signature = await signMut.signPermitAsync(input);
+      const compactSignature = serializeCompactSignature(signatureToCompactSignature(parseSignature(signature)));
+      const encodedArgs = encodePermit2TransferFromMethodArgs({
+        ...input,
+        signature: compactSignature
+      });
+      return {
+        signature: compactSignature,
+        permit2TransferFromEncodedArgs: encodedArgs,
+        signedPermitData: input
+      };
+    };
+    $[28] = owner;
+    $[29] = producePermitInput;
+    $[30] = signMut;
+    $[31] = t13;
+  } else {
+    t13 = $[31];
+  }
+  const signPermit2Async = t13;
+  let t14;
+  if ($[32] !== producePermitInput || $[33] !== signMut) {
+    t14 = (params_1) => {
+      const input_0 = producePermitInput(params_1);
+      signMut.signPermit(input_0);
+    };
+    $[32] = producePermitInput;
+    $[33] = signMut;
+    $[34] = t14;
+  } else {
+    t14 = $[34];
+  }
+  const signPermit2 = t14;
+  const paramsNotAvailable = typeof nonce !== "bigint" || !owner;
+  let t15;
+  if ($[35] !== owner || $[36] !== paramsNotAvailable || $[37] !== producePermitInput || $[38] !== signMut.signature || $[39] !== spender || $[40] !== value) {
+    t15 = (params_2) => {
+      const _spender_0 = params_2?.spender || spender;
+      const _value_0 = params_2?.value || value;
+      if (!signMut.signature || paramsNotAvailable || !_spender_0 || !_value_0) {
+        return;
+      }
+      const input_1 = producePermitInput({
+        spender: _spender_0,
+        value: _value_0
+      });
+      return encodePermit2TransferFromMethodArgs({
+        ...input_1,
+        signature: signMut.signature,
+        owner
+      });
+    };
+    $[35] = owner;
+    $[36] = paramsNotAvailable;
+    $[37] = producePermitInput;
+    $[38] = signMut.signature;
+    $[39] = spender;
+    $[40] = value;
+    $[41] = t15;
+  } else {
+    t15 = $[41];
+  }
+  const encodePermitArgs = t15;
+  let t16;
+  if ($[42] !== encodePermitArgs || $[43] !== error || $[44] !== isError || $[45] !== isPending || $[46] !== isPermitReadyToSign || $[47] !== isPermitSupported || $[48] !== isSuccess || $[49] !== permitFetchingState || $[50] !== permitSigningState || $[51] !== signMut.reset || $[52] !== signMut.signature || $[53] !== signPermit2 || $[54] !== signPermit2Async) {
+    t16 = {
+      signPermit2,
+      signPermit2Async,
+      encodePermitArgs,
+      isPermitSupported,
+      isPermitReadyToSign,
+      permitFetchingState,
+      permitSigningState,
+      isPending,
+      isSuccess,
+      isError,
+      error,
+      reset: signMut.reset,
+      signature: signMut.signature
+    };
+    $[42] = encodePermitArgs;
+    $[43] = error;
+    $[44] = isError;
+    $[45] = isPending;
+    $[46] = isPermitReadyToSign;
+    $[47] = isPermitSupported;
+    $[48] = isSuccess;
+    $[49] = permitFetchingState;
+    $[50] = permitSigningState;
+    $[51] = signMut.reset;
+    $[52] = signMut.signature;
+    $[53] = signPermit2;
+    $[54] = signPermit2Async;
+    $[55] = t16;
+  } else {
+    t16 = $[55];
+  }
+  return t16;
+}
+function useMarkPermit2NonceAsUsed() {
+  const $ = distExports.c(4);
+  const nonceUsedMarker = useMarkNonceAsUsed();
+  let t0;
+  if ($[0] !== nonceUsedMarker) {
+    t0 = (t12) => {
+      const {
+        owner,
+        chainId,
+        nonce
+      } = t12;
+      nonceUsedMarker.markNonceAsUsed({
+        owner,
+        chainId,
+        usedNonce: nonce
+      });
+    };
+    $[0] = nonceUsedMarker;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const markNonceAsUsed = t0;
+  let t1;
+  if ($[2] !== markNonceAsUsed) {
+    t1 = {
+      markNonceAsUsed
+    };
+    $[2] = markNonceAsUsed;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  return t1;
+}
+
+export { useMarkPermit2NonceAsUsed, useSignTokenPermit2TransferFrom };
+//# sourceMappingURL=useSignTokenPermit2TransferFrom.js.map

package/dist/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignTokenPermit2TransferFrom.js","sources":["../../../../../src/hooks/permit/hooks/permit2/useSignTokenPermit2TransferFrom.ts"],"sourcesContent":["import { useAccount } from \"wagmi\";\nimport {\n  isAddress,\n  parseSignature,\n  serializeCompactSignature,\n  signatureToCompactSignature,\n  type Address,\n  type Hash,\n  type Hex,\n} from \"viem\";\nimport { useSignPermit } from \"../common/useSignPermit\";\nimport type { Permit2Input } from \"../../utils/construct\";\nimport type { Token } from \"@/tokens/state/types\";\nimport { assert } from \"ts-essentials\";\nimport { encodePermit2TransferFromMethodArgs } from \"../../utils/encodeArgs\";\nimport { usePermit2Allowance } from \"./usePermit2Allowance\";\nimport {\n  useMarkNonceAsUsed,\n  usePermit2TransferFromNonce,\n} from \"./usePermit2TransferFromNonce\";\nimport { produceSignatureDeadline } from \"../../utils/deadlines\";\nimport { useWalletSupportsPermit } from \"../common/useWalletSupportsPermit\";\n\ntype UseSignTokenPermit2TransferFromParams = {\n  onSuccess?: (signature: Hex) => void;\n  onError?: (error: Error) => void;\n  token?: Pick<Token, \"address\" | \"network\">;\n  value?: bigint;\n  spender?: Address;\n  enabled?: boolean;\n};\n\ntype QueryMutState = {\n  isPending: boolean;\n  isError: boolean;\n  isSuccess: boolean;\n  error: Error | null;\n};\n\nexport type SignedPermit2Result = {\n  signature: Hash;\n  permit2TransferFromEncodedArgs: Hash;\n  signedPermitData: Permit2Input & {\n    variant: \"transferFrom\";\n    owner: Address;\n  };\n};\n\nexport type SignPermit2TransferFromInput = {\n  // sometimes we need specific deadline that is available only outside the hook\n  deadline?: bigint;\n  // e.g. on delta the order.deadline must exactly match permit2.deadline\n} & Pick<UseSignTokenPermit2TransferFromParams, \"value\" | \"spender\">;\n\nexport type UseSignTokenPermit2TransferFromResult = {\n  signPermit2: (params?: SignPermit2TransferFromInput) => void;\n  signPermit2Async: (\n    params?: SignPermit2TransferFromInput\n  ) => Promise<SignedPermit2Result>;\n  encodePermitArgs: (params?: SignPermit2TransferFromInput) => Hash | undefined;\n  isPermitSupported: boolean;\n  isPermitReadyToSign: boolean;\n  permitFetchingState: QueryMutState;\n  permitSigningState: QueryMutState;\n  isPending: boolean;\n  isSuccess: boolean;\n  isError: boolean;\n  error: Error | null;\n  reset: () => void;\n  signature?: Hash;\n};\n\nexport function useSignTokenPermit2TransferFrom({\n  onSuccess,\n  onError,\n  token,\n  value,\n  spender,\n  enabled = true,\n}: UseSignTokenPermit2TransferFromParams): UseSignTokenPermit2TransferFromResult {\n  const { permit2: isPermit2Supported } = useWalletSupportsPermit();\n\n  const queriesEnabled = enabled && isPermit2Supported;\n\n  const permit2AllowanceQueryResult = usePermit2Allowance({\n    token,\n    spender,\n    amount: value,\n    enabled: queriesEnabled,\n  });\n\n  const { address: owner } = useAccount();\n\n  const nonceQueryResult = usePermit2TransferFromNonce({\n    owner,\n    chainId: token?.network,\n    enabled: queriesEnabled,\n  });\n\n  const permitFetchingState = {\n    isPending:\n      permit2AllowanceQueryResult.isLoading || nonceQueryResult.isLoading,\n    isError: permit2AllowanceQueryResult.isError || nonceQueryResult.isError,\n    isSuccess:\n      permit2AllowanceQueryResult.isSuccess || nonceQueryResult.isSuccess,\n    error: permit2AllowanceQueryResult.error || nonceQueryResult.error,\n  };\n\n  const isPermitSupported =\n    permit2AllowanceQueryResult.canUsePermit2 &&\n    permit2AllowanceQueryResult.enoughAllowanceForPermit2 &&\n    isPermit2Supported;\n  const isPermitReadyToSign =\n    isPermitSupported &&\n    !!owner &&\n    typeof nonceQueryResult.nonceToUse === \"bigint\";\n\n  const signMut = useSignPermit({\n    onSuccess,\n    onError,\n  });\n\n  const permitSigningState = {\n    isPending: signMut.isPending,\n    isError: signMut.isError,\n    isSuccess: signMut.isSuccess,\n    error: signMut.error,\n  };\n\n  const isPending =\n    permitFetchingState.isPending || permitSigningState.isPending;\n  const isError = permitFetchingState.isError || permitSigningState.isError;\n  const isSuccess =\n    permitFetchingState.isSuccess || permitSigningState.isSuccess;\n  const error = permitFetchingState.error || permitSigningState.error;\n\n  const nonce = nonceQueryResult.nonceToUse;\n\n  const producePermitInput = (params?: SignPermit2TransferFromInput) => {\n    const _spender = params?.spender || spender;\n    const _value = params?.value || value;\n    const deadline = params?.deadline || produceSignatureDeadline();\n\n    assert(owner, \"Account not connected\");\n    assert(typeof nonce === \"bigint\", \"Nonce not available\");\n    assert(_spender, \"Spender not available\");\n    assert(_value, \"Value not available or 0\");\n    assert(token?.address && isAddress(token.address), \"Token not available\");\n\n    const permit2Input = {\n      type: \"permit2\",\n      variant: \"transferFrom\",\n      token: token.address,\n      spender: _spender,\n      nonce,\n      amount: _value,\n      expiration: deadline,\n      chainId: token.network,\n    } as const satisfies Permit2Input;\n    return permit2Input;\n  };\n\n  const signPermit2Async: UseSignTokenPermit2TransferFromResult[\"signPermit2Async\"] =\n    async (params) => {\n      assert(owner, \"Account not connected\");\n      const _input = producePermitInput(params);\n      const input = {\n        ..._input,\n        owner,\n      };\n      const signature = await signMut.signPermitAsync(input);\n\n      // contract requires Compact Signature\n      const compactSignature = serializeCompactSignature(\n        // this is unusable with Multisig Smart Wallets, because signature is non-standard length and it can'be parsed\n        signatureToCompactSignature(parseSignature(signature))\n      );\n\n      const encodedArgs = encodePermit2TransferFromMethodArgs({\n        ...input,\n        signature: compactSignature,\n      });\n\n      return {\n        signature: compactSignature,\n        permit2TransferFromEncodedArgs: encodedArgs,\n        signedPermitData: input,\n      };\n    };\n\n  const signPermit2: UseSignTokenPermit2TransferFromResult[\"signPermit2\"] = (\n    params\n  ) => {\n    const input = producePermitInput(params);\n    signMut.signPermit(input);\n  };\n\n  const paramsNotAvailable = typeof nonce !== \"bigint\" || !owner;\n\n  const encodePermitArgs: UseSignTokenPermit2TransferFromResult[\"encodePermitArgs\"] =\n    (params) => {\n      const _spender = params?.spender || spender;\n      const _value = params?.value || value;\n\n      if (!signMut.signature || paramsNotAvailable || !_spender || !_value) {\n        return;\n      }\n      const input = producePermitInput({\n        spender: _spender,\n        value: _value,\n      });\n\n      return encodePermit2TransferFromMethodArgs({\n        ...input,\n        signature: signMut.signature,\n        owner,\n      });\n    };\n\n  return {\n    signPermit2,\n    signPermit2Async,\n    encodePermitArgs,\n    isPermitSupported,\n    isPermitReadyToSign,\n    permitFetchingState,\n    permitSigningState,\n    isPending,\n    isSuccess,\n    isError,\n    error,\n    reset: signMut.reset,\n    signature: signMut.signature,\n  };\n}\n\ntype UseMarkPermit2NonceAsUsedResult = {\n  markNonceAsUsed: (\n    signedPermitData: Permit2Input & { owner: Address }\n  ) => void;\n};\n\nexport function useMarkPermit2NonceAsUsed(): UseMarkPermit2NonceAsUsedResult {\n  const nonceUsedMarker = useMarkNonceAsUsed();\n\n  const markNonceAsUsed: UseMarkPermit2NonceAsUsedResult[\"markNonceAsUsed\"] = ({\n    owner,\n    chainId,\n    nonce,\n  }) => {\n    nonceUsedMarker.markNonceAsUsed({\n      owner,\n      chainId,\n      usedNonce: nonce,\n    });\n  };\n\n  return {\n    markNonceAsUsed,\n  };\n}\n"],"names":["useSignTokenPermit2TransferFrom","t0","$","_c","onSuccess","onError","token","value","spender","enabled","t1","undefined","permit2","isPermit2Supported","useWalletSupportsPermit","queriesEnabled","t2","amount","permit2AllowanceQueryResult","usePermit2Allowance","address","owner","useAccount","t3","network","t4","chainId","nonceQueryResult","usePermit2TransferFromNonce","t5","isLoading","t6","isError","t7","isSuccess","t8","error","t9","isPending","permitFetchingState","isPermitSupported","canUsePermit2","enoughAllowanceForPermit2","isPermitReadyToSign","nonceToUse","t10","signMut","useSignPermit","t11","permitSigningState","nonce","t12","params","_spender","_value","deadline","produceSignatureDeadline","assert","isAddress","permit2Input","type","variant","expiration","producePermitInput","t13","params_0","_input","input","signature","signPermitAsync","compactSignature","serializeCompactSignature","signatureToCompactSignature","parseSignature","encodedArgs","encodePermit2TransferFromMethodArgs","permit2TransferFromEncodedArgs","signedPermitData","signPermit2Async","t14","params_1","input_0","signPermit","signPermit2","paramsNotAvailable","t15","params_2","_spender_0","_value_0","input_1","encodePermitArgs","t16","reset","useMarkPermit2NonceAsUsed","nonceUsedMarker","useMarkNonceAsUsed","markNonceAsUsed","usedNonce"],"mappings":"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"}

package/dist/hooks/permit/hooks/permit2/useTokenFromPermit2TransferFromNonce.d.ts

@@ -0,0 +1,10 @@
+import { Token } from '../../../../tokens/state/types';
+import { UsePermit2TransferFromNonceResult } from './usePermit2TransferFromNonce';
+type UseTokenFromPermitInfoParameters = {
+    enabled?: boolean;
+};
+export declare function useTokenFromPermit2TransferFromNonce({ enabled, }?: UseTokenFromPermitInfoParameters): UsePermit2TransferFromNonceResult & {
+    token: Token;
+};
+export {};
+//# sourceMappingURL=useTokenFromPermit2TransferFromNonce.d.ts.map

package/dist/hooks/permit/hooks/permit2/useTokenFromPermit2TransferFromNonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTokenFromPermit2TransferFromNonce.d.ts","sourceRoot":"","sources":["../../../../../src/hooks/permit/hooks/permit2/useTokenFromPermit2TransferFromNonce.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAEL,KAAK,iCAAiC,EACvC,MAAM,+BAA+B,CAAC;AAEvC,KAAK,gCAAgC,GAAG;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,oCAAoC,CAAC,EACnD,OAAc,GACf,GAAE,gCAAqC,GAAG,iCAAiC,GAAG;IAC7E,KAAK,EAAE,KAAK,CAAC;CACd,CAeA"}