@inco/js 0.1.31 → 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

package/dist/binary.js

@@ -0,0 +1,67 @@
+import { ParseResult, Schema } from 'effect';
+import { isHex } from 'viem';
+import { parse } from './schema';
+export const HexString = Schema.TemplateLiteral('0x', Schema.String);
+export function bytesToBigInt(byteArray) {
+    // Ugly but better than bigint-buffer that insists on writing junk to stderr if it doesn't have native bindings
+    return !byteArray?.length ? BigInt(0) : BigInt('0x' + Buffer.from(byteArray).toString('hex'));
+}
+export function bufferToBigInt(buffer) {
+    return bytesToBigInt(Uint8Array.from(buffer));
+}
+// Convert a bigint to a 32-byte array, left-padded if necessary. Note: it is
+// caller's responsibility to ensure that the bigint is not too large to fit in
+// 32 bytes, or else the result will be truncated.
+export function bigintToBytes32(value) {
+    return parse(Bytes32, Buffer.from(value.toString(16).padStart(64, '0'), 'hex').toString('hex'));
+}
+export function padLeft(bs, n) {
+    if (bs.length > n) {
+        throw new Error(`Cannot pad ${bs.length} bytes to ${n} - would truncate`);
+    }
+    const buf = Buffer.alloc(n);
+    buf.set(bs, n - bs.length);
+    return buf;
+}
+export function bytes32ToBigint(bs) {
+    const bytes32 = asBytes32(bs);
+    return BigInt(bytes32);
+}
+export function bytesFromHexString(hexString) {
+    return Buffer.from(hexString.startsWith('0x') ? hexString.slice(2) : hexString, 'hex');
+}
+export function mustBeHex(value) {
+    if (!isHex(value)) {
+        throw new Error(`Expected hex string, got: ${value}`);
+    }
+    return value;
+}
+export function normaliseToHex(value) {
+    return mustBeHex(value.startsWith('0x') ? value : `0x${value}`);
+}
+export function bytesToHex(bs) {
+    return ('0x' + Buffer.from(bs).toString('hex'));
+}
+const ByteArray = Schema.Object.pipe(Schema.filter((x) => x instanceof Uint8Array));
+const BytesToHex = Schema.transformOrFail(Schema.Union(Schema.String, ByteArray), HexString, {
+    strict: true,
+    encode: ParseResult.succeed,
+    decode: (x) => x instanceof Uint8Array
+        ? ParseResult.succeed(bytesToHex(x))
+        : ((y) => isHex(y)
+            ? ParseResult.succeed(y)
+            : ParseResult.fail(new ParseResult.Unexpected(y, `'${y}' is not a hex string`)))(normaliseToHex(x)),
+});
+export const Bytes32 = BytesToHex.pipe(Schema.filter((x) => x.length === 66 ||
+    `Expected 32-byte hex string (66 characters with 0x prefix) but got ${x.length} character string`), Schema.brand('Bytes32'));
+export function asBytes32(x) {
+    return parse(Bytes32, x);
+}
+export const Address = HexString.pipe(Schema.filter((s) => s.length === 42 || `Address must be a 20-byte '0x'-prefixed hex string, but got: ${s}`), Schema.brand('Address'));
+export function parseAddress(address) {
+    return parse(Address, address);
+}
+export function parseHex(hex) {
+    return parse(HexString, hex);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chain.js

@@ -0,0 +1,24 @@
+// No imports here to avoid issues with closures and modules across pulumi boundary
+// This file can be seen as mirroring the functionality of viem changes without depending on it directly.
+// It exists as a workaround for some very gnarly issues with code reuse between Pulumi and this module, partly
+// relating to modules but also linked to Pulumi's ability to capture closures and serialise them.
+export const supportedChains = {
+    baseSepolia: 84532,
+    sepolia: 11155111,
+    monadTestnet: 10143,
+};
+export const fheSupportedChains = { baseSepolia: 84532, sepolia: 11155111 };
+// Get supportedChain either by its chain ID or the short name (lower pascal case)
+export function getSupportedChain(chainish) {
+    const found = typeof chainish === 'number' || typeof chainish === 'bigint'
+        ? Object.entries(supportedChains).find(([, id]) => id === Number(chainish))
+        : typeof chainish === 'object'
+            ? Object.entries(supportedChains).find(([, id]) => id === Number(chainish.id))
+            : Object.entries(supportedChains).find(([shortName]) => shortName === chainish);
+    if (!found) {
+        throw new Error(`Supported chain ${JSON.stringify(chainish)} not found`);
+    }
+    const [name, id] = found;
+    return { name: name, id };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY2hhaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUZBQW1GO0FBRW5GLHlHQUF5RztBQUN6RywrR0FBK0c7QUFDL0csa0dBQWtHO0FBRWxHLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRztJQUM3QixXQUFXLEVBQUUsS0FBSztJQUNsQixPQUFPLEVBQUUsUUFBUTtJQUNqQixZQUFZLEVBQUUsS0FBSztDQUNYLENBQUM7QUFFWCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBVyxDQUFDO0FBY3JGLGtGQUFrRjtBQUNsRixNQUFNLFVBQVUsaUJBQWlCLENBQUMsUUFBa0I7SUFDbEQsTUFBTSxLQUFLLEdBQ1QsT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVE7UUFDMUQsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLEtBQUssTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzNFLENBQUMsQ0FBQyxPQUFPLFFBQVEsS0FBSyxRQUFRO1lBQzVCLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDOUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLENBQUMsU0FBUyxLQUFLLFFBQVEsQ0FBQyxDQUFDO0lBQ3RGLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsbUJBQW1CLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFDRCxNQUFNLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQztJQUN6QixPQUFPLEVBQUUsSUFBSSxFQUFFLElBQTBCLEVBQUUsRUFBRSxFQUFFLENBQUM7QUFDbEQsQ0FBQyJ9

package/dist/encryption/encryption.js

@@ -0,0 +1,98 @@
+import { Schema } from 'effect';
+import { bigintToBytes32, Bytes32, HexString } from '../binary';
+import { handleTypes, InputContext } from '../handle';
+export const supportedFheTypes = {
+    euint64: handleTypes.euint64,
+    euint256: handleTypes.euint256,
+    ebool: handleTypes.ebool,
+};
+const supportedFheTypeNames = Object.keys(supportedFheTypes);
+export const SupportedFheTypeName = Schema.Literal(...supportedFheTypeNames);
+// TODO: extend to all types
+export const SupportedFheType = Schema.Literal(...Object.values(supportedFheTypes));
+export const encryptionSchemes = {
+    tfhe: 0,
+    ecies: 1,
+    cryptobox: 2,
+};
+export function getEncryptionSchemeName(scheme) {
+    switch (scheme) {
+        case encryptionSchemes.tfhe:
+            return 'TFHE';
+        case encryptionSchemes.ecies:
+            return 'ECIES';
+        case encryptionSchemes.cryptobox:
+            return 'NACLCryptoBox';
+        default:
+            throw new Error(`Unknown encryption scheme: ${scheme}`);
+    }
+}
+export const EncryptionScheme = Schema.Literal(encryptionSchemes.tfhe, encryptionSchemes.ecies, encryptionSchemes.cryptobox);
+export const ciphertextEnvelopes = {
+    none: 0,
+    hadu: 1,
+};
+export const CiphertextEnvelope = Schema.Literal(...Object.values(ciphertextEnvelopes));
+export const Ciphertext = Schema.Struct({
+    scheme: EncryptionScheme,
+    type: SupportedFheType,
+    value: HexString,
+    envelope: Schema.optional(CiphertextEnvelope),
+});
+export const CiphertextWithContext = Schema.Struct({
+    ciphertext: Ciphertext,
+    context: InputContext,
+});
+export const EncryptResult = Schema.Struct({
+    ciphertext: Ciphertext,
+    context: InputContext,
+    prehandle: Bytes32,
+    handle: Bytes32,
+});
+export const Plaintext = Schema.Union(Schema.Struct({
+    scheme: EncryptionScheme,
+    type: Schema.Literal(handleTypes.euint64, handleTypes.euint256),
+    value: Schema.BigInt,
+}), Schema.Struct({
+    scheme: EncryptionScheme,
+    type: Schema.Literal(handleTypes.ebool),
+    value: Schema.Boolean,
+}));
+export const PlaintextWithContext = Schema.Struct({
+    plaintext: Plaintext,
+    context: InputContext,
+});
+export function bigintToPlaintext(scheme, type, bigPt) {
+    switch (type) {
+        case handleTypes.euint64:
+        case handleTypes.euint256:
+            return {
+                scheme,
+                type,
+                value: bigPt,
+            };
+        case handleTypes.ebool:
+            return {
+                scheme,
+                type,
+                value: bigPt !== 0n,
+            };
+    }
+    throw new Error(`Unsupported FHE type: ${type}`);
+}
+export function plaintextToBigint(plaintext) {
+    switch (plaintext.type) {
+        case handleTypes.euint64:
+        case handleTypes.euint256:
+            return plaintext.value;
+        case handleTypes.ebool:
+            return plaintext.value ? 1n : 0n;
+    }
+}
+export function plaintextToBytes32(plaintext) {
+    return bigintToBytes32(plaintextToBigint(plaintext));
+}
+export function bytes32ToPlaintext(plaintext, scheme, type) {
+    return bigintToPlaintext(scheme, type, BigInt(plaintext));
+}
+//# sourceMappingURL=data:application/json;base64,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