added support for string encryption

Author: spencer-xyz

src/account/confidential-account.ts

@@ -1,17 +1,17 @@
-import { BaseWallet, Wallet, Contract, Provider, JsonRpcProvider } from "ethers"
-import { decryptValue, prepareIT } from "../libs/crypto"
+import { BaseWallet, Wallet, Contract, Provider } from "ethers"
+import { decryptString, decryptUint, prepareStringIT, prepareUintIT } from "../libs/crypto"
 import { getDefaultProvider } from "../provider"
 import { onboard } from "./onboard"
 
 export class ConfidentialAccount {
   constructor(readonly wallet: BaseWallet, readonly userKey: string) {}
 
   public decryptValue(ciphertextValue: bigint) {
-    return decryptValue(ciphertextValue, this.userKey)
+    return decryptUint(ciphertextValue, this.userKey)
   }
 
   public encryptValue(plaintextValue: bigint | number, contractAddress: string, functionSelector: string) {
-    return prepareIT(BigInt(plaintextValue), this, contractAddress, functionSelector)
+    return prepareUintIT(BigInt(plaintextValue), this, contractAddress, functionSelector)
   }
 
   public static async onboard(wallet: BaseWallet, contract?: Contract): Promise<ConfidentialAccount> {

src/libs/crypto.ts

@@ -66,7 +66,7 @@ function decrypt(key: Buffer, r: Buffer, ciphertext: Buffer) {
   return plaintext
 }
 
-export function generateRSAKeyPair() {
+export function generateRSAKeyPair(): crypto.KeyPairSyncResult<Buffer, Buffer> {
   // Generate a new RSA key pair
   return crypto.generateKeyPairSync("rsa", {
     modulusLength: 2048,
@@ -97,9 +97,9 @@ export function decryptRSA(privateKey: Buffer, ciphertext: Buffer) {
   )
 }
 
-export function decryptValue(ctAmount: bigint, userKey: string) {
+export function decryptUint(ciphertext: bigint, userKey: string) {
   // Convert CT to bytes
-  let ctString = ctAmount.toString(hexBase)
+  let ctString = ciphertext.toString(hexBase)
   let ctArray = Buffer.from(ctString, "hex")
   while (ctArray.length < 32) {
     // When the first bits are 0, bigint bit size is less than 32 and need to re-add the bits
@@ -116,13 +116,25 @@ export function decryptValue(ctAmount: bigint, userKey: string) {
   return parseInt(decryptedMessage.toString("hex"), block_size)
 }
 
+export function decryptString(ciphertext: Array<bigint>, userKey: string) {
+    let decryptedStr = new Array<number>(ciphertext.length)
+
+    for (let i = 0; i < ciphertext.length; i++) {
+        decryptedStr[i] = decryptUint(ciphertext[i], userKey)
+    }
+
+    let decoder = new TextDecoder()
+
+    return decoder.decode(new Uint8Array(decryptedStr))
+}
+
 export function sign(message: string, privateKey: string) {
   const key = new SigningKey(privateKey)
   const sig = key.sign(message)
   return Buffer.concat([getBytes(sig.r), getBytes(sig.s), getBytes(`0x0${sig.v - 27}`)])
 }
 
-export async function prepareIT(
+export function prepareUintIT(
   plaintext: bigint,
   sender: { wallet: BaseWallet; userKey: string },
   contractAddress: string,
@@ -149,6 +161,26 @@ export async function prepareIT(
   return { ctInt, signature }
 }
 
+export async function prepareStringIT(
+    plaintext: string,
+    sender: { wallet: BaseWallet; userKey: string },
+    contractAddress: string,
+    functionSelector: string
+) {
+    let encoder = new TextEncoder()
+
+    let encodedStr = encoder.encode(plaintext)
+
+    let encryptedStr = new Array<{ ciphertext: bigint, signature: Buffer }>(plaintext.length)
+
+    for (let i = 0; i < plaintext.length; i++) {
+        const { ctInt, signature } = prepareUintIT(BigInt(encodedStr[i]), sender, contractAddress, functionSelector)
+        encryptedStr[i] = { ciphertext: ctInt, signature }
+    }
+
+    return encryptedStr
+}
+
 export function createRandomUserKey() {
   return crypto.randomBytes(block_size).toString("hex")
-}
+}