@pyratzlabs/react-fhevm-utils 3.2.2 → 3.3.0

package/dist/client/hooks/useEncryptedBatchTransfer.d.ts

@@ -6,6 +6,7 @@ interface BatchTransferData {
     to: Address;
     encryptedAmount: Address;
     inputProof: Address;
+    retryFor: bigint;
 }
 export declare const useEncryptedBatchTransfer: ({ batcherAddress }: Props) => {
     batchTransfer: (tokenAddress: Address, batchTransferData: BatchTransferData[], fees?: bigint) => void;

package/dist/client/hooks/useEncryptedBatchTransfer.js

@@ -1,6 +1,8 @@
 import { usePerformTransaction } from "./usePerformTransaction";
 import { TRANSFER_BATCHER_ABI } from "../../types/ABI/TransferBatcher.abi";
+import { useAccount } from "wagmi";
 export const useEncryptedBatchTransfer = ({ batcherAddress }) => {
+    const { address } = useAccount();
     const { perform, isLoading, isFailed, isSuccess, error } = usePerformTransaction({
         abi: TRANSFER_BATCHER_ABI,
         address: batcherAddress,
@@ -9,8 +11,10 @@ export const useEncryptedBatchTransfer = ({ batcherAddress }) => {
     const batchTransfer = (tokenAddress, batchTransferData, fees) => {
         if (!fees)
             throw new Error("BATCH TRANSFER: Fees must be provided");
+        if (!address)
+            throw new Error("BATCH TRANSFER: User address is not available");
         perform({
-            args: [tokenAddress, batchTransferData],
+            args: [tokenAddress, address, batchTransferData],
             value: fees,
         });
     };

package/dist/client/hooks/useFinalizeUnwrap.d.ts

@@ -3,7 +3,7 @@ interface Props {
     wrapper: Address;
 }
 export declare const useFinalizeUnwrap: ({ wrapper }: Props) => {
-    finalizeUnwrap: (requestId: bigint, unwrapStartedAmounts: Address[], clearValues: Address, decryptionProof: Address) => void;
+    finalizeUnwrap: (requestId: bigint, clearValues: Address, decryptionProof: Address) => void;
     isFailed: boolean;
     isLoading: boolean;
     isSuccess: boolean;

package/dist/client/hooks/useFinalizeUnwrap.js

@@ -8,11 +8,11 @@ export const useFinalizeUnwrap = ({ wrapper }) => {
         address: wrapper,
         functionName: "finalizeUnwrap",
     });
-    const finalizeUnwrap = (requestId, unwrapStartedAmounts, clearValues, decryptionProof) => {
+    const finalizeUnwrap = (requestId, clearValues, decryptionProof) => {
         if (!address)
             throw new Error("UNWRAP: User is not connected");
         perform({
-            args: [requestId, unwrapStartedAmounts, [clearValues, decryptionProof]],
+            args: [requestId, clearValues, decryptionProof],
         });
     };
     return { finalizeUnwrap, isFailed, isLoading, isSuccess };

package/dist/client/hooks/useUnwrap.js

@@ -15,7 +15,7 @@ export const useUnwrap = ({ encryptedErc20 }) => {
             throw new Error("UNWRAP: User is not connected");
         const handle = toHexString(handles[0]);
         const proof = toHexString(inputProof);
-        const data = encodeAbiParameters([{ type: "address" }, { type: "bytes" }], [address, "0x"]);
+        const data = encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "bytes" }], [address, address, "0x"]);
         perform({
             args: [wrapperAddress, handle, proof, data],
         });

package/dist/types/ABI/TransferBatcher.abi.d.ts

@@ -1,12 +1,52 @@
 export declare const TRANSFER_BATCHER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "contract AdminProvider";
+        readonly name: "adminProvider_";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "holder";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "ERC7984UnauthorizedSpender";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EmptyTransferArray";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "FeeTransferFailed";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InsufficientFee";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OnlyOriginalSenderCanRetry";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ZamaProtocolUnsupported";
+    readonly type: "error";
+}, {
     readonly anonymous: false;
     readonly inputs: readonly [{
-        readonly indexed: false;
+        readonly indexed: true;
         readonly internalType: "address";
         readonly name: "cToken";
         readonly type: "address";
     }, {
-        readonly indexed: false;
+        readonly indexed: true;
         readonly internalType: "address";
         readonly name: "sender";
         readonly type: "address";
@@ -20,14 +60,58 @@ export declare const TRANSFER_BATCHER_ABI: readonly [{
         readonly internalType: "uint256";
         readonly name: "endTxId";
         readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "fee";
+        readonly type: "uint256";
     }];
     readonly name: "BatchTransfer";
     readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "cToken";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "originalTxId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "retryTxId";
+        readonly type: "uint256";
+    }];
+    readonly name: "RetryTransfer";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "adminProvider";
+    readonly outputs: readonly [{
+        readonly internalType: "contract AdminProvider";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "contract RegulatedERC7984Upgradeable";
         readonly name: "cToken";
         readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
     }, {
         readonly components: readonly [{
             readonly internalType: "address";
@@ -41,6 +125,10 @@ export declare const TRANSFER_BATCHER_ABI: readonly [{
             readonly internalType: "bytes";
             readonly name: "inputProof";
             readonly type: "bytes";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "retryFor";
+            readonly type: "uint256";
         }];
         readonly internalType: "struct ERC7984TransferBatcher.ConfidentialTransferInput[]";
         readonly name: "transfers";
@@ -48,16 +136,34 @@ export declare const TRANSFER_BATCHER_ABI: readonly [{
     }];
     readonly name: "confidentialBatchTransfer";
     readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
+    readonly stateMutability: "payable";
     readonly type: "function";
 }, {
     readonly inputs: readonly [];
-    readonly name: "protocolId";
+    readonly name: "confidentialProtocolId";
     readonly outputs: readonly [{
         readonly internalType: "uint256";
         readonly name: "";
         readonly type: "uint256";
     }];
-    readonly stateMutability: "pure";
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "cToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "txId";
+        readonly type: "uint256";
+    }];
+    readonly name: "txIdToSender";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
     readonly type: "function";
 }];

package/dist/types/ABI/TransferBatcher.abi.js

@@ -1,15 +1,67 @@
 export const TRANSFER_BATCHER_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "contract AdminProvider",
+                name: "adminProvider_",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "holder",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "spender",
+                type: "address",
+            },
+        ],
+        name: "ERC7984UnauthorizedSpender",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "EmptyTransferArray",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "FeeTransferFailed",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "InsufficientFee",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "OnlyOriginalSenderCanRetry",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "ZamaProtocolUnsupported",
+        type: "error",
+    },
     {
         anonymous: false,
         inputs: [
             {
-                indexed: false,
+                indexed: true,
                 internalType: "address",
                 name: "cToken",
                 type: "address",
             },
             {
-                indexed: false,
+                indexed: true,
                 internalType: "address",
                 name: "sender",
                 type: "address",
@@ -26,10 +78,60 @@ export const TRANSFER_BATCHER_ABI = [
                 name: "endTxId",
                 type: "uint256",
             },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "fee",
+                type: "uint256",
+            },
         ],
         name: "BatchTransfer",
         type: "event",
     },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "cToken",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "originalTxId",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "retryTxId",
+                type: "uint256",
+            },
+        ],
+        name: "RetryTransfer",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "adminProvider",
+        outputs: [
+            {
+                internalType: "contract AdminProvider",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
     {
         inputs: [
             {
@@ -37,6 +139,11 @@ export const TRANSFER_BATCHER_ABI = [
                 name: "cToken",
                 type: "address",
             },
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
             {
                 components: [
                     {
@@ -54,6 +161,11 @@ export const TRANSFER_BATCHER_ABI = [
                         name: "inputProof",
                         type: "bytes",
                     },
+                    {
+                        internalType: "uint256",
+                        name: "retryFor",
+                        type: "uint256",
+                    },
                 ],
                 internalType: "struct ERC7984TransferBatcher.ConfidentialTransferInput[]",
                 name: "transfers",
@@ -62,12 +174,12 @@ export const TRANSFER_BATCHER_ABI = [
         ],
         name: "confidentialBatchTransfer",
         outputs: [],
-        stateMutability: "nonpayable",
+        stateMutability: "payable",
         type: "function",
     },
     {
         inputs: [],
-        name: "protocolId",
+        name: "confidentialProtocolId",
         outputs: [
             {
                 internalType: "uint256",
@@ -75,7 +187,31 @@ export const TRANSFER_BATCHER_ABI = [
                 type: "uint256",
             },
         ],
-        stateMutability: "pure",
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "cToken",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "txId",
+                type: "uint256",
+            },
+        ],
+        name: "txIdToSender",
+        outputs: [
+            {
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
         type: "function",
     },
 ];