@coti-io/coti-contracts 1.0.9 → 1.2.0

package/test/utils/mpc/Precompile128.test.ts

@@ -0,0 +1,51 @@
+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[],
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return ${expectedResult}`, async function () {
+    const [owner] = await setupAccounts()
+    const provider = owner.provider!
+    const network = await provider.getNetwork()
+
+    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 result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const params = [
+  BigInt("1000000000000000000"),  // 1e18 (fits in uint128)
+  BigInt("500000000000000000")    // 0.5e18
+]
+const [a, b] = params
+
+describe("Precompile 128-bit", function () {
+  buildTest("Arithmetic128TestsContract", "addTest", "getAddResult", params, a + b)
+  buildTest("Arithmetic128TestsContract", "checkedAddTest", "getAddResult", params, a + b)
+  buildTest("Arithmetic128TestsContract", "subTest", "getSubResult", params, a - b)
+  buildTest("Arithmetic128TestsContract", "checkedSubTest", "getSubResult", params, a - b)
+  buildTest("Arithmetic128TestsContract", "mulTest", "getMulResult", params, a * b)
+  buildTest("Arithmetic128TestsContract", "checkedMulTest", "getMulResult", params, a * b)
+  buildTest("Arithmetic128TestsContract", "divTest", "getDivResult", params, a / b)
+  buildTest("Arithmetic128TestsContract", "remTest", "getRemResult", params, a % b)
+})
+

package/test/utils/mpc/Precompile256.test.ts

@@ -0,0 +1,115 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+
+// Track if we've logged the deployment transaction
+let deploymentLogged = false
+
+function logTransaction(
+  txHash: string,
+  blockNumber: number,
+  contractAddress: string,
+  functionName: string,
+  networkName: string,
+  chainId: bigint,
+  gasUsed?: bigint
+) {
+  console.log("\n" + "=".repeat(80))
+  console.log(`📝 ON-CHAIN TRANSACTION - ${functionName}`)
+  console.log("=".repeat(80))
+  console.log(`Transaction Hash: ${txHash}`)
+  console.log(`Block Number: ${blockNumber}`)
+  console.log(`Contract Address: ${contractAddress}`)
+  console.log(`Network: ${networkName}`)
+  console.log(`Chain ID: ${chainId.toString()}`)
+  if (gasUsed) {
+    console.log(`Gas Used: ${gasUsed.toString()}`)
+  }
+  console.log("=".repeat(80) + "\n")
+}
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: bigint[],
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return ${expectedResult}`, async function () {
+    const [owner] = await setupAccounts()
+    const provider = owner.provider!
+    const network = await provider.getNetwork()
+    const networkName = hre.network.name
+
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
+    const contract = await factory.deploy({ gasLimit })
+    await contract.waitForDeployment()
+    
+    const contractAddress = await contract.getAddress()
+
+    // Log deployment transaction (first transaction only)
+    if (!deploymentLogged) {
+      const deployTx = contract.deploymentTransaction()
+      if (deployTx) {
+        const deployReceipt = await deployTx.wait()
+        if (deployReceipt) {
+          logTransaction(
+            deployReceipt.hash,
+            deployReceipt.blockNumber,
+            contractAddress,
+            "Contract Deployment",
+            networkName,
+            network.chainId,
+            deployReceipt.gasUsed
+          )
+          deploymentLogged = true
+        }
+      }
+    }
+
+    // Execute the function and log the transaction
+    const tx = await contract.getFunction(func)(...params, { gasLimit })
+    const receipt = await tx.wait()
+    
+    if (receipt) {
+      logTransaction(
+        receipt.hash,
+        receipt.blockNumber,
+        contractAddress,
+        `${contractName}.${func}`,
+        networkName,
+        network.chainId,
+        receipt.gasUsed
+      )
+    }
+
+    // Verify the result
+    const result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    // Additional verification: Check transaction exists on-chain
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.blockNumber).to.equal(receipt.blockNumber)
+    expect(txFromChain?.status).to.equal(1) // 1 = success
+  })
+}
+
+const params = [
+  BigInt("1000000000000000000"),  // 1e18
+  BigInt("500000000000000000")    // 0.5e18
+]
+const [a, b] = params
+
+describe("Precompile 256-bit", function () {
+  buildTest("Arithmetic256TestsContract", "addTest", "getAddResult", params, a + b)
+  buildTest("Arithmetic256TestsContract", "checkedAddTest", "getAddResult", params, a + b)
+  buildTest("Arithmetic256TestsContract", "subTest", "getSubResult", params, a - b)
+  buildTest("Arithmetic256TestsContract", "checkedSubTest", "getSubResult", params, a - b)
+  buildTest("Arithmetic256TestsContract", "mulTest", "getMulResult", params, a * b)
+  buildTest("Arithmetic256TestsContract", "checkedMulTest", "getMulResult", params, a * b)
+  buildTest("Arithmetic256TestsContract", "divTest", "getDivResult", params, a / b)
+  buildTest("Arithmetic256TestsContract", "remTest", "getRemResult", params, a % b)
+})

