@inco/js 0.1.32 → 0.1.33

package/README.md

@@ -4,7 +4,7 @@ The @inco/js package contains the TypeScript SDK for creating dapps built on Inc
 
 ## Current Status: Active Development
 
-The SDK is currently going through active development, to support all new features that Inco offers. As such, do expect breaking changes in subsequent releases, which will be documented in the [CHANGELOG](./CHANGELOG.md). The current state of `@inco/js` includes all low-level blocks to build functional dapps, but an improved public-facing API is also in the works.
+The SDK is currently going through active development, to support all new features that Inco offers. As such, do expect breaking changes in subsequent releases, which will be documented in the [CHANGELOG](./CHANGELOG.md).
 
 ## Install
 
@@ -29,76 +29,47 @@ A typical usage of `@inco/js` includes 3 steps:
 ### 1. Encrypt a value
 
 ```ts
-import { getSupportedChain, getViemChain, handleTypes, HexString } from '@inco/js';
-import { EciesScheme, encryptionSchemes, PlaintextWithContextOf } from '@inco/js/encryption';
-import {
-  decodeSecp256k1PublicKey,
-  generateSecp256k1Keypair,
-  getActiveLightningDeployment,
-  getEciesEncryptor,
-} from '@inco/js/lite';
-import { createWalletClient, hexToBytes } from 'viem';
-
-// Setup. Do it once at initialization.
-const chain = getSupportedChain('baseSepolia');
-const lightningConfig = getActiveLightningDeployment(chain);
+import { getViemChain, supportedChains } from '@inco/js';
+import { Lightning } from '@inco/js/lite';
+import { createWalletClient } from 'viem';
+
+// Setup: do it once at initialization
+const chainId = supportedChains.baseSepolia;
+const zap = Lightning.latest('testnet', chainId); // Connect to Inco's latest public testnet
 const walletClient = createWalletClient({
-    chain: getViemChain(chain),
-    account: /* Choose your account */,
-    transport: /* Choose your transport */,
+  chain: getViemChain(chainId),
+  account: /* Choose your account, e.g. from window.ethereum */,
+  transport: /* Choose your transport, e.g. from Alchemy */,
 });
-const dappAddress = '0x0000000000000000000000000000000000000000'; // Put your contract address here
-
-// Define plaintext, along with context needed for verification.
-const plaintext = 42n; // bigint
-const plaintextWithContext: PlaintextWithContextOf<EciesScheme, typeof handleTypes.euint256> = {
-    plaintext: {
-        scheme: encryptionSchemes.ecies,
-        value: plaintext,
-        type: handleTypes.euint256,
-    },
-    context: {
-        hostChainId: BigInt(chain.id),
-        aclAddress: lightningConfig.executorAddress,
-        userAddress: walletClient.account.address,
-        contractAddress: dappAddress,
-    },
-};
-
-// Encrypt.
-const ephemeralKeypair = await generateSecp256k1Keypair();
-const eciesPubKey = decodeSecp256k1PublicKey(hexToBytes(lightningConfig.eciesPublicKey));
-const encryptor = getEciesEncryptor({
-    scheme: encryptionSchemes.ecies,
-    pubKeyA: eciesPubKey,
-    privKeyB: ephemeralKeypair,
+const dappAddress = '0x00000000000000000000000000000000deadbeef'; // Put your contract address here
+
+// Encrypt the plaintext value
+const plaintext = 42;
+const ciphertext = await zap.encrypt(plaintext, {
+  accountAddress: walletClient.account.address,
+  dappAddress,
 });
-const { ciphertext } = await encryptor(plaintextWithContext);
-console.log(ciphertext.value); // Will print the encrypted value as hex
+
+console.log(ciphertext); // A long hex string representing the encrypted value
 ```
 
 ### 2. Post the ciphertext to the contract
 
-For this step, there is nothing specific to the `@inco/js`. We recommend continue using [viem](https://viem.sh). In particular, take a look at their [`writeContract`](https://viem.sh/docs/contract/writeContract) methods to make a transaction on chain, and pass in the `ciphertext.value` from the previous step as the input ciphertext.
+This step does not require any specific `@inco/js` functionality. We recommend using [viem](https://viem.sh) to interact with the blockchain. Specifically, use the [`writeContract`](https://viem.sh/docs/contract/writeContract) method to submit transactions. Pass the `ciphertext` from the previous encryption step as the input ciphertext parameter of type `bytes`.
 
 ### 3. Request a reencryption
 
-After submitting your transaction, the Inco covalidators will process your request and perform the computation. In your contract, the result handle of the computation should be stored on chain, let's call it `resultHandle` of type `Handle` (hex).
+Following transaction submission, the Inco covalidator processes the computation request. The contract stores the computation result as a handle on-chain. This handle, referenced below as `resultHandle`, is a hexadecimal string of type `Handle` that serves as a reference to the encrypted computation output.
 
 ```ts
-import { incoLiteReencryptor } from "@inco/js/lite";
 import { Hex } from "viem";
 
-// Reencrypt.
-let resultHandle = "0x..." as Hex; // Retrieve it, e.g. by reading from your dapp contract.
-const reencryptor = await incoLiteReencryptor({
-  chainId: BigInt(chain.id),
-  walletClient: walletClient,
-}); // This step will ask you to sign an EIP-712 needed for reencryption verification
-const resultPlaintext = await reencryptor({
-  handle: resultHandle,
-});
-console.log(resultPlaintext.value); // Plaintext of the final result after computation
+// Request a re-encryption of the result ciphertext
+const resultHandle = "0x..." as Hex; // Retrieve the handle from the contract, e.g. using viem
+const reencryptor = await zap.getReencryptor(walletClient); // Use same walletClient as previous step
+const resultPlaintext = await reencryptor({ handle: resultHandle });
+
+console.log(resultPlaintext.value); // The decrypted value
 ```
 
 ## License