x402z-shared 0.0.10 → 0.0.12

package/dist/index.d.mts

@@ -119,6 +119,71 @@ declare const confidentialTokenAbi: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "holder";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validAfter";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validBefore";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "encryptedAmountHash";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct FHEToken.UnwrapAuthorization";
+        readonly name: "p";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "sig";
+        readonly type: "bytes";
+    }];
+    readonly name: "unwrapWithAuthorization";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "burntAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "burntAmountCleartext";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "decryptionProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "finalizeUnwrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly anonymous: false;
     readonly inputs: readonly [{
@@ -291,33 +356,6 @@ type TransferQueryOptions = {
 };
 declare function getTransferAmounts(options: TransferQueryOptions): Promise<TransferAmount[]>;
 
-type TokenWriteSigner = RelayerSigner & {
-    writeContract?: (args: {
-        address: `0x${string}`;
-        abi: typeof confidentialTokenAbi;
-        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver";
-        args: readonly unknown[];
-    }) => Promise<`0x${string}`>;
-};
-type ConfidentialTokenOptions = {
-    rpcUrl: string;
-    tokenAddress: `0x${string}`;
-    relayer: RelayerInstance;
-    signer: TokenWriteSigner;
-};
-declare class ConfidentialToken {
-    private readonly rpcUrl;
-    private readonly tokenAddress;
-    private readonly relayer;
-    private readonly signer;
-    constructor(config: ConfidentialTokenOptions);
-    balanceOf(account?: `0x${string}`): Promise<bigint>;
-    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
-    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
-    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
-    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
-}
-
 type ConfidentialPaymentAuthorization = {
     holder: `0x${string}`;
     payee: `0x${string}`;
@@ -328,6 +366,14 @@ type ConfidentialPaymentAuthorization = {
     nonce: `0x${string}`;
     encryptedAmountHash: `0x${string}`;
 };
+type UnwrapAuthorization = {
+    holder: `0x${string}`;
+    to: `0x${string}`;
+    validAfter: number;
+    validBefore: number;
+    nonce: `0x${string}`;
+    encryptedAmountHash: `0x${string}`;
+};
 type ConfidentialPaymentPayload = {
     authorization: ConfidentialPaymentAuthorization;
     signature: `0x${string}`;
@@ -355,4 +401,33 @@ type ConfidentialPaymentInput = {
     nonce?: `0x${string}`;
 };
 
-export { type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };
+type TokenWriteSigner = RelayerSigner & {
+    writeContract?: (args: {
+        address: `0x${string}`;
+        abi: typeof confidentialTokenAbi;
+        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver" | "unwrapWithAuthorization" | "finalizeUnwrap";
+        args: readonly unknown[];
+    }) => Promise<`0x${string}`>;
+};
+type ConfidentialTokenOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    relayer: RelayerInstance;
+    signer: TokenWriteSigner;
+};
+declare class ConfidentialToken {
+    private readonly rpcUrl;
+    private readonly tokenAddress;
+    private readonly relayer;
+    private readonly signer;
+    constructor(config: ConfidentialTokenOptions);
+    balanceOf(account?: `0x${string}`): Promise<bigint>;
+    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
+    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
+    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    unwrapWithAuthorization(authorization: UnwrapAuthorization, encryptedAmountInput: `0x${string}`, inputProof: `0x${string}`, signature: `0x${string}`): Promise<`0x${string}`>;
+    finalizeUnwrap(burntAmount: `0x${string}`, burntAmountCleartext: string | number | bigint, decryptionProof: `0x${string}`): Promise<`0x${string}`>;
+}
+
+export { type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, type UnwrapAuthorization, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };

package/dist/index.d.ts

@@ -119,6 +119,71 @@ declare const confidentialTokenAbi: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "holder";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validAfter";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "uint48";
+            readonly name: "validBefore";
+            readonly type: "uint48";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "encryptedAmountHash";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct FHEToken.UnwrapAuthorization";
+        readonly name: "p";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "encryptedAmountInput";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "inputProof";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "sig";
+        readonly type: "bytes";
+    }];
+    readonly name: "unwrapWithAuthorization";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "burntAmount";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "burntAmountCleartext";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "decryptionProof";
+        readonly type: "bytes";
+    }];
+    readonly name: "finalizeUnwrap";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly anonymous: false;
     readonly inputs: readonly [{
@@ -291,33 +356,6 @@ type TransferQueryOptions = {
 };
 declare function getTransferAmounts(options: TransferQueryOptions): Promise<TransferAmount[]>;
 
-type TokenWriteSigner = RelayerSigner & {
-    writeContract?: (args: {
-        address: `0x${string}`;
-        abi: typeof confidentialTokenAbi;
-        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver";
-        args: readonly unknown[];
-    }) => Promise<`0x${string}`>;
-};
-type ConfidentialTokenOptions = {
-    rpcUrl: string;
-    tokenAddress: `0x${string}`;
-    relayer: RelayerInstance;
-    signer: TokenWriteSigner;
-};
-declare class ConfidentialToken {
-    private readonly rpcUrl;
-    private readonly tokenAddress;
-    private readonly relayer;
-    private readonly signer;
-    constructor(config: ConfidentialTokenOptions);
-    balanceOf(account?: `0x${string}`): Promise<bigint>;
-    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
-    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
-    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
-    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
-}
-
 type ConfidentialPaymentAuthorization = {
     holder: `0x${string}`;
     payee: `0x${string}`;
@@ -328,6 +366,14 @@ type ConfidentialPaymentAuthorization = {
     nonce: `0x${string}`;
     encryptedAmountHash: `0x${string}`;
 };
+type UnwrapAuthorization = {
+    holder: `0x${string}`;
+    to: `0x${string}`;
+    validAfter: number;
+    validBefore: number;
+    nonce: `0x${string}`;
+    encryptedAmountHash: `0x${string}`;
+};
 type ConfidentialPaymentPayload = {
     authorization: ConfidentialPaymentAuthorization;
     signature: `0x${string}`;
@@ -355,4 +401,33 @@ type ConfidentialPaymentInput = {
     nonce?: `0x${string}`;
 };
 
-export { type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };
+type TokenWriteSigner = RelayerSigner & {
+    writeContract?: (args: {
+        address: `0x${string}`;
+        abi: typeof confidentialTokenAbi;
+        functionName: "confidentialTransfer" | "wrap" | "unwrap" | "setObserver" | "unwrapWithAuthorization" | "finalizeUnwrap";
+        args: readonly unknown[];
+    }) => Promise<`0x${string}`>;
+};
+type ConfidentialTokenOptions = {
+    rpcUrl: string;
+    tokenAddress: `0x${string}`;
+    relayer: RelayerInstance;
+    signer: TokenWriteSigner;
+};
+declare class ConfidentialToken {
+    private readonly rpcUrl;
+    private readonly tokenAddress;
+    private readonly relayer;
+    private readonly signer;
+    constructor(config: ConfidentialTokenOptions);
+    balanceOf(account?: `0x${string}`): Promise<bigint>;
+    setObserver(account: `0x${string}`, observer: `0x${string}`): Promise<`0x${string}`>;
+    transfer(to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    wrap(to: `0x${string}`, amount: string | number | bigint): Promise<`0x${string}`>;
+    unwrap(from: `0x${string}`, to: `0x${string}`, amount: number): Promise<`0x${string}`>;
+    unwrapWithAuthorization(authorization: UnwrapAuthorization, encryptedAmountInput: `0x${string}`, inputProof: `0x${string}`, signature: `0x${string}`): Promise<`0x${string}`>;
+    finalizeUnwrap(burntAmount: `0x${string}`, burntAmountCleartext: string | number | bigint, decryptionProof: `0x${string}`): Promise<`0x${string}`>;
+}
+
+export { type ConfidentialErrorCode, type ConfidentialPaymentAuthorization, type ConfidentialPaymentInput, type ConfidentialPaymentPayload, type ConfidentialRequirementsExtra, ConfidentialToken, type ConfidentialTokenOptions, type RelayerInstance, type RelayerSigner, type TransferAmount, type TransferQueryOptions, type UnwrapAuthorization, confidentialErrorCodes, confidentialPaymentTypes, confidentialTokenAbi, createEncryptedAmountInput, createNonce, createRelayer, decryptEuint64, getTransferAmounts, hashEncryptedAmountInput, normalizeAmount, publicDecrypt };

package/dist/index.js

@@ -97,6 +97,41 @@ var confidentialTokenAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "holder", type: "address" },
+          { internalType: "address", name: "to", type: "address" },
+          { internalType: "uint48", name: "validAfter", type: "uint48" },
+          { internalType: "uint48", name: "validBefore", type: "uint48" },
+          { internalType: "bytes32", name: "nonce", type: "bytes32" },
+          { internalType: "bytes32", name: "encryptedAmountHash", type: "bytes32" }
+        ],
+        internalType: "struct FHEToken.UnwrapAuthorization",
+        name: "p",
+        type: "tuple"
+      },
+      { internalType: "bytes", name: "encryptedAmountInput", type: "bytes" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "bytes", name: "sig", type: "bytes" }
+    ],
+    name: "unwrapWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "burntAmount", type: "bytes32" },
+      { internalType: "uint64", name: "burntAmountCleartext", type: "uint64" },
+      { internalType: "bytes", name: "decryptionProof", type: "bytes" }
+    ],
+    name: "finalizeUnwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     anonymous: false,
     inputs: [
@@ -520,6 +555,41 @@ var ConfidentialToken = class {
       args: [fromAddress, toAddress, handle, inputProof]
     });
   }