package/test/utils/mpc/ProxyValidation.test.ts

@@ -0,0 +1,199 @@
+
+import { expect } from "chai";
+import hre from "hardhat";
+import { Wallet } from "@coti-io/coti-ethers";
+import type { MinimalProxy, MinimalImplementation } from "../../../typechain-types";
+
+const GAS_LIMIT = 12000000;
+
+/**
+ * Test: 200-bit numbers through proxy with offBoardToUser and storage verification
+ */
+describe("Proxy Validation - 200-bit Numbers Test", function () {
+    let proxy: MinimalProxy;
+    let implementation: MinimalImplementation;
+    let proxyAsImpl: MinimalImplementation;
+    let owner: Wallet;
+
+    this.timeout(120000);
+
+    before(async function () {
+        // Get only the first account to avoid insufficient funds issue
+        const pks = process.env.SIGNING_KEYS ? process.env.SIGNING_KEYS.split(",") : [];
+        if (pks.length === 0) {
+            throw new Error("No signing keys found in .env");
+        }
+
+        const provider = hre.ethers.provider;
+        owner = new Wallet(pks[0], provider);
+        
+        // Check if we need to onboard
+        const userKeys = process.env.USER_KEYS ? process.env.USER_KEYS.split(",") : [];
+        if (userKeys.length > 0 && userKeys[0]) {
+            owner.setAesKey(userKeys[0]);
+        } else {
+            console.log("************* Onboarding user", owner.address, "*************");
+            await owner.generateOrRecoverAes();
+            console.log("************* Onboarded! *************");
+        }
+
+        if (!owner.getUserOnboardInfo()?.aesKey) {
+            throw new Error("Owner AES key not found");
+        }
+
+        // Deploy implementation
+        const ImplFactory = await hre.ethers.getContractFactory("MinimalImplementation", owner as any);
+        implementation = await ImplFactory.deploy({ gasLimit: GAS_LIMIT });
+        await implementation.waitForDeployment();
+        const implAddress = await implementation.getAddress();
+
+        // Deploy proxy
+        const ProxyFactory = await hre.ethers.getContractFactory("MinimalProxy", owner as any);
+        proxy = await ProxyFactory.deploy(implAddress, { gasLimit: GAS_LIMIT });
+        await proxy.waitForDeployment();
+        const proxyAddress = await proxy.getAddress();
+
+        // Create interface to call proxy as implementation
+        proxyAsImpl = await hre.ethers.getContractAt(
+            "MinimalImplementation",
+            proxyAddress,
+            owner as any
+        ) as MinimalImplementation;
+
+        console.log("\n" + "=".repeat(80));
+        console.log("COMPLETE FLOW TEST: Encrypt → Validate → Add → OffBoard → Store → Decrypt");
+        console.log("=".repeat(80));
+        console.log(`Proxy:          ${proxyAddress}`);
+        console.log(`Implementation: ${implAddress}`);
+        console.log("=".repeat(80) + "\n");
+    });
+
+    it("✅ Full cycle with 200-bit numbers: Encrypt → Add → Store → Decrypt", async function () {
+        const proxyAddress = await proxy.getAddress();
+        const selector = proxyAsImpl.interface.getFunction("addAndStore")!.selector;
+        
+        // Use 200-bit numbers (larger than 128-bit but < 256-bit)
+        const valueA = (2n ** 199n) + 123456789n; // ~200 bits
+        const valueB = (2n ** 198n) + 987654321n; // ~199 bits
+        const expected = valueA + valueB;
+        
+        console.log("=" .repeat(80));
+        console.log("STEP 1: ENCRYPT OFFCHAIN");
+        console.log("=".repeat(80));
+        console.log(`Value A (200-bit): ${valueA.toString()}`);
+        console.log(`Bit length:        ${valueA.toString(2).length} bits`);
+        console.log(`Value B (199-bit): ${valueB.toString()}`);
+        console.log(`Bit length:        ${valueB.toString(2).length} bits`);
+        console.log(`Expected A + B:    ${expected.toString()}`);
+        console.log(`Bit length:        ${expected.toString(2).length} bits`);
+        console.log(`Signed for:        ${proxyAddress} (PROXY)`);
+        console.log("");
+        
+        // Encrypt values offchain
+        console.log("Encrypting values offchain using coti-ethers...");
+        const encA = await owner.encryptValue256(valueA, proxyAddress, selector);
+        const encB = await owner.encryptValue256(valueB, proxyAddress, selector);
+        console.log("✅ Encryption complete");
+        console.log(`   encA.ciphertext.high: ${encA.ciphertext.ciphertextHigh.toString()}`);
+        console.log(`   encA.ciphertext.low:  ${encA.ciphertext.ciphertextLow.toString()}`);
+        console.log(`   encB.ciphertext.high: ${encB.ciphertext.ciphertextHigh.toString()}`);
+        console.log(`   encB.ciphertext.low:  ${encB.ciphertext.ciphertextLow.toString()}`);
+        console.log("");
+        
+        console.log("=".repeat(80));
+        console.log("STEP 2: SEND TRANSACTION (Validate → Add → OffBoard → Store)");
+        console.log("=".repeat(80));
+        
+        // Send transaction
+        const tx = await proxyAsImpl.connect(owner).addAndStore(encA, encB, { gasLimit: GAS_LIMIT });
+        console.log(`Transaction hash: ${tx.hash}`);
+        console.log("Waiting for confirmation...");
+        
+        const receipt = await tx.wait();
+        console.log(`✅ Transaction confirmed in block ${receipt?.blockNumber}`);
+        console.log(`   Gas used: ${receipt?.gasUsed.toString()}`);
+        console.log("");
+        
+        // Check events
+        console.log("=".repeat(80));
+        console.log("STEP 3: VERIFY EVENTS");
+        console.log("=".repeat(80));
+        
+        let eventCount = 0;
+        receipt?.logs.forEach((log: any) => {
+            try {
+                const parsed = implementation.interface.parseLog({ topics: log.topics as string[], data: log.data });
+                if (parsed) {
+                    eventCount++;
+                    console.log(`✅ Event ${eventCount}: ${parsed.name}`);
+                    console.log(`   Message: ${parsed.args[1]}`);
+                }
+            } catch (e) {}
+        });
+        console.log("");
+        
+        expect(eventCount).to.be.greaterThan(0, "No events emitted - validation may have failed");
+        
+        console.log("=".repeat(80));
+        console.log("STEP 4: READ FROM STORAGE");
+        console.log("=".repeat(80));
+        
+        // Read the stored ctUint256 from storage
+        console.log("Reading stored result from contract storage...");
+        const storedCt = await proxyAsImpl.connect(owner).getStoredResult();
+        console.log("✅ Storage read complete");
+        console.log(`   Stored CT High: ${storedCt.ciphertextHigh.toString()}`);
+        console.log(`   Stored CT Low:  ${storedCt.ciphertextLow.toString()}`);
+        console.log("");
+        
+        console.log("=".repeat(80));
+        console.log("STEP 5: DECRYPT OFFCHAIN");
+        console.log("=".repeat(80));
+        
+        // Decrypt the result offchain
+        console.log("Decrypting result offchain using coti-ethers...");
+        // Explicitly format the struct to ensure correct format
+        const decrypted = await owner.decryptValue256({
+            ciphertextHigh: storedCt.ciphertextHigh,
+            ciphertextLow: storedCt.ciphertextLow
+        });
+        console.log("✅ Decryption complete");
+        console.log(`   Decrypted value: ${decrypted.toString()}`);
+        console.log("");
+        
+        console.log("=".repeat(80));
+        console.log("STEP 6: VERIFY CORRECTNESS");
+        console.log("=".repeat(80));
+        console.log(`Original A:      ${valueA.toString()}`);
+        console.log(`Original B:      ${valueB.toString()}`);
+        console.log(`Expected A + B:  ${expected.toString()}`);
+        console.log(`Decrypted result: ${decrypted.toString()}`);
+        console.log("");
+        
+        expect(decrypted).to.equal(expected, "Decrypted result does not match expected");
+        
+        console.log("✅ VERIFICATION PASSED!");
+        console.log("");
+        console.log("=".repeat(80));
+        console.log("SUMMARY");
+        console.log("=".repeat(80));
+        console.log("✅ 200-bit numbers encrypted offchain");
+        console.log("✅ IT-types validated through proxy");
+        console.log("✅ Addition performed on encrypted values");
+        console.log("✅ Result offBoarded to user (ctUint256)");
+        console.log("✅ Result stored in contract storage");
+        console.log("✅ Result read from storage");
+        console.log("✅ Result decrypted offchain");
+        console.log("✅ Decrypted value matches expected");
+        console.log("");
+        console.log("CONCLUSION: IT-types + proxy + large numbers = ✅ WORKS PERFECTLY!");
+        console.log("=".repeat(80) + "\n");
+    });
+
+    // Comment out other tests as requested
+    /*
+    it("❌ TEST 2: Wrong signing for implementation address", async function () {
+        // ... test code ...
+    });
+    */
+});

package/test/utils/mpc/Random128.test.ts

@@ -0,0 +1,47 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+let last_random_value = BigInt(0)
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: (bigint | number)[],
+  expectedResult?: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return a random value`, 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 result = await contract.getFunction(resFunc)()
+    
+    if (resFunc === "getRandom" || resFunc === "getRandomBounded") {
+      expect(result).to.not.equal(expectedResult || last_random_value)
+      last_random_value = result
+    } else {
+      expect(result).to.equal(expectedResult)
+    }
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const numBits = 7
+
+describe("Random 128-bit", function () {
+  buildTest("Random128TestsContract", "randomTest", "getRandom", [], last_random_value)
+  buildTest("Random128TestsContract", "randomBoundedTest", "getRandomBounded", [numBits], last_random_value)
+})
+

package/test/utils/mpc/Random256.test.ts

@@ -0,0 +1,47 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+let last_random_value = BigInt(0)
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: (bigint | number)[],
+  expectedResult?: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return a random value`, 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 result = await contract.getFunction(resFunc)()
+    
+    if (resFunc === "getRandom" || resFunc === "getRandomBounded") {
+      expect(result).to.not.equal(expectedResult || last_random_value)
+      last_random_value = result
+    } else {
+      expect(result).to.equal(expectedResult)
+    }
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const numBits = 7
+
+describe("Random 256-bit", function () {
+  buildTest("Random256TestsContract", "randomTest", "getRandom", [], last_random_value)
+  buildTest("Random256TestsContract", "randomBoundedTest", "getRandomBounded", [numBits], last_random_value)
+})
+

