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

package/README.md

@@ -10,9 +10,12 @@ npm install @skalenetwork/privacy-sdk
 
 ## Quick Start
 
+The SDK accepts any signer that implements `{ address, sendTransaction }`. Here's how to initialize with popular web3 libraries:
+
+### With viem
+
 ```typescript
 import { ConfidentialWrapper } from "@skalenetwork/privacy-sdk";
-import { deriveViewerKeypair } from "@skalenetwork/privacy-sdk/utils";
 import { createWalletClient, http } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 
@@ -27,6 +30,56 @@ const token = new ConfidentialWrapper({
     sendTransaction: (tx) => walletClient.sendTransaction({ ...tx, chain: null }),
   },
 });
+```
+
+### With ethers v6
+
+```typescript
+import { ConfidentialWrapper } from "@skalenetwork/privacy-sdk";
+import { Wallet, JsonRpcProvider } from "ethers";
+
+const provider = new JsonRpcProvider(RPC_URL);
+const wallet = new Wallet("0x...", provider);
+
+const token = new ConfidentialWrapper({
+  rpcUrl: RPC_URL,
+  address: WRAPPER_ADDRESS,
+  signer: {
+    address: wallet.address as `0x${string}`,
+    sendTransaction: async (tx) => {
+      const resp = await wallet.sendTransaction(tx);
+      return resp.hash as `0x${string}`;
+    },
+  },
+});
+```
+
+### With web3.js
+
+```typescript
+import { ConfidentialWrapper } from "@skalenetwork/privacy-sdk";
+import Web3 from "web3";
+
+const web3 = new Web3(RPC_URL);
+const account = web3.eth.accounts.privateKeyToAccount("0x...");
+
+const token = new ConfidentialWrapper({
+  rpcUrl: RPC_URL,
+  address: WRAPPER_ADDRESS,
+  signer: {
+    address: account.address as `0x${string}`,
+    sendTransaction: async (tx) => {
+      const receipt = await web3.eth.sendTransaction({ from: account.address, ...tx });
+      return receipt.transactionHash as `0x${string}`;
+    },
+  },
+});
+```
+
+### Usage
+
+```typescript
+import { deriveViewerKeypair } from "@skalenetwork/privacy-sdk/utils";
 
 // Derive viewer keypair from a signed message (do this once per account)
 const sig = await walletClient.signMessage({ message: "SKALE Privacy Viewer Key", account });
@@ -35,11 +88,10 @@ token.setViewerPrivateKey(privateKey);
 await token.registerViewerPublicKey(publicKey);
 
 // Wrap underlying ERC-20 → confidential token (approve underlying first)
-const { ctxHash } = await token.wrap(account.address, 1000n).waitForCtx();
+const { ctxHash: wrapCtxHash } = await token.wrap(account.address, 1000n).waitForCtx();
 
-// Confidential transfer — await for origin hash, .waitForCtx() for the full CTX result
-const hash = await token.transfer(recipient, 500n);
-const { originHash, ctxHash } = await token.transfer(recipient, 500n).waitForCtx();
+// Confidential transfer
+const { ctxHash: transferCtxHash, ctxReceipt } = await token.transfer(recipient, 500n).waitForCtx();
 
 // Decrypt balance
 const balance = await token.decryptBalance();
@@ -50,7 +102,7 @@ await token.unwrap(account.address, 500n).waitForCtx();
 
 ## Docs
 
-- [Concepts](https://github.com/skalenetwork/private-pay/blob/main/packages/privacy-sdk/docs/concepts.md) — CTX lifecycle, viewer keys, CtxPromise pattern
-- [Architecture](https://github.com/skalenetwork/private-pay/blob/main/packages/privacy-sdk/docs/architecture.md) — three-layer design (facades / actions / utils)
-- [API Reference](https://github.com/skalenetwork/private-pay/blob/main/packages/privacy-sdk/docs/api.md) — full method tables for all exports
+- [Concepts](https://github.com/skalenetwork/privacy-sdk/blob/develop/docs/concepts.md) — CTX lifecycle, viewer keys, CtxPromise pattern
+- [Architecture](https://github.com/skalenetwork/privacy-sdk/blob/develop/docs/architecture.md) — three-layer design (facades / actions / utils)
+- [API Reference](https://github.com/skalenetwork/privacy-sdk/blob/develop/docs/api.md) — full method tables for all exports
 

package/dist/actions/index.cjs

@@ -23,13 +23,11 @@ __export(actions_exports, {
   approve: () => approve,
   authorizeHistoricViewForRange: () => authorizeHistoricViewForRange,
   authorizeHistoricViewForTransfer: () => authorizeHistoricViewForTransfer,
-  decryptHistoricTransferData: () => decryptHistoricTransferData,
   decryptTokenBalance: () => decryptTokenBalance,
-  fundCtxBalance: () => fundCtxBalance,
   getCtxBalance: () => getCtxBalance,
-  getCtxFee: () => getCtxFee,
+  getCtxFee: () => getCtxRawCost,
   getTransferId: () => getTransferId,
-  getValueForCtx: () => getValueForCtx,
+  getValueForCtx: () => getCtxOperationCost,
   registerViewerKey: () => registerViewerKey,
   requestTransferDecryption: () => requestTransferDecryption,
   revokeHistoricView: () => revokeHistoricView,
@@ -40,12 +38,17 @@ __export(actions_exports, {
 module.exports = __toCommonJS(actions_exports);
 
 // 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",
@@ -611,6 +614,11 @@ var confidentialWrapperAbi = [
     name: "InvalidDataOffset",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "InvalidInitialization",
+    type: "error"
+  },
   {
     inputs: [],
     name: "InvalidPublicKey",
@@ -639,7 +647,7 @@ var confidentialWrapperAbi = [
   },
   {
     inputs: [],
-    name: "InvalidShortString",
+    name: "InvalidSaltForTransactionValue",
     type: "error"
   },
   {
@@ -685,6 +693,11 @@ var confidentialWrapperAbi = [
     name: "NoViewerRegisteredForHolder",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "NotInitializing",
+    type: "error"
+  },
   {
     inputs: [
       {
@@ -723,17 +736,6 @@ var confidentialWrapperAbi = [
     name: "SafeERC20FailedOperation",
     type: "error"
   },
-  {
-    inputs: [
-      {
-        internalType: "string",
-        name: "str",
-        type: "string"
-      }
-    ],
-    name: "StringTooLong",
-    type: "error"
-  },
   {
     inputs: [
       {
@@ -793,6 +795,11 @@ var confidentialWrapperAbi = [
     name: "ValueWasNotEncryptedCorrectly",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "WrongInitializer",
+    type: "error"
+  },
   {
     inputs: [],
     name: "WrongPlaintextFormat",
@@ -1149,6 +1156,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: [
@@ -1781,6 +1801,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: [
       {
@@ -1850,7 +1894,7 @@ var confidentialWrapperAbi = [
     ],
     name: "encryptedReceiveWithAuthorization",
     outputs: [],
-    stateMutability: "nonpayable",
+    stateMutability: "payable",
     type: "function"
   },
   {
@@ -1979,6 +2023,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",
@@ -2683,7 +2778,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({
@@ -2693,87 +2787,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 fundCtxBalance(config, params) {
-  const data = (0, import_viem.encodeFunctionData)({
-    abi: confidentialWrapperAbi,
-    functionName: "fundWithGasToken",
-    args: [config.signer.address]
-  });
-  return config.signer.sendTransaction({
-    to: config.address,
-    data,
-    value: params.amount
-  });
-}
-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.");
   }
@@ -2787,7 +2872,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
   );
@@ -2795,23 +2880,6 @@ function decryptEciesPayload(encryptedHex, privateKey) {
   const keyMaterial = Uint8Array.from(encryptionKey);
   return (0, import_aes.cbc)(keyMaterial, iv).decrypt(ciphertext);
 }
-function tryDecodeTransferData(encoded) {
-  try {
-    const [from, to, value, timestamp, transferId] = (0, import_viem3.decodeAbiParameters)(
-      [
-        { type: "address" },
-        { type: "address" },
-        { type: "uint256" },
-        { type: "uint256" },
-        { type: "uint256" }
-      ],
-      encoded
-    );
-    return { from, to, value, timestamp, transferId };
-  } catch {
-    return void 0;
-  }
-}
 async function decryptBalance(encryptedHex, privateKey) {
   const plaintext = decryptEciesPayload(encryptedHex, privateKey);
   if (plaintext.length <= 32) {
@@ -2819,40 +2887,21 @@ async function decryptBalance(encryptedHex, privateKey) {
   }
   return bytesToBigInt(plaintext.slice(-32));
 }
-async function decryptTransferData(encryptedHex, privateKey) {
-  const plaintext = decryptEciesPayload(encryptedHex, privateKey);
-  const direct = tryDecodeTransferData((0, import_viem3.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));
-    if (trailingDecoded) {
-      return trailingDecoded;
-    }
-  }
-  throw new Error("Unable to decode decrypted transfer payload as TransferData struct.");
-}
 
 // 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);
+  const encryptedHex = typeof raw === "string" ? raw : (0, import_viem3.bytesToHex)(raw);
+  return decryptBalance(encryptedHex, viewerKey);
 }
-async function decryptHistoricTransferData(params) {
-  return decryptTransferData(params.encryptedData, params.viewerKey);
-}
-async function getTransferId(config, params) {
-  const receipt = await config.publicClient.waitForTransactionReceipt({ hash: params.ctxHash });
-  const events = (0, import_viem4.parseEventLogs)({
+async function getTransferId(config, ctxHash) {
+  const receipt = await config.publicClient.waitForTransactionReceipt({ hash: ctxHash });
+  const events = (0, import_viem3.parseEventLogs)({
     abi: confidentialWrapperAbi,
     logs: receipt.logs,
     eventName: "EncryptedTransfer"
@@ -2869,10 +2918,10 @@ async function getTransferId(config, params) {
 }
 
 // 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) {
@@ -2887,43 +2936,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"
@@ -2953,7 +3002,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]
@@ -2965,9 +3014,7 @@ async function requestTransferDecryption(config, params) {
   approve,
   authorizeHistoricViewForRange,
   authorizeHistoricViewForTransfer,
-  decryptHistoricTransferData,
   decryptTokenBalance,
-  fundCtxBalance,
   getCtxBalance,
   getCtxFee,
   getTransferId,