+  async unwrapWithAuthorization(authorization, encryptedAmountInput, inputProof, signature) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const holder = assertAddress(authorization.holder, "holder address");
+    const to = assertAddress(authorization.to, "to address");
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrapWithAuthorization",
+      args: [
+        {
+          holder,
+          to,
+          validAfter: authorization.validAfter,
+          validBefore: authorization.validBefore,
+          nonce: authorization.nonce,
+          encryptedAmountHash: authorization.encryptedAmountHash
+        },
+        encryptedAmountInput,
+        inputProof,
+        signature
+      ]
+    });
+  }
+  async finalizeUnwrap(burntAmount, burntAmountCleartext, decryptionProof) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const normalizedAmount = BigInt(normalizeAmount(burntAmountCleartext));
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "finalizeUnwrap",
+      args: [burntAmount, normalizedAmount, decryptionProof]
+    });
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -59,6 +59,41 @@ var confidentialTokenAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "holder", type: "address" },
+          { internalType: "address", name: "to", type: "address" },
+          { internalType: "uint48", name: "validAfter", type: "uint48" },
+          { internalType: "uint48", name: "validBefore", type: "uint48" },
+          { internalType: "bytes32", name: "nonce", type: "bytes32" },
+          { internalType: "bytes32", name: "encryptedAmountHash", type: "bytes32" }
+        ],
+        internalType: "struct FHEToken.UnwrapAuthorization",
+        name: "p",
+        type: "tuple"
+      },
+      { internalType: "bytes", name: "encryptedAmountInput", type: "bytes" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "bytes", name: "sig", type: "bytes" }
+    ],
+    name: "unwrapWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "burntAmount", type: "bytes32" },
+      { internalType: "uint64", name: "burntAmountCleartext", type: "uint64" },
+      { internalType: "bytes", name: "decryptionProof", type: "bytes" }
+    ],
+    name: "finalizeUnwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     anonymous: false,
     inputs: [
@@ -482,6 +517,41 @@ var ConfidentialToken = class {
       args: [fromAddress, toAddress, handle, inputProof]
     });
   }
+  async unwrapWithAuthorization(authorization, encryptedAmountInput, inputProof, signature) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const holder = assertAddress(authorization.holder, "holder address");
+    const to = assertAddress(authorization.to, "to address");
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "unwrapWithAuthorization",
+      args: [
+        {
+          holder,
+          to,
+          validAfter: authorization.validAfter,
+          validBefore: authorization.validBefore,
+          nonce: authorization.nonce,
+          encryptedAmountHash: authorization.encryptedAmountHash
+        },
+        encryptedAmountInput,
+        inputProof,
+        signature
+      ]
+    });
+  }
+  async finalizeUnwrap(burntAmount, burntAmountCleartext, decryptionProof) {
+    const tokenAddress = assertAddress(this.tokenAddress, "token address");
+    const normalizedAmount = BigInt(normalizeAmount(burntAmountCleartext));
+    const writeContract = requireWriteContract(this.signer);
+    return writeContract({
+      address: tokenAddress,
+      abi: confidentialTokenAbi,
+      functionName: "finalizeUnwrap",
+      args: [burntAmount, normalizedAmount, decryptionProof]
+    });
+  }
 };
 export {
   ConfidentialToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402z-shared",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",