package/test/utils/mpc/Shift128.test.ts

@@ -0,0 +1,41 @@
+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 | number)[],
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return ${expectedResult}`, 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 result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const a = BigInt("1000000000000000000")
+const shift = 2
+
+describe("Shift 128-bit", function () {
+  buildTest("Shift128TestsContract", "shlTest", "getShlResult", [a, shift], a << BigInt(shift))
+  buildTest("Shift128TestsContract", "shrTest", "getShrResult", [a, shift], a >> BigInt(shift))
+})
+

package/test/utils/mpc/Shift256.test.ts

@@ -0,0 +1,41 @@
+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 | number)[],
+  expectedResult: bigint
+) {
+  it(`${contractName}.${func}(${params}) should return ${expectedResult}`, 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 result = await contract.getFunction(resFunc)()
+    expect(result).to.equal(expectedResult)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const a = BigInt("1000000000000000000")
+const shift = 2
+
+describe("Shift 256-bit", function () {
+  buildTest("Shift256TestsContract", "shlTest", "getShlResult", [a, shift], a << BigInt(shift))
+  buildTest("Shift256TestsContract", "shrTest", "getShrResult", [a, shift], a >> BigInt(shift))
+})
+

package/test/utils/mpc/Transfer128.test.ts

@@ -0,0 +1,46 @@
+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]
+) {
+  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])
+    
+    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")
+]
+const [a, b, amount] = params
+
+describe("Transfer 128-bit", function () {
+  buildTest("Transfer128TestsContract", "transferTest", "getResults", params, [a - amount, b + amount, true])
+})
+

package/test/utils/mpc/Transfer256.test.ts

@@ -0,0 +1,46 @@
+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]
+) {
+  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]) // newA
+    expect(results[1]).to.equal(expectedResults[1]) // newB
+    expect(results[2]).to.equal(expectedResults[2]) // result (success)
+    
+    const txFromChain = await provider.getTransactionReceipt(receipt.hash)
+    expect(txFromChain).to.not.be.null
+    expect(txFromChain?.status).to.equal(1)
+  })
+}
+
+const params = [
+  BigInt("1000000000000000000"),  // a = 1e18
+  BigInt("500000000000000000"),   // b = 0.5e18
+  BigInt("200000000000000000")    // amount = 0.2e18
+]
+const [a, b, amount] = params
+
+describe("Transfer 256-bit", function () {
+  buildTest("Transfer256TestsContract", "transferTest", "getResults", params, [a - amount, b + amount, true])
+})
+

package/test/utils/mpc/TransferWithAllowance128.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 128-bit", function () {
+  buildTest("TransferWithAllowance128TestsContract", "transferWithAllowanceTest", "getResults", params, [a - amount, b + amount, true, allowance - amount])
+})
+