@skalenetwork/privacy-sdk 0.1.0-develop.0 → 0.1.0-develop.2

package/dist/index.cjs

@@ -27,16 +27,21 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/ConfidentialToken.ts
-var import_viem7 = require("viem");
+var import_viem6 = require("viem");
 var import_bite = require("@skalenetwork/bite");
 
 // src/actions/transfers.ts
-var import_viem2 = require("viem");
+var import_viem = require("viem");
 
 // src/abi/confidentialWrapper.ts
 var confidentialWrapperAbi = [
   {
     inputs: [
+      {
+        internalType: "bool",
+        name: "proxyMode",
+        type: "bool"
+      },
       {
         internalType: "contract IERC20Metadata",
         name: "underlyingToken",
@@ -602,6 +607,11 @@ var confidentialWrapperAbi = [
     name: "InvalidDataOffset",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "InvalidInitialization",
+    type: "error"
+  },
   {
     inputs: [],
     name: "InvalidPublicKey",
@@ -630,7 +640,7 @@ var confidentialWrapperAbi = [
   },
   {
     inputs: [],
-    name: "InvalidShortString",
+    name: "InvalidSaltForTransactionValue",
     type: "error"
   },
   {
@@ -676,6 +686,11 @@ var confidentialWrapperAbi = [
     name: "NoViewerRegisteredForHolder",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "NotInitializing",
+    type: "error"
+  },
   {
     inputs: [
       {
@@ -714,17 +729,6 @@ var confidentialWrapperAbi = [
     name: "SafeERC20FailedOperation",
     type: "error"
   },
-  {
-    inputs: [
-      {
-        internalType: "string",
-        name: "str",
-        type: "string"
-      }
-    ],
-    name: "StringTooLong",
-    type: "error"
-  },
   {
     inputs: [
       {
@@ -784,6 +788,11 @@ var confidentialWrapperAbi = [
     name: "ValueWasNotEncryptedCorrectly",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "WrongInitializer",
+    type: "error"
+  },
   {
     inputs: [],
     name: "WrongPlaintextFormat",
@@ -1140,6 +1149,19 @@ var confidentialWrapperAbi = [
     name: "HistoricViewTransferIdRevoked",
     type: "event"
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "version",
+        type: "uint64"
+      }
+    ],
+    name: "Initialized",
+    type: "event"
+  },
   {
     anonymous: false,
     inputs: [
@@ -1772,6 +1794,30 @@ var confidentialWrapperAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "holder",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "encryptValue",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "encryptedValue",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -1841,7 +1887,7 @@ var confidentialWrapperAbi = [
     ],
     name: "encryptedReceiveWithAuthorization",
     outputs: [],
-    stateMutability: "nonpayable",
+    stateMutability: "payable",
     type: "function"
   },
   {
@@ -1970,6 +2016,57 @@ var confidentialWrapperAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract IERC20Metadata",
+        name: "underlyingToken",
+        type: "address"
+      },
+      {
+        internalType: "string",
+        name: "version_",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "initialAuthority",
+        type: "address"
+      }
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [],
     name: "isConsumingScheduledOp",
@@ -2674,7 +2771,6 @@ var confidentialWrapperAbi = [
 ];
 
 // src/actions/funding.ts
-var import_viem = require("viem");
 var CTX_RESERVE_THRESHOLD = 1n;
 async function getCtxBalance(config) {
   return await config.publicClient.readContract({
@@ -2684,75 +2780,78 @@ async function getCtxBalance(config) {
     args: [config.signer.address]
   });
 }
-async function getCtxFee(config) {
+async function getCtxRawCost(config) {
   return await config.publicClient.readContract({
     address: config.address,
     abi: confidentialWrapperAbi,
     functionName: "callbackFee"
   });
 }
-async function getValueForCtx(config) {
-  const [fee, balance] = await Promise.all([getCtxFee(config), getCtxBalance(config)]);
+async function getCtxOperationCost(config) {
+  const [fee, balance] = await Promise.all([getCtxRawCost(config), getCtxBalance(config)]);
   const topUp = CTX_RESERVE_THRESHOLD * fee - balance;
   return fee + (topUp > 0n ? topUp : 0n);
 }
 
 // src/actions/transfers.ts
-async function approve(config, params) {
-  const data = (0, import_viem2.encodeFunctionData)({
+async function approve(config, spender, amount) {
+  const data = (0, import_viem.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "approve",
-    args: [params.spender, params.amount]
+    args: [spender, amount]
   });
   return config.signer.sendTransaction({ to: config.address, data });
 }
-async function transfer(config, params) {
-  const value = await getValueForCtx(config);
-  const valueHex = (0, import_viem2.toHex)(params.amount, { size: 32 });
+async function transfer(config, to, amount) {
+  const value = await getCtxOperationCost(config);
+  const valueHex = (0, import_viem.encodeAbiParameters)(
+    [{ type: "address" }, { type: "uint256" }],
+    [config.signer.address, amount]
+  );
   const encryptedValue = await config.bite.encryptMessageForCTX(valueHex, config.address);
-  const data = (0, import_viem2.encodeFunctionData)({
+  const data = (0, import_viem.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "encryptedTransfer",
-    args: [params.to, encryptedValue]
+    args: [to, encryptedValue]
   });
   return config.signer.sendTransaction({ to: config.address, data, value });
 }
-async function wrap(config, params) {
-  const value = await getValueForCtx(config);
-  const data = (0, import_viem2.encodeFunctionData)({
+async function wrap(config, receiver, amount) {
+  const value = await getCtxOperationCost(config);
+  const data = (0, import_viem.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "depositForWithGasToken",
-    args: [params.receiver, params.amount]
+    args: [receiver, amount]
   });
   return config.signer.sendTransaction({ to: config.address, data, value });
 }
-async function unwrap(config, params) {
-  const value = await getValueForCtx(config);
-  const data = (0, import_viem2.encodeFunctionData)({
+async function unwrap(config, receiver, amount) {
+  const value = await getCtxOperationCost(config);
+  const data = (0, import_viem.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "withdrawToWithGasToken",
-    args: [params.receiver, params.amount]
+    args: [receiver, amount]
   });
   return config.signer.sendTransaction({ to: config.address, data, value });
 }
 
 // src/actions/decrypt.ts
-var import_viem4 = require("viem");
+var import_viem3 = require("viem");
 
 // src/utils/crypto.ts
 var import_secp256k1 = require("@noble/curves/secp256k1");
 var import_sha256 = require("@noble/hashes/sha256");
 var import_aes = require("@noble/ciphers/aes");
-var import_viem3 = require("viem");
+var import_viem2 = require("viem");
 function bytesToBigInt(bytes) {
   if (bytes.length === 0) {
     return 0n;
   }
-  const hexValue = (0, import_viem3.bytesToHex)(bytes);
+  const hexValue = (0, import_viem2.bytesToHex)(bytes);
   return BigInt(hexValue === "0x" ? "0x0" : hexValue);
 }
 function decryptEciesPayload(encryptedHex, privateKey) {
-  const payload = (0, import_viem3.hexToBytes)(encryptedHex);
+  const payload = (0, import_viem2.hexToBytes)(encryptedHex);
   if (payload.length < 65) {
     throw new Error("Encrypted payload is too short.");
   }
@@ -2766,7 +2865,7 @@ function decryptEciesPayload(encryptedHex, privateKey) {
     throw new Error("Invalid AES-CBC ciphertext length.");
   }
   const sharedSecret = import_secp256k1.secp256k1.getSharedSecret(
-    (0, import_viem3.hexToBytes)(privateKey),
+    (0, import_viem2.hexToBytes)(privateKey),
     ephemeralCompressedPublicKey,
     true
   );
@@ -2776,7 +2875,7 @@ function decryptEciesPayload(encryptedHex, privateKey) {
 }
 function tryDecodeTransferData(encoded) {
   try {
-    const [from, to, value, timestamp, transferId] = (0, import_viem3.decodeAbiParameters)(
+    const [from, to, value, timestamp, transferId] = (0, import_viem2.decodeAbiParameters)(
       [
         { type: "address" },
         { type: "address" },
@@ -2800,14 +2899,14 @@ async function decryptBalance(encryptedHex, privateKey) {
 }
 async function decryptTransferData(encryptedHex, privateKey) {
   const plaintext = decryptEciesPayload(encryptedHex, privateKey);
-  const direct = tryDecodeTransferData((0, import_viem3.bytesToHex)(plaintext));
+  const direct = tryDecodeTransferData((0, import_viem2.bytesToHex)(plaintext));
   if (direct) {
     return direct;
   }
   const structSizeBytes = 32 * 5;
   if (plaintext.length >= structSizeBytes) {
     const trailing = plaintext.slice(-structSizeBytes);
-    const trailingDecoded = tryDecodeTransferData((0, import_viem3.bytesToHex)(trailing));
+    const trailingDecoded = tryDecodeTransferData((0, import_viem2.bytesToHex)(trailing));
     if (trailingDecoded) {
       return trailingDecoded;
     }
@@ -2816,25 +2915,22 @@ async function decryptTransferData(encryptedHex, privateKey) {
 }
 
 // src/actions/decrypt.ts
-async function decryptTokenBalance(config, params) {
+async function decryptTokenBalance(config, viewerKey) {
   const raw = await config.publicClient.readContract({
     address: config.address,
     abi: confidentialWrapperAbi,
     functionName: "encryptedBalanceOf",
     args: [config.signer.address]
   });
-  const encryptedHex = typeof raw === "string" ? raw : (0, import_viem4.bytesToHex)(raw);
-  return decryptBalance(encryptedHex, params.viewerKey);
-}
-async function decryptHistoricTransferData(params) {
-  return decryptTransferData(params.encryptedData, params.viewerKey);
+  const encryptedHex = typeof raw === "string" ? raw : (0, import_viem3.bytesToHex)(raw);
+  return decryptBalance(encryptedHex, viewerKey);
 }
 
 // src/actions/access.ts
-var import_viem6 = require("viem");
+var import_viem5 = require("viem");
 
 // src/utils/viewerKey.ts
-var import_viem5 = require("viem");
+var import_viem4 = require("viem");
 var import_utils = require("viem/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
 function parsePublicKeyCoordinates(publicKey) {
@@ -2849,43 +2945,43 @@ function parsePublicKeyCoordinates(publicKey) {
 }
 
 // src/actions/access.ts
-async function registerViewerKey(config, params) {
-  const { x, y } = parsePublicKeyCoordinates(params.publicKey);
-  const data = (0, import_viem6.encodeFunctionData)({
+async function registerViewerKey(config, publicKey) {
+  const { x, y } = parsePublicKeyCoordinates(publicKey);
+  const data = (0, import_viem5.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "setViewerPublicKey",
     args: [{ x, y }]
   });
   return config.signer.sendTransaction({ to: config.address, data });
 }
-async function authorizeHistoricViewForRange(config, params) {
-  const data = (0, import_viem6.encodeFunctionData)({
+async function authorizeHistoricViewForRange(config, address, fromTimestamp, toTimestamp) {
+  const data = (0, import_viem5.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "authorizeHistoricViewTimeRange",
-    args: [params.address, params.fromTimestamp, params.toTimestamp]
+    args: [address, fromTimestamp, toTimestamp]
   });
   return config.signer.sendTransaction({ to: config.address, data });
 }
-async function authorizeHistoricViewForTransfer(config, params) {
-  const data = (0, import_viem6.encodeFunctionData)({
+async function authorizeHistoricViewForTransfer(config, address, transferId) {
+  const data = (0, import_viem5.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "authorizeHistoricViewTransferId",
-    args: [params.address, params.transferId]
+    args: [address, transferId]
   });
   return config.signer.sendTransaction({ to: config.address, data });
 }
-async function revokeHistoricView(config, params) {
-  const data = (0, import_viem6.encodeFunctionData)({
+async function revokeHistoricView(config, address) {
+  const data = (0, import_viem5.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "removeHistoricViewAuth",
-    args: [params.address]
+    args: [address]
   });
   return config.signer.sendTransaction({ to: config.address, data });
 }
-async function requestTransferDecryption(config, params) {
-  const value = await getValueForCtx(config);
-  const receipt = await config.publicClient.waitForTransactionReceipt({ hash: params.ctxHash });
-  const events = (0, import_viem6.parseEventLogs)({
+async function requestTransferDecryption(config, ctxHash) {
+  const value = await getCtxOperationCost(config);
+  const receipt = await config.publicClient.waitForTransactionReceipt({ hash: ctxHash });
+  const events = (0, import_viem5.parseEventLogs)({
     abi: confidentialWrapperAbi,
     logs: receipt.logs,
     eventName: "EncryptedTransfer"
@@ -2915,7 +3011,7 @@ async function requestTransferDecryption(config, params) {
   if (!canDecrypt) {
     throw new Error("Viewer is not authorized to decrypt this historic transfer.");
   }
-  const data = (0, import_viem6.encodeFunctionData)({
+  const data = (0, import_viem5.encodeFunctionData)({
     abi: confidentialWrapperAbi,
     functionName: "requestDecryptHistoricTransferFor",
     args: [encryptedData, viewerAddress]
@@ -2998,7 +3094,7 @@ var ConfidentialToken = class {
     this.address = config.address;
     this.signer = config.signer;
     this.viewerPrivateKey = config.viewerPrivateKey;
-    this.client = (0, import_viem7.createPublicClient)({ transport: (0, import_viem7.http)(config.rpcUrl) });
+    this.client = (0, import_viem6.createPublicClient)({ transport: (0, import_viem6.http)(config.rpcUrl) });
     this.bite = new import_bite.BITE(config.rpcUrl);
   }
   get actionConfig() {
@@ -3058,44 +3154,42 @@ var ConfidentialToken = class {
     if (!this.viewerPrivateKey) {
       throw new Error("Viewer key is required to decrypt balance.");
     }
-    return decryptTokenBalance(this.actionConfig, { viewerKey: this.viewerPrivateKey });
+    return decryptTokenBalance(this.actionConfig, this.viewerPrivateKey);
   }
   // --- Standard ERC-20 writes ---
   async approve(spender, amount) {
-    return approve(this.actionConfig, { spender, amount });
+    return approve(this.actionConfig, spender, amount);
   }
   // --- Privacy-specific writes ---
   transfer(to, amount) {
-    return createCtxPromise(
-      transfer(this.actionConfig, { to, amount }),
-      this.client
-    );
+    return createCtxPromise(transfer(this.actionConfig, to, amount), this.client);
   }
   // --- Viewer key management ---
   async registerViewerPublicKey(publicKey) {
-    return registerViewerKey(this.actionConfig, { publicKey });
+    return registerViewerKey(this.actionConfig, publicKey);
   }
   async authorizeHistoricViewForRange(address, fromTimestamp, toTimestamp) {
-    return authorizeHistoricViewForRange(this.actionConfig, {
+    return authorizeHistoricViewForRange(
+      this.actionConfig,
       address,
       fromTimestamp,
       toTimestamp
-    });
+    );
   }
   async authorizeHistoricViewForTransfer(address, transferId) {
-    return authorizeHistoricViewForTransfer(this.actionConfig, { address, transferId });
+    return authorizeHistoricViewForTransfer(this.actionConfig, address, transferId);
   }
   async revokeHistoricView(address) {
-    return revokeHistoricView(this.actionConfig, { address });
+    return revokeHistoricView(this.actionConfig, address);
   }
   // --- Decrypt / history ---
   async requestTransferDecryption(ctxHash) {
     if (!this.viewerPrivateKey) {
       throw new Error("Viewer key is required to decrypt transfer data.");
     }
-    const txHash = await requestTransferDecryption(this.actionConfig, { ctxHash });
+    const txHash = await requestTransferDecryption(this.actionConfig, ctxHash);
     const { ctxReceipt } = await waitForCtx(txHash, this.client);
-    const events = (0, import_viem7.parseEventLogs)({
+    const events = (0, import_viem6.parseEventLogs)({
       abi: confidentialWrapperAbi,
       logs: ctxReceipt.logs,
       eventName: "ReEncryptedTransfer"
@@ -3108,7 +3202,7 @@ var ConfidentialToken = class {
     if (!encryptedData) {
       throw new Error("CTX receipt does not contain a ReEncryptedTransfer event.");
     }
-    return decryptHistoricTransferData({ encryptedData, viewerKey: this.viewerPrivateKey });
+    return decryptTransferData(encryptedData, this.viewerPrivateKey);
   }
 };
 
@@ -3122,10 +3216,10 @@ var ConfidentialWrapper = class extends ConfidentialToken {
     });
   }
   wrap(receiver, amount) {
-    return createCtxPromise(wrap(this.actionConfig, { receiver, amount }), this.client);
+    return createCtxPromise(wrap(this.actionConfig, receiver, amount), this.client);
   }
   unwrap(receiver, amount) {
-    return createCtxPromise(unwrap(this.actionConfig, { receiver, amount }), this.client);
+    return createCtxPromise(unwrap(this.actionConfig, receiver, amount), this.client);
   }
 };
 // Annotate the CommonJS export names for ESM import in node: