@coti-io/coti-contracts 0.1.0 → 1.0.0

package/contracts/utils/mpc/MpcInterface.sol

@@ -12,15 +12,16 @@ interface ExtendedOperations {
     function RandBoundedBits(bytes1 metaData, uint8 numBits) external returns (uint256 result);
 
     function Add(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
+    function CheckedAdd(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 overflowBit, uint256 result);
     function Sub(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
+    function CheckedSub(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 overflowBit, uint256 result);
     function Mul(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
+    function CheckedMul(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 overflowBit, uint256 result);
     function Div(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Rem(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function And(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Or(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Xor(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
-    function Shl(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
-    function Shr(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Eq(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Ne(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function Ge(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
@@ -33,9 +34,10 @@ interface ExtendedOperations {
     function Mux(bytes3 metaData, uint256 bit, uint256 a,uint256 b) external returns (uint256 result);
     function Not(bytes1 metaData, uint256 a) external returns (uint256 result);
     function Transfer(bytes4 metaData, uint256 a, uint256 b, uint256 amount) external returns (uint256 new_a, uint256 new_b, uint256 res);
-    function TransferWithAllowance(bytes4 metaData, uint256 a, uint256 b, uint256 amount, uint256 allowance) external returns (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance);
+    function TransferWithAllowance(bytes5 metaData, uint256 a, uint256 b, uint256 amount, uint256 allowance) external returns (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance);
     function ValidateCiphertext(bytes1 metaData, uint256 ciphertext, bytes calldata signature) external returns (uint256 result);
-    function GetUserKey(bytes calldata signedEK) external view returns (bytes memory encryptedKey);
+    function GetUserKey(bytes calldata signedEK) external returns (bytes memory encryptedKey);
+    function DeleteUserKey(bytes calldata signature) external returns (bool);
 }
 
 address constant MPC_PRECOMPILE = address(0x0000000000000000000000000000000000000064);

package/hardhat.config.ts

@@ -5,14 +5,17 @@ import dotenv from "dotenv"
 dotenv.config()
 
 const config: HardhatUserConfig = {
-  defaultNetwork: "devnet",
+  defaultNetwork: "testnet",
   solidity: "0.8.20",
   networks: {
-    devnet: {
-      url: "https://devnet.coti.io/rpc",
-      chainId: 13068200,
+    testnet: {
+      url: "https://testnet.coti.io/rpc",
+      chainId: 7082400,
     },
-  }
+  },
+  mocha: {
+    timeout: 100000000
+  },
 }
 
 export default config;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@coti-io/coti-contracts",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "",
   "devDependencies": {
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "hardhat": "^2.22.8"
   },
   "dependencies": {
-    "@coti-io/coti-ethers": "^0.1.1-b",
+    "@coti-io/coti-ethers": "^1.0.1-b",
     "@openzeppelin/contracts": "^5.0.2",
     "dotenv": "^16.4.5"
   }

package/test/utils/accounts.ts

@@ -4,7 +4,7 @@ import { CotiNetwork, getDefaultProvider, parseEther, Wallet } from "@coti-io/co
 let pks = process.env.SIGNING_KEYS ? process.env.SIGNING_KEYS.split(",") : []
 
 export async function setupAccounts() {
-  const provider = getDefaultProvider(CotiNetwork.Devnet);
+  const provider = getDefaultProvider(CotiNetwork.Testnet);
 
   if (pks.length == 0) {
     const key1 = Wallet.createRandom(provider)

package/test/utils/mpc/Precompile.test.ts

@@ -15,13 +15,13 @@ function buildTest(
   it(`${contractName}.${func}(${params}) should return ${expectedResults}`, async function () {
     const [owner] = await setupAccounts()
 
-    const factory = await hre.ethers.getContractFactory(contractName, owner)
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
     const contract = await factory.deploy({ gasLimit })
     await contract.waitForDeployment()
 
     await (await contract.getFunction(func)(...params, { gasLimit })).wait()
     const result = await contract.getFunction(resFunc)()
-    if (resFunc === "getRandom") {
+    if (resFunc === "getRandom" || resFunc === "getRandomBounded") {
       expect(result).to.not.equal(expectedResults[0])
       last_random_value = result
     } else if (expectedResults.length === 1) {
@@ -36,7 +36,7 @@ function buildTestWithUser(contractName: string, func: string, resFunc: string,
   it(`${contractName}.${func}(${params}, <address>) should return the correct user decrypted value`, async function () {
     const [owner] = await setupAccounts()
 
-    const factory = await hre.ethers.getContractFactory(contractName, owner)
+    const factory = await hre.ethers.getContractFactory(contractName, owner as any)
     const contract = await factory.deploy({ gasLimit })
     await contract.waitForDeployment()
 
@@ -56,46 +56,35 @@ const bool_a = true
 const bool_b = false
 const [a, b] = params
 describe("Precompile", function () {
-  buildTest("ArithmeticTestsContract", "addTest", "getResult", params, a + b)
-  buildTest("ArithmeticTestsContract", "subTest", "getResult", params, a - b)
-  buildTest("ArithmeticTestsContract", "mulTest", "getResult16", params, a * b)
-
-  buildTest("Miscellaneous2TestsContract", "divTest", "getResult", params, a / b)
-  buildTest("Miscellaneous2TestsContract", "remTest", "getResult", params, a % b)
-
-  buildTest("BitwiseTestsContract", "andTest", "getResult", params, a & b)
-  buildTest("BitwiseTestsContract", "orTest", "getResult", params, a | b)
-  buildTest("BitwiseTestsContract", "xorTest", "getResult", params, a ^ b)
-
-  buildTest(
-    "ShiftTestsContract",
-    "shlTest",
-    "getAllShiftResults",
-    [a, shift],
-    ...[2, 4, 8, 16].map((x) => BigInt(a << shift) & BigInt(`0x${"f".repeat(x)}`))
-  )
-  buildTest("ShiftTestsContract", "shrTest", "getResult", params, a >> b)
-
-  buildTest("MinMaxTestsContract", "minTest", "getResult", params, Math.min(a, b))
-  buildTest("MinMaxTestsContract", "maxTest", "getResult", params, Math.max(a, b))
-  buildTest("Comparison2TestsContract", "eqTest", "getResult", params, a == b)
-  buildTest("Comparison2TestsContract", "neTest", "getResult", params, a != b)
-  buildTest("Comparison2TestsContract", "geTest", "getResult", params, a >= b)
-  buildTest("Comparison1TestsContract", "gtTest", "getResult", params, a > b)
-  buildTest("Comparison1TestsContract", "leTest", "getResult", params, a <= b)
-  buildTest("Comparison1TestsContract", "ltTest", "getResult", params, a < b)
-  buildTest("Miscellaneous2TestsContract", "muxTest", "getResult", [bit, a, b], bit === false ? a : b)
+  buildTest("ArithmeticTestsContract", "addTest", "getAddResult", params, a + b)
+  buildTest("ArithmeticTestsContract", "subTest", "getSubResult", params, a - b)
+  buildTest("ArithmeticTestsContract", "mulTest", "getMulResult", params, a * b)
+
+  buildTest("MiscellaneousTestsContract", "divTest", "getDivResult", params, a / b)
+  buildTest("MiscellaneousTestsContract", "remTest", "getRemResult", params, a % b)
+
+  buildTest("BitwiseTestsContract", "andTest", "getAndResult", params, a & b)
+  buildTest("BitwiseTestsContract", "orTest", "getOrResult", params, a | b)
+  buildTest("BitwiseTestsContract", "xorTest", "getXorResult", params, a ^ b)
+
+  buildTest("MinMaxTestsContract", "minTest", "getMinResult", params, Math.min(a, b))
+  buildTest("MinMaxTestsContract", "maxTest", "getMaxResult", params, Math.max(a, b))
+  buildTest("Comparison2TestsContract", "eqTest", "getEqResult", params, a == b)
+  buildTest("Comparison2TestsContract", "neTest", "getNeResult", params, a != b)
+  buildTest("Comparison2TestsContract", "geTest", "getGeResult", params, a >= b)
+  buildTest("Comparison1TestsContract", "gtTest", "getGtResult", params, a > b)
+  buildTest("Comparison1TestsContract", "leTest", "getLeResult", params, a <= b)
+  buildTest("Comparison1TestsContract", "ltTest", "getLtResult", params, a < b)
+  buildTest("MiscellaneousTestsContract", "muxTest", "getMuxResult", [bit, a, b], bit === false ? a : b)
 
   buildTest("TransferTestsContract", "transferTest", "getResults", [a, b, b], a - b, b + b, true)
   buildTest("TransferScalarTestsContract", "transferScalarTest", "getResults", [a, b, b], a - b, b + b, true)
-
-  buildTest("Miscellaneous2TestsContract", "offboardOnboardTest", "getResult", [a, a, a, a], a)
-  buildTest("Miscellaneous2TestsContract", "notTest", "getBoolResult", [!!a], !a)
+  buildTest("OffboardToUserKeyTestContract", "offboardOnboardTest", "getOnboardOffboardResult", [a, a, a, a], a)
+  buildTest("MiscellaneousTestsContract", "notTest", "getBoolResult", [!!a], !a)
 
   buildTestWithUser("OffboardToUserKeyTestContract", "offboardToUserTest", "getCTs", a)
-
   buildTest("Miscellaneous1TestsContract", "randomTest", "getRandom", [], last_random_value)
-  buildTest("Miscellaneous1TestsContract", "randomBoundedTest", "getRandom", [numBits], last_random_value)
+  buildTest("Miscellaneous1TestsContract", "randomBoundedTest", "getRandomBounded", [numBits], last_random_value)
   buildTest(
     "Miscellaneous1TestsContract",
     "booleanTest",

package/typechain-types/contracts/mocks/utils/mpc/ArithmeticTestsContract.sol/ArithmeticTestsContract.ts

@@ -0,0 +1,374 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../../../common";
+
+export declare namespace ArithmeticTestsContract {
+  export type Check16Struct = {
+    res16_16: BigNumberish;
+    res8_16: BigNumberish;
+    res16_8: BigNumberish;
+  };
+
+  export type Check16StructOutput = [
+    res16_16: bigint,
+    res8_16: bigint,
+    res16_8: bigint
+  ] & { res16_16: bigint; res8_16: bigint; res16_8: bigint };
+
+  export type Check32Struct = {
+    res32_32: BigNumberish;
+    res8_32: BigNumberish;
+    res32_8: BigNumberish;
+    res16_32: BigNumberish;
+    res32_16: BigNumberish;
+  };
+
+  export type Check32StructOutput = [
+    res32_32: bigint,
+    res8_32: bigint,
+    res32_8: bigint,
+    res16_32: bigint,
+    res32_16: bigint
+  ] & {
+    res32_32: bigint;
+    res8_32: bigint;
+    res32_8: bigint;
+    res16_32: bigint;
+    res32_16: bigint;
+  };
+
+  export type Check64Struct = {
+    res64_64: BigNumberish;
+    res8_64: BigNumberish;
+    res64_8: BigNumberish;
+    res16_64: BigNumberish;
+    res64_16: BigNumberish;
+    res32_64: BigNumberish;
+    res64_32: BigNumberish;
+  };
+
+  export type Check64StructOutput = [
+    res64_64: bigint,
+    res8_64: bigint,
+    res64_8: bigint,
+    res16_64: bigint,
+    res64_16: bigint,
+    res32_64: bigint,
+    res64_32: bigint
+  ] & {
+    res64_64: bigint;
+    res8_64: bigint;
+    res64_8: bigint;
+    res16_64: bigint;
+    res64_16: bigint;
+    res32_64: bigint;
+    res64_32: bigint;
+  };
+
+  export type AllGTCastingValuesStruct = {
+    a8_s: BigNumberish;
+    b8_s: BigNumberish;
+    a16_s: BigNumberish;
+    b16_s: BigNumberish;
+    a32_s: BigNumberish;
+    b32_s: BigNumberish;
+    a64_s: BigNumberish;
+    b64_s: BigNumberish;
+  };
+
+  export type AllGTCastingValuesStructOutput = [
+    a8_s: bigint,
+    b8_s: bigint,
+    a16_s: bigint,
+    b16_s: bigint,
+    a32_s: bigint,
+    b32_s: bigint,
+    a64_s: bigint,
+    b64_s: bigint
+  ] & {
+    a8_s: bigint;
+    b8_s: bigint;
+    a16_s: bigint;
+    b16_s: bigint;
+    a32_s: bigint;
+    b32_s: bigint;
+    a64_s: bigint;
+    b64_s: bigint;
+  };
+}
+
+export interface ArithmeticTestsContractInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "addTest"
+      | "decryptAndCompareResults16"
+      | "decryptAndCompareResults32"
+      | "decryptAndCompareResults64"
+      | "getAddResult"
+      | "getMulResult"
+      | "getSubResult"
+      | "mulTest"
+      | "setPublicValues"
+      | "subTest"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "addTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "decryptAndCompareResults16",
+    values: [ArithmeticTestsContract.Check16Struct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "decryptAndCompareResults32",
+    values: [ArithmeticTestsContract.Check32Struct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "decryptAndCompareResults64",
+    values: [ArithmeticTestsContract.Check64Struct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAddResult",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getMulResult",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSubResult",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mulTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setPublicValues",
+    values: [
+      ArithmeticTestsContract.AllGTCastingValuesStruct,
+      BigNumberish,
+      BigNumberish
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "subTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "addTest", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "decryptAndCompareResults16",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "decryptAndCompareResults32",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "decryptAndCompareResults64",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getAddResult",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getMulResult",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSubResult",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "mulTest", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setPublicValues",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "subTest", data: BytesLike): Result;
+}
+
+export interface ArithmeticTestsContract extends BaseContract {
+  connect(runner?: ContractRunner | null): ArithmeticTestsContract;
+  waitForDeployment(): Promise<this>;
+
+  interface: ArithmeticTestsContractInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  addTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  decryptAndCompareResults16: TypedContractMethod<
+    [check16: ArithmeticTestsContract.Check16Struct],
+    [bigint],
+    "nonpayable"
+  >;
+
+  decryptAndCompareResults32: TypedContractMethod<
+    [check32: ArithmeticTestsContract.Check32Struct],
+    [bigint],
+    "nonpayable"
+  >;
+
+  decryptAndCompareResults64: TypedContractMethod<
+    [check64: ArithmeticTestsContract.Check64Struct],
+    [bigint],
+    "nonpayable"
+  >;
+
+  getAddResult: TypedContractMethod<[], [bigint], "view">;
+
+  getMulResult: TypedContractMethod<[], [bigint], "view">;
+
+  getSubResult: TypedContractMethod<[], [bigint], "view">;
+
+  mulTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  setPublicValues: TypedContractMethod<
+    [
+      castingValues: ArithmeticTestsContract.AllGTCastingValuesStruct,
+      a: BigNumberish,
+      b: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  subTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "addTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "decryptAndCompareResults16"
+  ): TypedContractMethod<
+    [check16: ArithmeticTestsContract.Check16Struct],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "decryptAndCompareResults32"
+  ): TypedContractMethod<
+    [check32: ArithmeticTestsContract.Check32Struct],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "decryptAndCompareResults64"
+  ): TypedContractMethod<
+    [check64: ArithmeticTestsContract.Check64Struct],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "getAddResult"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getMulResult"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getSubResult"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "mulTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setPublicValues"
+  ): TypedContractMethod<
+    [
+      castingValues: ArithmeticTestsContract.AllGTCastingValuesStruct,
+      a: BigNumberish,
+      b: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "subTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  filters: {};
+}