@inco/js 0.1.31 → 0.1.33

package/dist/l1/client.js

@@ -0,0 +1,93 @@
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import { DirectSecp256k1HdWallet, Registry } from '@cosmjs/proto-signing';
+import { defaultRegistryTypes as defaultStargateTypes, SigningStargateClient, } from '@cosmjs/stargate';
+import * as fhe from '../generated/es/inco/fhe/v1/query_pb';
+import * as preflight from '../generated/es/inco/preflight/v1/query_pb';
+import { MsgAddCovalidator, MsgAddFheEnv } from '../generated/ts/inco/fhe/v1/tx';
+import { MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx';
+// We could have extracted these strings from types inside
+// ../generated/es/fhe/v1/tx_pb, but it seems more readable to hardcode
+// them here.
+const msgRegisterInputTypeUrl = '/inco.preflight.v1.MsgRegisterInput';
+const msgAddCovalidatorTypeUrl = '/inco.fhe.v1.MsgAddCovalidator';
+const msgAddFheEnvTypeUrl = '/inco.fhe.v1.MsgAddFheEnv';
+// The CosmJS L1 client needs a local registry to register custom types that
+// are not part of the default Cosmos types (`defaultStargateTypes`). We
+// hardcode them here.
+//
+// If we want to support more messages for strong TS typings, we need to add
+// them here.
+const supportedMsgs = {
+    [msgRegisterInputTypeUrl]: MsgRegisterInput,
+    [msgAddCovalidatorTypeUrl]: MsgAddCovalidator,
+    [msgAddFheEnvTypeUrl]: MsgAddFheEnv,
+};
+// The list of supported queries on the Inco L1.
+//
+// If we want to support more queries (e.g. Cosmos bank, staking queries), we
+// need to add them here.
+const supportedQueries = {
+    fhe,
+    preflight,
+};
+export async function createL1Wallet(mnemonic) {
+    return await DirectSecp256k1HdWallet.fromMnemonic(mnemonic, { prefix: 'inco' });
+}
+// Creates a Cosmos L1 client using CosmJS.
+export async function createL1Client({ cometRpcEndpoint, grpcEndpoint, wallet, waitTimeForTxInclusion = 10_000, }) {
+    // Manual registry creation is required to register custom Msg types.
+    const registry = new Registry(defaultStargateTypes);
+    Object.entries(supportedMsgs).forEach(([typeUrl, message]) => {
+        // @ts-ignore TODO: Fix this typing issue. This was introcued in:
+        // https://github.com/Inco-fhevm/inco-monorepo/pull/251
+        registry.register(typeUrl, message);
+    });
+    // Create one shared gRPC transport for all queries.
+    const transport = createGrpcTransport({ baseUrl: grpcEndpoint });
+    const query = Object.fromEntries(Object.entries(supportedQueries).map(([k, v]) => [k, createClient(v.Query, transport)]));
+    const signingClient = await SigningStargateClient.connectWithSigner(cometRpcEndpoint, wallet, {
+        registry,
+    });
+    // We currently assume that the Inco chain has 0 fees and hardcode the default gas limit.
+    const defaultFee = {
+        amount: [{ denom: 'uinco', amount: '0' }],
+        gas: '1000000',
+    };
+    return {
+        get q() {
+            return query;
+        },
+        async sendTx(signerAddress, msgType, msg, fee = defaultFee) {
+            const msgAny = {
+                typeUrl: msgType,
+                value: msg,
+            };
+            const result = await signingClient.signAndBroadcast(signerAddress, [msgAny], fee);
+            if (result.code) {
+                throw new Error(`Error broadcasting tx: ${result.rawLog}`);
+            }
+            // Poll until the transaction is included in a block, with a maximum wait time given by config.
+            const startTime = Date.now();
+            await new Promise((resolve, reject) => {
+                const interval = setInterval(async () => {
+                    const tx = await signingClient.getTx(result.transactionHash);
+                    if (tx?.code) {
+                        clearInterval(interval);
+                        reject(new Error(`Transaction failed: ${JSON.stringify(tx)}`));
+                    }
+                    else if (tx?.height) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                    else if (Date.now() - startTime > waitTimeForTxInclusion) {
+                        clearInterval(interval);
+                        reject(new Error('Transaction polling timed out'));
+                    }
+                }, 1000);
+            });
+            return result;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/l1/index.js

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './preflight';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbDEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUMifQ==

package/dist/l1/preflight.js

@@ -0,0 +1,39 @@
+import { Schema } from 'effect';
+import { Bytes32, bytesFromHexString } from '../binary';
+import { MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx';
+import { computeHandle } from '../handle';
+import { parse } from '../schema';
+import { createL1Client } from './client';
+// Do not export this value, only allow parsing of Handle to happen here
+const Handle = Bytes32.pipe(Schema.brand('Handle'));
+// Sends a preflight input to the Cosmos L1 chain using CosmJS.
+export async function cosmJSPreflight({ cometRpcEndpoint, grpcEndpoint, wallet, signerAddress, }) {
+    const l1Client = await createL1Client({ cometRpcEndpoint, wallet, grpcEndpoint });
+    return {
+        async send({ prehandle, ciphertext, context }) {
+            const msg = MsgRegisterInput.create({
+                prehandle: Buffer.from(prehandle.replace(/^0x/, ''), 'hex'),
+                signer: signerAddress,
+                ciphertext: Buffer.from(ciphertext.value, 'hex'),
+                context: {
+                    ownerAddr: context.userAddress.replace(/^0x/, ''),
+                    contractAddr: context.contractAddress.replace(/^0x/, ''),
+                    // We decided to put the ACL address in the keyset ID field.
+                    keysetId: context.aclAddress.replace(/^0x/, ''),
+                    hostChainId: 'evm/' + context.hostChainId,
+                },
+            });
+            // There are some hidden dependencies needed to make the following line work:
+            //
+            // 1. The signer must have an account on the chain. In Cosmos, this is
+            // usually done by sending some tokens to the account. However, since the
+            // fees are 0, this account doesn't need to have any tokens.
+            // 2. The FheEnv must have been created in the on-chain registry. Only the
+            // council can add new FheEnvs to the registry.
+            const result = await l1Client.sendTx(signerAddress, '/inco.preflight.v1.MsgRegisterInput', msg);
+            const handle = computeHandle({ prehandle: bytesFromHexString(prehandle), context });
+            return { transactionHash: result.transactionHash, handle: parse(Handle, handle) };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lite/deployments.js

@@ -0,0 +1,17 @@
+// Avoid inporting any other dependencies in this file to avoid serialisation issues downstream in infracto
+import { getSupportedChain } from '../chain';
+import { lightningDeployments } from '../generated/lightning';
+export function getActiveLightningDeployment(chain) {
+    const supportedChain = getSupportedChain(chain);
+    const deployments = lightningDeployments.filter((d) => d.chainId === supportedChain.id);
+    if (!deployments?.length) {
+        throw new Error(`No deployments found for chain ${chain}`);
+    }
+    return deployments[0];
+}
+export function getLightningDeployments(chainId) {
+    const supportedChain = getSupportedChain(chainId);
+    const deployments = lightningDeployments.filter((d) => d.chainId === supportedChain.id);
+    return deployments ?? [];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95bWVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGl0ZS9kZXBsb3ltZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyR0FBMkc7QUFDM0csT0FBTyxFQUFZLGlCQUFpQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ3ZELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBTzlELE1BQU0sVUFBVSw0QkFBNEIsQ0FBQyxLQUFlO0lBQzFELE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hELE1BQU0sV0FBVyxHQUFHLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sS0FBSyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDeEYsSUFBSSxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsQ0FBQztRQUN6QixNQUFNLElBQUksS0FBSyxDQUFDLGtDQUFrQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFDRCxPQUFPLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUN4QixDQUFDO0FBRUQsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE9BQWlCO0lBQ3ZELE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2xELE1BQU0sV0FBVyxHQUFHLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sS0FBSyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDeEYsT0FBTyxXQUFXLElBQUksRUFBRSxDQUFDO0FBQzNCLENBQUMifQ==

package/dist/lite/ecies.js

@@ -0,0 +1,124 @@
+import { decrypt as eciesDecrypt, encrypt as eciesEncrypt } from 'ecies-geth';
+import { ec } from 'elliptic';
+import { asBytes32, bytes32ToBigint, bytesFromHexString, bytesToHex } from '../binary';
+import { bigintToPlaintext, ciphertextEnvelopes, encryptionSchemes, getEncryptionSchemeName, } from '../encryption/encryption';
+import { computeHandle, computePrehandle } from '../handle';
+import { decodeInput, encodeInput } from './hadu';
+const secp256k1 = new ec('secp256k1');
+// Convert an ec.KeyPair from the 'elliptic' package (assumed to have geen generated
+// with the secp256k1 curve) to our Secp256k1Keypair type.
+export function toSecp256k1Keypair(kp) {
+    return {
+        scheme: encryptionSchemes.ecies,
+        kp,
+        encodePublicKey() {
+            return new Uint8Array(kp.getPublic().encode('array', false));
+        },
+    };
+}
+// Generate a new ephemeral keypair for reencryption.
+export function generateSecp256k1Keypair() {
+    return toSecp256k1Keypair(secp256k1.genKeyPair());
+}
+// EncodePublicKey encodes an ECIES public key it's 33-byte compressed form.
+export function encodeSecp256k1PublicKey(pub) {
+    return new Uint8Array(pub.encodeCompressed('array'));
+}
+// DecodeSecp256k1PublicKey decodes a 33-byte compressed ECIES public key.
+export function decodeSecp256k1PublicKey(pubKeyCompressed) {
+    return secp256k1.keyFromPublic(pubKeyCompressed, 'array').getPublic();
+}
+// DecodeSecp256k1PrivateKey returns a ECIES secp256k1 private key based on the provided byte slice which is
+// interpreted as an unsigned 256-bit big-endian integer in the range [0, N-1],
+// where N is the order of the curve.
+// where N is the order of the curve.
+//
+// WARNING: This means passing a slice with more than 32 bytes is truncated and
+// that truncated value is reduced modulo N.  Further, 0 is not a valid private
+// key.  It is up to the caller to provide a value in the appropriate range of
+// [1, N-1].  Failure to do so will either result in an invalid private key or
+// potentially weak private keys that have bias that could be exploited.
+//
+// This function primarily exists to provide a mechanism for converting
+// serialized private keys that are already known to be good.
+//
+// For more info, refer to the decred/dcrd documentation:
+// ref: https://pkg.go.dev/github.com/decred/dcrd/dcrec/secp256k1/v4@v4.2.0#PrivKeyFromBytes
+//
+// We don't include any curve parameters or ECIES params, as they are assumed to
+// be the ones in ecies.ECIES_AES128_SHA256 from go-ethereum.
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.0/crypto/ecies/params.go#L76-L82
+export function decodeSecp256k1PrivateKey(privKey) {
+    return toSecp256k1Keypair(secp256k1.keyFromPrivate(privKey, 'array'));
+}
+// Given a (usually 3rd-party known) public key, called `pubKeyA`, and an ephemeral
+// private key (usually generated locally), called `privKeyB`, encrypt the `msg`
+// using ECIES, with geth's parameters:
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.2/crypto/ecies/ecies.go
+export async function encrypt(pubKeyA, plaintext, privKeyB) {
+    const pubKeyABuffer = Buffer.from(pubKeyA.encode('array', false));
+    const privKeyBBuffer = privKeyB.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    const ct = await eciesEncrypt(pubKeyABuffer, Buffer.from(plaintext), {
+        ephemPrivateKey: privKeyBBuffer,
+    });
+    return new Uint8Array(ct);
+}
+export function getEciesEncryptor({ pubKeyA, privKeyB }) {
+    const pubKeyABuffer = Buffer.from(pubKeyA.encode('array', false));
+    const privKeyBBuffer = privKeyB.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    return async ({ plaintext, context, }) => {
+        if (plaintext.scheme !== encryptionSchemes.ecies) {
+            throw new Error(`Plaintext with scheme ${getEncryptionSchemeName(plaintext.scheme)} cannot be encrypted with ECIES`);
+        }
+        const ptBuf = Buffer.from(encodeInput({ plaintext, context }));
+        const ct = await eciesEncrypt(pubKeyABuffer, ptBuf, {
+            ephemPrivateKey: privKeyBBuffer,
+        });
+        const prehandle = computePrehandle({
+            ciphertext: ct,
+            handleType: plaintext.type,
+            indexHandle: 0,
+            handleVersion: 0,
+        });
+        const handle = computeHandle({
+            prehandle,
+            context: context,
+        });
+        return {
+            prehandle: asBytes32(prehandle),
+            handle: asBytes32(handle),
+            context,
+            ciphertext: {
+                scheme: encryptionSchemes.ecies,
+                type: plaintext.type,
+                value: bytesToHex(ct),
+            },
+        };
+    };
+}
+// Given an ephemeral private key, called `privKeyA`, and a ciphertext `ct`,
+// decrypt the ciphertext using ECIES, with geth's parameters:
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.2/crypto/ecies/ecies.go
+export async function decrypt(privKeyA, ciphertext) {
+    const privKeyABuffer = privKeyA.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    const pt = await eciesDecrypt(privKeyABuffer, Buffer.from(ciphertext));
+    return new Uint8Array(pt);
+}
+export function getEciesDecryptor({ privKeyA }) {
+    const privKeyABuffer = privKeyA.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    return async ({ scheme, type, value, envelope, }) => {
+        if (scheme !== encryptionSchemes.ecies) {
+            throw new Error(`Ciphertext with scheme ${getEncryptionSchemeName(scheme)} cannot be decrypted with ECIES`);
+        }
+        const ptBuf = await eciesDecrypt(privKeyABuffer, bytesFromHexString(value));
+        // If envelope field is omitted then assume HADU, only with an explicit none envelope do we assume a raw byte
+        // encoding as would be performed by the compute server
+        if (envelope === ciphertextEnvelopes.none) {
+            const bigPt = bytes32ToBigint(Buffer.from(ptBuf).toString('hex'));
+            return bigintToPlaintext(scheme, type, bigPt);
+        }
+        const { plaintext } = decodeInput(ptBuf.toString());
+        return plaintext;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lite/hadu.js

@@ -0,0 +1,36 @@
+import { Schema } from 'effect';
+import { parseJson } from 'effect/Schema';
+import { Bytes32 } from '../binary';
+import { bytes32ToPlaintext, EncryptionScheme, plaintextToBytes32, SupportedFheType, } from '../encryption';
+import { InputContext } from '../handle';
+// HADU stands for "Host Chain, ACL, DApp, and User" it maps to the InputContext type where the aclAddress
+// may actually be the singular IncoLite contract which embeds its own ACL
+export const encryptionEnvelopes = {
+    none: 0,
+    hadu: 1,
+};
+export const EncryptionEnvelope = Schema.Literal(...Object.values(encryptionEnvelopes));
+export const HaduInput = parseJson(Schema.Struct({
+    envelope: Schema.Literal(encryptionEnvelopes.hadu),
+    scheme: EncryptionScheme,
+    context: InputContext,
+    plaintext: Bytes32,
+    type: SupportedFheType,
+}));
+export function encodeInput({ plaintext, context }) {
+    return Schema.encodeSync(HaduInput)({
+        envelope: encryptionEnvelopes.hadu,
+        scheme: plaintext.scheme,
+        type: plaintext.type,
+        plaintext: plaintextToBytes32(plaintext),
+        context,
+    });
+}
+export function decodeInput(json) {
+    const { scheme, context, plaintext, type } = Schema.decodeSync(HaduInput)(json);
+    return {
+        plaintext: bytes32ToPlaintext(plaintext, scheme, type),
+        context,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFkdS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saXRlL2hhZHUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUNoQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDcEMsT0FBTyxFQUNMLGtCQUFrQixFQUNsQixnQkFBZ0IsRUFDaEIsa0JBQWtCLEVBRWxCLGdCQUFnQixHQUNqQixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRXpDLDBHQUEwRztBQUMxRywwRUFBMEU7QUFFMUUsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7SUFDakMsSUFBSSxFQUFFLENBQUM7SUFDUCxJQUFJLEVBQUUsQ0FBQztDQUNDLENBQUM7QUFLWCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLENBQUM7QUFFeEYsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLFNBQVMsQ0FDaEMsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNaLFFBQVEsRUFBRSxNQUFNLENBQUMsT0FBTyxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQztJQUNsRCxNQUFNLEVBQUUsZ0JBQWdCO0lBQ3hCLE9BQU8sRUFBRSxZQUFZO0lBQ3JCLFNBQVMsRUFBRSxPQUFPO0lBQ2xCLElBQUksRUFBRSxnQkFBZ0I7Q0FDdkIsQ0FBQyxDQUNILENBQUM7QUFJRixNQUFNLFVBQVUsV0FBVyxDQUFDLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBd0I7SUFDdEUsT0FBTyxNQUFNLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ2xDLFFBQVEsRUFBRSxtQkFBbUIsQ0FBQyxJQUFJO1FBQ2xDLE1BQU0sRUFBRSxTQUFTLENBQUMsTUFBTTtRQUN4QixJQUFJLEVBQUUsU0FBUyxDQUFDLElBQUk7UUFDcEIsU0FBUyxFQUFFLGtCQUFrQixDQUFDLFNBQVMsQ0FBQztRQUN4QyxPQUFPO0tBQ1IsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVELE1BQU0sVUFBVSxXQUFXLENBQUMsSUFBWTtJQUN0QyxNQUFNLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoRixPQUFPO1FBQ0wsU0FBUyxFQUFFLGtCQUFrQixDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDO1FBQ3RELE9BQU87S0FDUixDQUFDO0FBQ0osQ0FBQyJ9