@coti-io/coti-contracts 1.1.0 → 1.2.0

package/test/utils/mpc/WalletEncryptionFailures.test.ts

@@ -0,0 +1,494 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+import { Wallet, ctUint, ctUint256 } from "@coti-io/coti-ethers"
+import { ValidateCiphertext128TestsContract } from "../../../typechain-types"
+import { MpcOperationsTestContract } from "../../../typechain-types"
+
+const GAS_LIMIT = 12000000
+
+async function deploy128Contract() {
+    const [owner] = await setupAccounts()
+    const contractFactory = await hre.ethers.getContractFactory("ValidateCiphertext128TestsContract", owner as any)
+    const contract = await contractFactory.deploy({ gasLimit: GAS_LIMIT })
+    await contract.waitForDeployment()
+    return {
+        contract,
+        contractAddress: await contract.getAddress(),
+        owner
+    }
+}
+
+async function deploy256Contract() {
+    const [owner] = await setupAccounts()
+    const contractFactory = await hre.ethers.getContractFactory("MpcOperationsTestContract", owner as any)
+    const contract = await contractFactory.deploy({ gasLimit: GAS_LIMIT })
+    await contract.waitForDeployment()
+    return {
+        contract,
+        contractAddress: await contract.getAddress(),
+        owner
+    }
+}
+
+describe("Wallet Encryption/Decryption Failure Tests with Contract Integration", function () {
+    this.timeout(300000) // 5 minutes timeout
+    let contract128: ValidateCiphertext128TestsContract
+    let contract128Address: string
+    let contract256: MpcOperationsTestContract
+    let contract256Address: string
+    let owner: Wallet
+    let walletWithoutAes: Wallet
+    let walletWithAutoOnboardOff: Wallet
+
+    before(async function () {
+        // Deploy contracts
+        const deployment128 = await deploy128Contract()
+        contract128 = deployment128.contract
+        contract128Address = deployment128.contractAddress
+        owner = deployment128.owner
+
+        const deployment256 = await deploy256Contract()
+        contract256 = deployment256.contract
+        contract256Address = deployment256.contractAddress
+
+        // Get network info and provider from owner's provider
+        const networkName = hre.network.name
+        const provider = owner.provider as any
+
+        // Create wallet without AES key (auto-onboard enabled)
+        const randomWallet = Wallet.createRandom(provider)
+        walletWithoutAes = new Wallet(randomWallet.privateKey, provider)
+        // Don't onboard - leave AES key undefined
+
+        // Create wallet with auto-onboard disabled
+        const randomWallet2 = Wallet.createRandom(provider)
+        walletWithAutoOnboardOff = new Wallet(randomWallet2.privateKey, provider)
+        walletWithAutoOnboardOff.disableAutoOnboard()
+        // Don't set AES key
+
+        const onboardInfo = owner.getUserOnboardInfo()
+        if (!onboardInfo || !onboardInfo.aesKey) {
+            throw new Error("User AES key not found. Please onboard the user first.")
+        }
+
+        console.log("\n" + "=".repeat(80))
+        console.log("🧪 WALLET ENCRYPTION/DECRYPTION FAILURE TESTS")
+        console.log("=".repeat(80))
+        console.log(`Network: ${networkName}`)
+        console.log(`128-bit Contract: ${contract128Address}`)
+        console.log(`256-bit Contract: ${contract256Address}`)
+        console.log(`Owner Address: ${owner.address}`)
+        console.log(`Wallet Without AES: ${walletWithoutAes.address}`)
+        console.log(`Wallet Auto-Onboard Off: ${walletWithAutoOnboardOff.address}`)
+        console.log("=".repeat(80) + "\n")
+    })
+
+    describe("encryptValue Failure Scenarios with Contract Integration", function () {
+        it("Should fail when encrypting 129-bit value (exceeds 128-bit limit)", async function () {
+            // 129-bit value (2^128)
+            const value129Bits = 2n ** 128n
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            await expect(
+                owner.encryptValue(value129Bits, contract128Address, functionSelector)
+            ).to.be.rejectedWith("encryptValue: values larger than 128 bits are not supported")
+        })
+
+        it("Should fail when encrypting 256-bit value with encryptValue", async function () {
+            // 256-bit value
+            const value256Bits = 2n ** 255n
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            await expect(
+                owner.encryptValue(value256Bits, contract128Address, functionSelector)
+            ).to.be.rejectedWith("encryptValue: values larger than 128 bits are not supported")
+        })
+
+        it("Should succeed with 128-bit value and complete full cycle", async function () {
+            // Maximum 128-bit value (2^128 - 1)
+            const max128Bits = 2n ** 128n - 1n
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            console.log(`\n✅ Testing 128-bit encryption/decryption full cycle`)
+            console.log(`   Value: ${max128Bits.toString()}`)
+
+            // Encrypt
+            const encrypted = await owner.encryptValue(max128Bits, contract128Address, functionSelector) as any
+            expect(encrypted).to.have.property("ciphertext")
+            expect(encrypted).to.have.property("signature")
+            console.log(`   ✅ Encrypted successfully`)
+
+            // Call contract
+            const tx = await contract128.validateAndReturn(encrypted, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+            console.log(`   ✅ Contract call successful`)
+
+            // Get result from event
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract128.interface.parseLog(log)?.name === "ValueOffBoarded128"
+                } catch {
+                    return false
+                }
+            })
+
+            expect(resultEvent).to.not.be.undefined
+            const parsedLog = contract128.interface.parseLog(resultEvent!)
+            const ctResult: ctUint = parsedLog?.args.result
+
+            // Decrypt
+            const decrypted = await owner.decryptValue(ctResult)
+            expect(decrypted).to.equal(max128Bits)
+            console.log(`   ✅ Decrypted successfully: ${decrypted.toString()}\n`)
+        })
+
+        it("Should fail when encrypting without AES key and auto-onboard is off", async function () {
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            await expect(
+                walletWithAutoOnboardOff.encryptValue(1000n, contract128Address, functionSelector)
+            ).to.be.rejectedWith("user AES key is not defined and auto onboard is off")
+        })
+
+        it("Should fail when encrypting without AES key and account has no balance", async function () {
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            await expect(
+                walletWithoutAes.encryptValue(1000n, contract128Address, functionSelector)
+            ).to.be.rejected
+        })
+    })
+
+    describe("encryptValue256 Failure Scenarios with Contract Integration", function () {
+        it("Should fail when encrypting 257-bit value (exceeds 256-bit limit)", async function () {
+            // 257-bit value (2^256)
+            const value257Bits = 2n ** 256n
+            const functionSelector = contract256.add256.fragment.selector
+
+            await expect(
+                owner.encryptValue256(value257Bits, contract256Address, functionSelector)
+            ).to.be.rejectedWith("encryptValue256: values larger than 256 bits are not supported")
+        })
+
+        it("Should succeed with 256-bit value and complete full cycle", async function () {
+            // Maximum 256-bit value (2^256 - 1)
+            const max256Bits = 2n ** 256n - 1n
+            const functionSelector = contract256.add256.fragment.selector
+
+            console.log(`\n✅ Testing 256-bit encryption/decryption full cycle`)
+            console.log(`   Value: ${max256Bits.toString().substring(0, 50)}...`)
+
+            // Encrypt
+            const encrypted = await owner.encryptValue256(max256Bits, contract256Address, functionSelector)
+            expect(encrypted).to.have.property("ciphertext")
+            expect(encrypted.ciphertext).to.have.property("ciphertextHigh")
+            expect(encrypted.ciphertext).to.have.property("ciphertextLow")
+            expect(encrypted).to.have.property("signature")
+            console.log(`   ✅ Encrypted successfully`)
+
+            // Call contract (add with zero to get same value back)
+            const zero = await owner.encryptValue256(0n, contract256Address, functionSelector)
+            const tx = await contract256.add256(encrypted, zero, owner.address, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+            console.log(`   ✅ Contract call successful`)
+
+            // Get result from event
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract256.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+
+            expect(resultEvent).to.not.be.undefined
+            const parsedLog = contract256.interface.parseLog(resultEvent!)
+            const ctResult: ctUint256 = parsedLog?.args.result
+
+            // Decrypt
+            const decrypted = await owner.decryptValue256({
+                ciphertextHigh: ctResult.ciphertextHigh,
+                ciphertextLow: ctResult.ciphertextLow
+            })
+            expect(decrypted).to.equal(max256Bits)
+            console.log(`   ✅ Decrypted successfully\n`)
+        })
+
+        it("Should succeed with 129-bit value using encryptValue256", async function () {
+            // 129-bit value should work with encryptValue256
+            const value129Bits = 2n ** 128n
+            const functionSelector = contract256.add256.fragment.selector
+
+            console.log(`\n✅ Testing 129-bit value with encryptValue256`)
+            console.log(`   Value: ${value129Bits.toString()}`)
+
+            // Encrypt
+            const encrypted = await owner.encryptValue256(value129Bits, contract256Address, functionSelector)
+            expect(encrypted).to.have.property("ciphertext")
+            expect(encrypted.ciphertext).to.have.property("ciphertextHigh")
+            expect(encrypted.ciphertext).to.have.property("ciphertextLow")
+            console.log(`   ✅ Encrypted successfully`)
+
+            // Call contract
+            const zero = await owner.encryptValue256(0n, contract256Address, functionSelector)
+            const tx = await contract256.add256(encrypted, zero, owner.address, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+
+            // Get and decrypt result
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract256.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract256.interface.parseLog(resultEvent!)
+            const ctResult: ctUint256 = parsedLog?.args.result
+
+            const decrypted = await owner.decryptValue256({
+                ciphertextHigh: ctResult.ciphertextHigh,
+                ciphertextLow: ctResult.ciphertextLow
+            })
+            expect(decrypted).to.equal(value129Bits)
+            console.log(`   ✅ Full cycle successful\n`)
+        })
+
+        it("Should fail when encrypting without AES key and auto-onboard is off", async function () {
+            const functionSelector = contract256.add256.fragment.selector
+
+            await expect(
+                walletWithAutoOnboardOff.encryptValue256(1000n, contract256Address, functionSelector)
+            ).to.be.rejectedWith("user AES key is not defined and auto onboard is off")
+        })
+
+        it("Should fail when encrypting without AES key and account has no balance", async function () {
+            const functionSelector = contract256.add256.fragment.selector
+
+            await expect(
+                walletWithoutAes.encryptValue256(1000n, contract256Address, functionSelector)
+            ).to.be.rejected
+        })
+    })
+
+    describe("Boundary Value Tests with Contract Integration", function () {
+        it("Should succeed with 64-bit value using encryptValue and complete full cycle", async function () {
+            const value64Bits = 2n ** 64n - 1n // Max 64-bit value
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            console.log(`\n✅ Testing 64-bit value full cycle`)
+            const encrypted = await owner.encryptValue(value64Bits, contract128Address, functionSelector) as any
+            const tx = await contract128.validateAndReturn(encrypted, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract128.interface.parseLog(log)?.name === "ValueOffBoarded128"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract128.interface.parseLog(resultEvent!)
+            const ctResult: ctUint = parsedLog?.args.result
+            const decrypted = await owner.decryptValue(ctResult)
+            expect(decrypted).to.equal(value64Bits)
+            console.log(`   ✅ 64-bit full cycle successful\n`)
+        })
+
+        it("Should fail with 129-bit value using encryptValue", async function () {
+            const value129Bits = 2n ** 128n // 129-bit value
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            await expect(
+                owner.encryptValue(value129Bits, contract128Address, functionSelector)
+            ).to.be.rejectedWith("encryptValue: values larger than 128 bits are not supported")
+        })
+
+        it("Should succeed with 128-bit value using encryptValue", async function () {
+            const value128Bits = 2n ** 128n - 1n // Max 128-bit value
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            const encrypted = await owner.encryptValue(value128Bits, contract128Address, functionSelector) as any
+            const tx = await contract128.validateAndReturn(encrypted, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract128.interface.parseLog(log)?.name === "ValueOffBoarded128"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract128.interface.parseLog(resultEvent!)
+            const ctResult: ctUint = parsedLog?.args.result
+            const decrypted = await owner.decryptValue(ctResult)
+            expect(decrypted).to.equal(value128Bits)
+        })
+    })
+
+    describe("Full Cycle Operations with Contract Integration", function () {
+        it("Should perform addition with 128-bit values using encryptValue", async function () {
+            const a = 2n ** 100n - 1000n
+            const b = 2n ** 100n - 2000n
+            const expected = a + b
+            const functionSelector = contract128.validateAndAdd.fragment.selector
+
+            console.log(`\n✅ Testing 128-bit addition full cycle`)
+            console.log(`   A: ${a.toString()}`)
+            console.log(`   B: ${b.toString()}`)
+            console.log(`   Expected: ${expected.toString()}`)
+
+            const itA = await owner.encryptValue(a, contract128Address, functionSelector) as any
+            const itB = await owner.encryptValue(b, contract128Address, functionSelector) as any
+
+            const tx = await contract128.validateAndAdd(itA, itB, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract128.interface.parseLog(log)?.name === "ValueOffBoarded128"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract128.interface.parseLog(resultEvent!)
+            const ctResult: ctUint = parsedLog?.args.result
+            const decrypted = await owner.decryptValue(ctResult)
+
+            expect(decrypted).to.equal(expected)
+            console.log(`   ✅ Addition verified: ${decrypted.toString()}\n`)
+        })
+
+        it("Should perform addition with 256-bit values using encryptValue256", async function () {
+            const a = 2n ** 130n + 1000n
+            const b = 2n ** 129n + 500n
+            const expected = a + b
+            const functionSelector = contract256.add256.fragment.selector
+
+            console.log(`\n✅ Testing 256-bit addition full cycle`)
+            const itA = await owner.encryptValue256(a, contract256Address, functionSelector)
+            const itB = await owner.encryptValue256(b, contract256Address, functionSelector)
+
+            const tx = await contract256.add256(itA, itB, owner.address, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract256.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract256.interface.parseLog(resultEvent!)
+            const ctResult: ctUint256 = parsedLog?.args.result
+            const decrypted = await owner.decryptValue256({
+                ciphertextHigh: ctResult.ciphertextHigh,
+                ciphertextLow: ctResult.ciphertextLow
+            })
+
+            expect(decrypted).to.equal(expected)
+            console.log(`   ✅ Addition verified\n`)
+        })
+
+        it("Should fail when trying to use encryptValue for 129-bit value in contract call", async function () {
+            const value129Bits = 2n ** 128n
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            // This should fail at encryption stage, before contract call
+            await expect(
+                owner.encryptValue(value129Bits, contract128Address, functionSelector)
+            ).to.be.rejectedWith("encryptValue: values larger than 128 bits are not supported")
+        })
+
+        it("Should succeed when using encryptValue256 for 129-bit value in contract call", async function () {
+            const value129Bits = 2n ** 128n
+            const functionSelector = contract256.add256.fragment.selector
+
+            // Should work with encryptValue256
+            const encrypted = await owner.encryptValue256(value129Bits, contract256Address, functionSelector)
+            const zero = await owner.encryptValue256(0n, contract256Address, functionSelector)
+            const tx = await contract256.add256(encrypted, zero, owner.address, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+            expect(receipt?.status).to.equal(1)
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract256.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract256.interface.parseLog(resultEvent!)
+            const ctResult: ctUint256 = parsedLog?.args.result
+            const decrypted = await owner.decryptValue256({
+                ciphertextHigh: ctResult.ciphertextHigh,
+                ciphertextLow: ctResult.ciphertextLow
+            })
+
+            expect(decrypted).to.equal(value129Bits)
+        })
+    })
+
+    describe("Type Conversion Tests with Contract Integration", function () {
+        it("Should convert number to bigint in encryptValue and complete full cycle", async function () {
+            const value = 1000 // number
+            const functionSelector = contract128.validateAndReturn.fragment.selector
+
+            const encrypted = await owner.encryptValue(value, contract128Address, functionSelector) as any
+            const tx = await contract128.validateAndReturn(encrypted, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract128.interface.parseLog(log)?.name === "ValueOffBoarded128"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract128.interface.parseLog(resultEvent!)
+            const ctResult: ctUint = parsedLog?.args.result
+            const decrypted = await owner.decryptValue(ctResult)
+
+            expect(decrypted).to.equal(BigInt(value))
+        })
+
+        it("Should convert number to bigint in encryptValue256 and complete full cycle", async function () {
+            const value = 1000 // number
+            const functionSelector = contract256.add256.fragment.selector
+
+            const encrypted = await owner.encryptValue256(value, contract256Address, functionSelector)
+            const zero = await owner.encryptValue256(0n, contract256Address, functionSelector)
+            const tx = await contract256.add256(encrypted, zero, owner.address, { gasLimit: GAS_LIMIT })
+            const receipt = await tx.wait()
+
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract256.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+
+            const parsedLog = contract256.interface.parseLog(resultEvent!)
+            const ctResult: ctUint256 = parsedLog?.args.result
+            const decrypted = await owner.decryptValue256({
+                ciphertextHigh: ctResult.ciphertextHigh,
+                ciphertextLow: ctResult.ciphertextLow
+            })
+
+            expect(decrypted).to.equal(BigInt(value))
+        })
+    })
+})

package/test/utils/privateErc20Helpers.ts

@@ -0,0 +1,97 @@
+import { expect } from "chai"
+import type { BaseContract, ContractTransactionResponse } from "ethers"
+import { prepareIT256, decryptUint256 } from "@coti-io/coti-sdk-typescript"
+import type { ctUint256, itUint256 } from "@coti-io/coti-sdk-typescript"
+
+/** Normalize ethers Result / tuple ctUint256 for the SDK. */
+function toCtUint256(
+    ct: ctUint256 | readonly [bigint, bigint] | { ciphertextHigh: bigint; ciphertextLow: bigint }
+): ctUint256 {
+    if (Array.isArray(ct)) {
+        return { ciphertextHigh: BigInt(ct[0]), ciphertextLow: BigInt(ct[1]) }
+    }
+    return {
+        ciphertextHigh: BigInt(ct.ciphertextHigh),
+        ciphertextLow: BigInt(ct.ciphertextLow)
+    }
+}
+
+/** Canonical empty ciphertext reads as numeric zero on-chain (see IPrivateERC20). */
+function isZeroCt(ct: ctUint256): boolean {
+    return ct.ciphertextHigh === 0n && ct.ciphertextLow === 0n
+}
+import type { Wallet } from "@coti-io/coti-ethers"
+
+/** Gas limit for COTI testnet txs (MPC-heavy). */
+export const GAS_LIMIT = 12_000_000
+
+export const txOpts = { gasLimit: GAS_LIMIT }
+
+/** EIP-165 `type(IPrivateERC20).interfaceId` (XOR of function selectors in `IPrivateERC20.sol`). */
+export const IPRIVATE_ERC20_INTERFACE_ID = "0x479eaff4"
+
+export async function mintPublic(
+    contract: BaseContract,
+    signer: Wallet,
+    to: string,
+    amount: bigint
+) {
+    return contract
+        .connect(signer)
+        .getFunction("mint(address,uint256)")(to, amount, txOpts)
+}
+
+export async function burnPublic(
+    contract: BaseContract,
+    signer: Wallet,
+    from: string,
+    amount: bigint
+) {
+    return contract
+        .connect(signer)
+        .getFunction("burn(address,uint256)")(from, amount, txOpts)
+}
+
+/** Encrypted uint256 input text for `itUint256` calldata (PrivateERC20). Uses `prepareIT256`, not 64-bit `Wallet.encryptValue`. */
+export async function encryptItUint256(
+    wallet: Wallet,
+    plaintext: bigint,
+    contractAddress: string,
+    functionSelector: string
+): Promise<itUint256> {
+    const info = wallet.getUserOnboardInfo()
+    if (!info?.aesKey) {
+        throw new Error("Wallet not onboarded: missing aesKey")
+    }
+    return prepareIT256(plaintext, { wallet, userKey: info.aesKey }, contractAddress, functionSelector)
+}
+
+/** Decrypt `ctUint256` from `balanceOf` / allowance views. */
+export function decryptCtUint256(
+    wallet: Wallet,
+    ct: ctUint256 | readonly [bigint, bigint] | { ciphertextHigh: bigint; ciphertextLow: bigint }
+): bigint {
+    const info = wallet.getUserOnboardInfo()
+    if (!info?.aesKey) {
+        throw new Error("Wallet not onboarded: missing aesKey")
+    }
+    const normalized = toCtUint256(ct)
+    if (isZeroCt(normalized)) {
+        return 0n
+    }
+    return decryptUint256(normalized, info.aesKey)
+}
+
+/**
+ * COTI testnet often omits revert data on eth_call; Hardhat custom-error matchers also fail when
+ * sendTransaction receipts lack data. Use this for "must revert" smoke checks.
+ */
+export async function expectTxFails(txPromise: Promise<ContractTransactionResponse>): Promise<void> {
+    try {
+        const tx = await txPromise
+        await tx.wait()
+        expect.fail("expected transaction to revert")
+    } catch (e) {
+        expect(e).to.be.ok
+    }
+}