@coti-io/coti-contracts 1.1.0 → 1.2.0

package/test/utils/mpc/TransferWithAllowance256.test.ts

@@ -0,0 +1,48 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: bigint[],
+  expectedResults: [bigint, bigint, boolean, bigint]
+) {
+  it(`${contractName}.${func}(${params}) should return correct transfer results`, async function () {
+    const [owner] = await setupAccounts()
+    const provider = owner.provider!
+
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
+    const contract = await factory.deploy({ gasLimit })
+    await contract.waitForDeployment()
+
+    const tx = await contract.getFunction(func)(...params, { gasLimit })
+    const receipt = await tx.wait()
+    
+    const results = await contract.getFunction(resFunc)()
+    expect(results[0]).to.equal(expectedResults[0])
+    expect(results[1]).to.equal(expectedResults[1])
+    expect(results[2]).to.equal(expectedResults[2])
+    expect(results[3]).to.equal(expectedResults[3])
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const params = [
+  BigInt("1000000000000000000"),
+  BigInt("500000000000000000"),
+  BigInt("200000000000000000"),
+  BigInt("1000000000000000000")
+]
+const [a, b, amount, allowance] = params
+
+describe("TransferWithAllowance 256-bit", function () {
+  buildTest("TransferWithAllowance256TestsContract", "transferWithAllowanceTest", "getResults", params, [a - amount, b + amount, true, allowance - amount])
+})
+

package/test/utils/mpc/UpgradeablePrivacyProxy.test.ts

@@ -0,0 +1,307 @@
+import { expect } from "chai";
+import hre from "hardhat";
+import { Wallet } from "@coti-io/coti-ethers";
+import { setupAccounts } from "../accounts";
+import type {
+    PrivacyProxy,
+    PrivacyImplementationV1,
+    PrivacyImplementationV2,
+} from "../../../typechain-types";
+
+const GAS_LIMIT = 12000000;
+
+describe("Upgradeable Privacy Proxy with Encrypted Data", function () {
+    let proxy: PrivacyProxy;
+    let implementationV1: PrivacyImplementationV1;
+    let implementationV2: PrivacyImplementationV2;
+    let proxyAsV1: PrivacyImplementationV1;
+    let proxyAsV2: PrivacyImplementationV2;
+    let owner: Wallet;
+    let user1: Wallet;
+
+    // Increase timeout for MPC operations
+    this.timeout(240000);
+
+    before(async function () {
+        const accounts = await setupAccounts();
+        owner = accounts[0];
+        user1 = accounts[1];
+
+        // Verify wallets have AES keys
+        const ownerInfo = owner.getUserOnboardInfo();
+        const user1Info = user1.getUserOnboardInfo();
+        
+        if (!ownerInfo || !ownerInfo.aesKey) {
+            throw new Error("Owner AES key not found. Please onboard the owner first.");
+        }
+        if (!user1Info || !user1Info.aesKey) {
+            throw new Error("User1 AES key not found. Please onboard the user first.");
+        }
+
+        console.log("\n" + "=".repeat(80));
+        console.log("🔄 UPGRADEABLE PRIVACY PROXY TEST");
+        console.log("=".repeat(80));
+        console.log("Owner address:", owner.address);
+        console.log("User1 address:", user1.address);
+        console.log("=".repeat(80) + "\n");
+    });
+
+    describe("Proxy Deployment and Initial Setup", function () {
+        it("Should deploy implementation V1", async function () {
+            console.log("\n=== Deploying Implementation V1 ===");
+            
+            const ImplFactory = await hre.ethers.getContractFactory("PrivacyImplementationV1", owner as any);
+            implementationV1 = await ImplFactory.deploy({ gasLimit: GAS_LIMIT });
+            await implementationV1.waitForDeployment();
+            const implAddress = await implementationV1.getAddress();
+            
+            console.log("Implementation V1 deployed to:", implAddress);
+            
+            // Test version
+            const version = await implementationV1.version();
+            expect(version).to.equal("v1");
+            console.log("✅ Implementation V1 version:", version);
+        });
+
+        it("Should deploy proxy pointing to V1", async function () {
+            console.log("\n=== Deploying Proxy ===");
+            
+            const implV1Address = await implementationV1.getAddress();
+            const ProxyFactory = await hre.ethers.getContractFactory("PrivacyProxy", owner as any);
+            proxy = await ProxyFactory.deploy(implV1Address, { gasLimit: GAS_LIMIT });
+            await proxy.waitForDeployment();
+            const proxyAddress = await proxy.getAddress();
+            
+            console.log("Proxy deployed to:", proxyAddress);
+            console.log("Proxy points to implementation:", implV1Address);
+            
+            // Verify implementation
+            const currentImpl = await proxy.implementation();
+            expect(currentImpl).to.equal(implV1Address);
+            
+            // Verify admin
+            const admin = await proxy.admin();
+            expect(admin).to.equal(owner.address);
+            console.log("✅ Proxy admin:", admin);
+            
+            // Create interface to call proxy as V1
+            proxyAsV1 = await hre.ethers.getContractAt(
+                "PrivacyImplementationV1",
+                proxyAddress,
+                owner as any
+            ) as PrivacyImplementationV1;
+            
+            // Test version through proxy
+            const version = await proxyAsV1.version();
+            expect(version).to.equal("v1");
+            console.log("✅ Version through proxy:", version);
+        });
+    });
+
+    describe("Privacy Operations Through Proxy (V1)", function () {
+        it("Should validate IT-type through delegatecall (uint128)", async function () {
+            console.log("\n=== Testing IT-Type Validation Through Proxy ===");
+            
+            const value = 1000n;
+            console.log(`Input value: ${value}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV1.interface.getFunction("storeValue128")!.selector;
+            
+            // Encrypt for PROXY address (not implementation!)
+            const encrypted = await owner.encryptValue(value, proxyAddress, selector);
+            console.log("✅ Encrypted for proxy address");
+            
+            // Call through proxy - delegatecall will execute in proxy's context
+            const tx = await proxyAsV1.connect(owner).storeValue128(encrypted, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - value stored`);
+            console.log(`Stored value: ${value}`);
+            console.log("✅ IT-type validation through delegatecall works! (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+
+        it("Should perform addition through proxy (uint128)", async function () {
+            console.log("\n=== Testing Addition Through Proxy ===");
+            
+            const a = 500n;
+            const b = 300n;
+            const expected = a + b;
+            
+            console.log(`Inputs: ${a} + ${b} = ${expected}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV1.interface.getFunction("add128")!.selector;
+            
+            const encryptedA = await owner.encryptValue(a, proxyAddress, selector);
+            const encryptedB = await owner.encryptValue(b, proxyAddress, selector);
+            
+            // Call add128 - it returns the result but we can't get it from transaction without staticCall
+            // Since staticCall doesn't work on coti-private, we'll verify the transaction succeeded
+            // The function works correctly if the transaction succeeds without reverting
+            const tx = await proxyAsV1.connect(owner).add128(encryptedA, encryptedB, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - addition performed`);
+            console.log(`Expected result: ${expected}`);
+            console.log("✅ Addition through proxy successful (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+
+
+        it("Should work with uint256 through proxy", async function () {
+            console.log("\n=== Testing uint256 Through Proxy ===");
+            
+            const value = 2n ** 128n;
+            console.log(`Input value: ${value}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV1.interface.getFunction("storeValue256")!.selector;
+            
+            const encrypted = await owner.encryptValue256(value, proxyAddress, selector);
+            
+            const tx = await proxyAsV1.connect(owner).storeValue256(encrypted, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - uint256 value stored`);
+            console.log(`Stored value: ${value}`);
+            console.log("✅ uint256 through proxy successful (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+    });
+
+    describe("Proxy Upgrade to V2", function () {
+        it("Should deploy implementation V2", async function () {
+            console.log("\n=== Deploying Implementation V2 ===");
+            
+            const ImplFactory = await hre.ethers.getContractFactory("PrivacyImplementationV2", owner as any);
+            implementationV2 = await ImplFactory.deploy({ gasLimit: GAS_LIMIT });
+            await implementationV2.waitForDeployment();
+            const implAddress = await implementationV2.getAddress();
+            
+            console.log("Implementation V2 deployed to:", implAddress);
+            
+            // Test version
+            const version = await implementationV2.version();
+            expect(version).to.equal("v2");
+            console.log("✅ Implementation V2 version:", version);
+        });
+
+        it("Should upgrade proxy to V2", async function () {
+            console.log("\n=== Upgrading Proxy to V2 ===");
+            
+            const implV2Address = await implementationV2.getAddress();
+            
+            // Upgrade
+            const tx = await proxy.connect(owner).upgradeTo(implV2Address, { gasLimit: GAS_LIMIT });
+            await tx.wait();
+            
+            // Verify upgrade
+            const currentImpl = await proxy.implementation();
+            expect(currentImpl).to.equal(implV2Address);
+            console.log("✅ Proxy upgraded to V2:", implV2Address);
+            
+            // Create interface to call proxy as V2
+            const proxyAddress = await proxy.getAddress();
+            proxyAsV2 = await hre.ethers.getContractAt(
+                "PrivacyImplementationV2",
+                proxyAddress,
+                owner as any
+            ) as PrivacyImplementationV2;
+            
+            // Test version through proxy
+            const version = await proxyAsV2.version();
+            expect(version).to.equal("v2");
+            console.log("✅ Version through upgraded proxy:", version);
+        });
+
+    });
+
+    describe("New Features in V2", function () {
+        it("Should use new subtraction feature in V2", async function () {
+            console.log("\n=== Testing New V2 Feature: Subtraction ===");
+            
+            const a = 1000n;
+            const b = 300n;
+            const expected = a - b;
+            
+            console.log(`Inputs: ${a} - ${b} = ${expected}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV2.interface.getFunction("sub128")!.selector;
+            
+            const encryptedA = await owner.encryptValue(a, proxyAddress, selector);
+            const encryptedB = await owner.encryptValue(b, proxyAddress, selector);
+            
+            // Call sub128 - it returns the result but we can't get it from transaction without staticCall
+            // Since staticCall doesn't work on coti-private, we'll verify the transaction succeeded
+            const tx = await proxyAsV2.connect(owner).sub128(encryptedA, encryptedB, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - subtraction performed`);
+            console.log(`Expected result: ${expected}`);
+            console.log("✅ New V2 subtraction feature works (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+
+        it("Should use new division feature in V2", async function () {
+            console.log("\n=== Testing New V2 Feature: Division ===");
+            
+            const a = 1000n;
+            const b = 10n;
+            const expected = a / b;
+            
+            console.log(`Inputs: ${a} / ${b} = ${expected}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV2.interface.getFunction("div128")!.selector;
+            
+            const encryptedA = await owner.encryptValue(a, proxyAddress, selector);
+            const encryptedB = await owner.encryptValue(b, proxyAddress, selector);
+            
+            // Call div128 - it returns the result but we can't get it from transaction without staticCall
+            // Since staticCall doesn't work on coti-private, we'll verify the transaction succeeded
+            const tx = await proxyAsV2.connect(owner).div128(encryptedA, encryptedB, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - division performed`);
+            console.log(`Expected result: ${expected}`);
+            console.log("✅ New V2 division feature works (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+
+        it("Should still work with V1 functions after upgrade", async function () {
+            console.log("\n=== Testing V1 Functions Still Work in V2 ===");
+            
+            const a = 200n;
+            const b = 100n;
+            const expected = a * b;
+            
+            console.log(`Testing V1 multiplication: ${a} * ${b} = ${expected}`);
+            
+            const proxyAddress = await proxy.getAddress();
+            const selector = proxyAsV2.interface.getFunction("mul128")!.selector;
+            
+            const encryptedA = await owner.encryptValue(a, proxyAddress, selector);
+            const encryptedB = await owner.encryptValue(b, proxyAddress, selector);
+            
+            // Call mul128 - it returns the result but we can't get it from transaction without staticCall
+            // Since staticCall doesn't work on coti-private, we'll verify the transaction succeeded
+            const tx = await proxyAsV2.connect(owner).mul128(encryptedA, encryptedB, { gasLimit: GAS_LIMIT });
+            const receipt = await tx.wait();
+            
+            // Verify transaction succeeded
+            expect(receipt?.status).to.equal(1);
+            console.log(`Transaction succeeded - multiplication performed`);
+            console.log(`Expected result: ${expected}`);
+            console.log("✅ V1 functions still work after upgrade (transaction verified - return value cannot be retrieved without staticCall)");
+        });
+    });
+});
+

package/test/utils/mpc/ValidateCiphertext.test.ts

@@ -0,0 +1,221 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+import { Wallet, itUint, ctUint } from "@coti-io/coti-ethers"
+import { ValidateCiphertextTestsContract } from "../../../typechain-types"
+
+const GAS_LIMIT = 12000000
+
+async function deploy() {
+    const [owner] = await setupAccounts()
+    const contractFactory = await hre.ethers.getContractFactory("ValidateCiphertextTestsContract", owner as any)
+    const contract = await contractFactory.deploy({ gasLimit: GAS_LIMIT })
+    await contract.waitForDeployment()
+    return {
+        contract,
+        contractAddress: await contract.getAddress(),
+        owner
+    }
+}
+
+describe("ValidateCiphertext Tests - 8/16/32/64-bit", function () {
+    this.timeout(60000)
+    let contract: ValidateCiphertextTestsContract
+    let contractAddress: string
+    let owner: Wallet
+
+    before(async function () {
+        const deployment = await deploy()
+        contract = deployment.contract
+        contractAddress = deployment.contractAddress
+        owner = deployment.owner
+    })
+
+    describe("validateAndStore", function () {
+        it("Should validate and store a small value (8-bit)", async function () {
+            const testValue = 100
+            
+            const itUintValue = await owner.encryptValue(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndStore(itUintValue, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            const storedValue = await contract.getStoredValue()
+            expect(storedValue).to.equal(testValue)
+
+            const validationResult = await contract.getValidationResult()
+            expect(validationResult).to.equal(true)
+
+            // Verify we can retrieve the encrypted value
+            const storedEncryptedValue = await contract.getStoredEncryptedValue()
+            // Note: storedEncryptedValue is a ctUint8 which is a uint256, so we just check it's not zero
+            expect(storedEncryptedValue).to.not.be.undefined
+            expect(storedEncryptedValue.toString()).to.not.equal("0")
+        })
+
+        it("Should validate and store a 16-bit value", async function () {
+            const testValue = 1000  // Fits in 16-bit
+            
+            const itUintValue = await owner.encryptValue(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndStore(itUintValue, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            const storedValue = await contract.getStoredValue()
+            // Note: storedValue is uint8, so it will be truncated if > 255
+            if (testValue <= 255) {
+                expect(storedValue).to.equal(testValue)
+            }
+        })
+
+        it("Should validate and store a 32-bit value", async function () {
+            const testValue = 50000  // Fits in 32-bit
+            
+            const itUintValue = await owner.encryptValue(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndStore(itUintValue, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            const storedValue = await contract.getStoredValue()
+            // Note: storedValue is uint8, so it will be truncated if > 255
+            if (testValue <= 255) {
+                expect(storedValue).to.equal(testValue)
+            }
+        })
+
+        it("Should validate and store a 64-bit value", async function () {
+            const testValue = BigInt("1000000000000000000")  // Large 64-bit value
+            
+            const itUintValue = await owner.encryptValue(
+                testValue,
+                contractAddress,
+                contract.validateAndStore.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndStore(itUintValue, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            // Note: storedValue is uint8, so large values will be truncated
+            // But validation should still succeed
+            const validationResult = await contract.getValidationResult()
+            expect(validationResult).to.equal(true)
+        })
+    })
+
+    describe("validateAndReturn", function () {
+        it("Should validate and return encrypted value for user", async function () {
+            const testValue = 100
+            
+            const itUintValue = await owner.encryptValue(
+                testValue,
+                contractAddress,
+                contract.validateAndReturn.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndReturn(itUintValue, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            // Get the result from transaction logs
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+            
+            if (resultEvent) {
+                const parsedLog = contract.interface.parseLog(resultEvent)
+                const ctResult: ctUint = parsedLog?.args.result
+                
+                // User should be able to decrypt the result
+                const decrypted = await owner.decryptValue(ctResult)
+                expect(decrypted).to.equal(testValue)
+            }
+        })
+    })
+
+    describe("validateAndAdd", function () {
+        it("Should validate two values and add them", async function () {
+            const a = 50
+            const b = 30
+            const expected = a + b
+            
+            const itA = await owner.encryptValue(
+                a,
+                contractAddress,
+                contract.validateAndAdd.fragment.selector
+            ) as itUint
+            
+            const itB = await owner.encryptValue(
+                b,
+                contractAddress,
+                contract.validateAndAdd.fragment.selector
+            ) as itUint
+
+            const tx = await contract
+                .connect(owner)
+                .validateAndAdd(itA, itB, { gasLimit: GAS_LIMIT })
+            
+            const receipt = await tx.wait()
+            expect(receipt).to.not.be.null
+            expect(receipt?.status).to.equal(1)
+
+            // Get the result from transaction logs
+            const resultEvent = receipt?.logs.find((log: any) => {
+                try {
+                    return contract.interface.parseLog(log)?.name === "ValueOffBoarded"
+                } catch {
+                    return false
+                }
+            })
+            
+            if (resultEvent) {
+                const parsedLog = contract.interface.parseLog(resultEvent)
+                const ctResult: ctUint = parsedLog?.args.result
+                
+                // User should be able to decrypt the result
+                const decrypted = await owner.decryptValue(ctResult)
+                expect(Number(decrypted)).to.equal(expected)
+            }
+        })
+    })
+})
+