@coti-io/coti-contracts 1.0.0 → 1.0.3

package/contracts/token/PrivateERC721/IERC721Errors.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+interface IERC721Errors {
+    /**
+     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
+     * Used in balance queries.
+     * @param owner Address of the current owner of a token.
+     */
+    error ERC721InvalidOwner(address owner);
+
+    /**
+     * @dev Indicates a `tokenId` whose `owner` is the zero address.
+     * @param tokenId Identifier number of a token.
+     */
+    error ERC721NonexistentToken(uint256 tokenId);
+
+    /**
+     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
+     * @param sender Address whose tokens are being transferred.
+     * @param tokenId Identifier number of a token.
+     * @param owner Address of the current owner of a token.
+     */
+    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
+
+    /**
+     * @dev Indicates a failure with the token `sender`. Used in transfers.
+     * @param sender Address whose tokens are being transferred.
+     */
+    error ERC721InvalidSender(address sender);
+
+    /**
+     * @dev Indicates a failure with the token `receiver`. Used in transfers.
+     * @param receiver Address to which tokens are being transferred.
+     */
+    error ERC721InvalidReceiver(address receiver);
+
+    /**
+     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
+     * @param operator Address that may be allowed to operate on tokens without being their owner.
+     * @param tokenId Identifier number of a token.
+     */
+    error ERC721InsufficientApproval(address operator, uint256 tokenId);
+
+    /**
+     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
+     * @param approver Address initiating an approval operation.
+     */
+    error ERC721InvalidApprover(address approver);
+
+    /**
+     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
+     * @param operator Address that may be allowed to operate on tokens without being their owner.
+     */
+    error ERC721InvalidOperator(address operator);
+}

package/contracts/token/PrivateERC721/PrivateERC721.sol

@@ -6,7 +6,7 @@ import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import {Context} from "@openzeppelin/contracts/utils/Context.sol";
 import {IERC165, ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
-import {IERC721Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
+import {IERC721Errors} from "./IERC721Errors.sol";
 
 /**
  * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard.

package/contracts/utils/mpc/MpcCore.sol

@@ -1553,6 +1553,16 @@ library MpcCore {
             Xor(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
     }
 
+    function shl(gtUint8 a, uint8 b) internal returns (gtUint8) {
+        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
+    }
+
+    function shr(gtUint8 a, uint8 b) internal returns (gtUint8) {
+        return gtUint8.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
+    }
+
     function eq(gtUint8 a, uint8 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
             Eq(combineEnumsToBytes3(MPC_TYPE.SUINT8_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint8.unwrap(a), uint256(b)));
@@ -1661,6 +1671,16 @@ library MpcCore {
             Xor(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
     }
 
+    function shl(gtUint16 a, uint16 b) internal returns (gtUint16) {
+        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
+    }
+
+    function shr(gtUint16 a, uint16 b) internal returns (gtUint16) {
+        return gtUint16.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT8_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
+    }
+
     function eq(gtUint16 a, uint16 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
             Eq(combineEnumsToBytes3(MPC_TYPE.SUINT16_T, MPC_TYPE.SUINT16_T, ARGS.RHS_PUBLIC), gtUint16.unwrap(a), uint256(b)));
@@ -1769,6 +1789,16 @@ library MpcCore {
             Xor(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
     }
 
+    function shl(gtUint32 a, uint32 b) internal returns (gtUint32) {
+        return gtUint32.wrap(ExtendedOperations(MPC_PRECOMPILE).
+            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
+    }
+
+    function shr(gtUint32 a, uint32 b) internal returns (gtUint32) {
+        return gtUint32.wrap(ExtendedOperations(MPC_PRECOMPILE).
+            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
+    }
+
     function eq(gtUint32 a, uint32 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
             Eq(combineEnumsToBytes3(MPC_TYPE.SUINT32_T, MPC_TYPE.SUINT32_T, ARGS.RHS_PUBLIC), gtUint32.unwrap(a), uint256(b)));
@@ -1878,6 +1908,16 @@ library MpcCore {
             Xor(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
     }
 
+    function shl(gtUint64 a, uint64 b) internal returns (gtUint64) {
+        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shl(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
+    }
+
+    function shr(gtUint64 a, uint64 b) internal returns (gtUint64) {
+        return gtUint64.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
+            Shr(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));
+    }
+
     function eq(gtUint64 a, uint64 b) internal returns (gtBool) {
         return gtBool.wrap(ExtendedOperations(address(MPC_PRECOMPILE)).
             Eq(combineEnumsToBytes3(MPC_TYPE.SUINT64_T, MPC_TYPE.SUINT64_T, ARGS.RHS_PUBLIC), gtUint64.unwrap(a), uint256(b)));

package/contracts/utils/mpc/MpcInterface.sol

@@ -22,6 +22,8 @@ interface ExtendedOperations {
     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);

package/hardhat.config.ts

@@ -6,7 +6,15 @@ dotenv.config()
 
 const config: HardhatUserConfig = {
   defaultNetwork: "testnet",
-  solidity: "0.8.20",
+  solidity: {
+    version: "0.8.19",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 10000
+      }
+    }
+  },
   networks: {
     testnet: {
       url: "https://testnet.coti.io/rpc",

package/package.json

@@ -1,14 +1,30 @@
 {
   "name": "@coti-io/coti-contracts",
-  "version": "1.0.0",
-  "description": "",
+  "version": "1.0.3",
+  "description": "A library for smart contract development on the COTI network.",
+  "author": "COTI Development",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/coti-io/coti-contracts.git"
+  },
+  "homepage": "https://docs.coti.io/coti-v2-documentation/build-on-coti/tools/contracts-library",
+  "keywords": [
+    "coti",
+    "privacy",
+    "ethereum",
+    "blockchain",
+    "web3",
+    "garbled-circuits",
+    "l2",
+    "on-chain-compute"
+  ],
   "devDependencies": {
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "hardhat": "^2.22.8"
   },
   "dependencies": {
-    "@coti-io/coti-ethers": "^1.0.1-b",
-    "@openzeppelin/contracts": "^5.0.2",
+    "@coti-io/coti-ethers": "^1.0.3",
+    "@openzeppelin/contracts": "^4.9.6",
     "dotenv": "^16.4.5"
   }
 }

package/test/onboard/AccountOnboard.test.ts

@@ -24,9 +24,9 @@ describe("Account Onboard", function () {
   })
 
   it('Should successfully onboard the account', async function () {
-    const { owner } = deployment
+    const { owner, contractAddress } = deployment
 
-    await owner.generateOrRecoverAes()
+    await owner.generateOrRecoverAes(contractAddress)
 
     expect(owner.getUserOnboardInfo()?.aesKey).to.not.equal('')
   })

package/test/token/PrivateERC20/PrivateERC20.test.ts

@@ -50,8 +50,8 @@ describe("Private ERC20", function () {
             await expect(await contract.symbol()).to.equal("PE20M");
         })
 
-        it('has 2 decimals', async function () {
-            await expect(await contract.decimals()).to.equal(2n);
+        it('has 6 decimals', async function () {
+            await expect(await contract.decimals()).to.equal(6n);
         })
     })
 

package/test/utils/accounts.ts

@@ -14,7 +14,7 @@ export async function setupAccounts() {
     setEnvValue("PUBLIC_KEYS", `${key1.address},${key2.address}`)
     setEnvValue("SIGNING_KEYS", `${key1.privateKey},${key2.privateKey}`)
 
-    throw new Error(`Created new random accounts ${key1.address} and ${key2.address}. Please use faucet to fund it.`)
+    throw new Error(`Created new random accounts ${key1.address} and ${key2.address}. Please use faucet to fund them.`)
   }
 
   const wallets = pks.map((pk) => new Wallet(pk, provider))
@@ -39,7 +39,7 @@ export async function setupAccounts() {
 
   let accounts: Wallet[] = []
   if (userKeys.length !== wallets.length) {
-    await (await wallets[0].sendTransaction({ to: wallets[1].address, value: parseEther("0.1") })).wait()
+    await (await wallets[0].sendTransaction({ to: wallets[1].address, value: parseEther("1.0") })).wait()
 
     accounts = await Promise.all(wallets.map(async (account, i) => await toAccount(account)))
     setEnvValue("USER_KEYS", accounts.map((a) => a.getUserOnboardInfo()?.aesKey).join(","))

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

@@ -42,8 +42,12 @@ function buildTestWithUser(contractName: string, func: string, resFunc: string,
 
     await (await contract.getFunction(func)(param, owner.address, { gasLimit: 12000000 })).wait()
     const results = await contract.getFunction(resFunc)()
-    for (const result of results) {
-      expect(await owner.decryptValue(result)).to.equal(param)
+    for (let i = 0; i < results.length; i++) {
+      if (i === 0) {
+        expect(Boolean(await owner.decryptValue(results[i]))).to.equal(true)
+      } else {
+        expect(await owner.decryptValue(results[i])).to.equal(param)
+      }
     }
   })
 }
@@ -57,8 +61,11 @@ const bool_b = false
 const [a, b] = params
 describe("Precompile", function () {
   buildTest("ArithmeticTestsContract", "addTest", "getAddResult", params, a + b)
+  buildTest("ArithmeticTestsContract", "checkedAddTest", "getAddResult", params, a + b)
   buildTest("ArithmeticTestsContract", "subTest", "getSubResult", params, a - b)
+  buildTest("ArithmeticTestsContract", "checkedSubTest", "getSubResult", params, a - b)
   buildTest("ArithmeticTestsContract", "mulTest", "getMulResult", params, a * b)
+  buildTest("ArithmeticTestsContract", "checkedMulTest", "getMulResult", params, a * b)
 
   buildTest("MiscellaneousTestsContract", "divTest", "getDivResult", params, a / b)
   buildTest("MiscellaneousTestsContract", "remTest", "getRemResult", params, a % b)
@@ -79,10 +86,17 @@ describe("Precompile", function () {
 
   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("TransferWithAllowanceTestsContract", "transferWithAllowanceTest", "getResults", [a, b, b, b], a - b, b + b, true, 0)
+  buildTest("TransferWithAllowance64_8TestsContract", "transferWithAllowance64Test", "getResults", [a, b, b, b], a - b, b + b, true, 0)
+  buildTest("TransferWithAllowance64_16TestsContract", "transferWithAllowance64Test", "getResults", [a, b, b, b], a - b, b + b, true, 0)
+  buildTest("TransferWithAllowance64_32TestsContract", "transferWithAllowance64Test", "getResults", [a, b, b, b], a - b, b + b, true, 0)
+  buildTest("TransferWithAllowance64_64TestsContract", "transferWithAllowance64Test", "getResults", [a, b, b, b], a - b, b + b, true, 0)
+  buildTest("TransferWithAllowanceScalarTestsContract", "transferWithAllowanceScalarTest", "getResults", [a, b, b, b], a - b, b + b, true, 0)
   buildTest("OffboardToUserKeyTestContract", "offboardOnboardTest", "getOnboardOffboardResult", [a, a, a, a], a)
   buildTest("MiscellaneousTestsContract", "notTest", "getBoolResult", [!!a], !a)
 
   buildTestWithUser("OffboardToUserKeyTestContract", "offboardToUserTest", "getCTs", a)
+  buildTestWithUser("OffboardToUserKeyTestContract", "offboardCombinedTest", "getCTs", a)
   buildTest("Miscellaneous1TestsContract", "randomTest", "getRandom", [], last_random_value)
   buildTest("Miscellaneous1TestsContract", "randomBoundedTest", "getRandomBounded", [numBits], last_random_value)
   buildTest(
@@ -99,4 +113,12 @@ describe("Precompile", function () {
     bit ? bool_b : bool_a,
     bool_a
   )
+  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)
 })

package/typechain-types/@openzeppelin/contracts/interfaces/index.ts

@@ -1,6 +1,4 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import type * as draftIerc6093Sol from "./draft-IERC6093.sol";
-export type { draftIerc6093Sol };
 export type { IERC4906 } from "./IERC4906";

package/typechain-types/contracts/GasTest.ts

@@ -0,0 +1,91 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface GasTestInterface extends Interface {
+  getFunction(nameOrSignature: "test1" | "test2"): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "test1", values?: undefined): string;
+  encodeFunctionData(functionFragment: "test2", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "test1", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "test2", data: BytesLike): Result;
+}
+
+export interface GasTest extends BaseContract {
+  connect(runner?: ContractRunner | null): GasTest;
+  waitForDeployment(): Promise<this>;
+
+  interface: GasTestInterface;
+
+  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>;
+
+  test1: TypedContractMethod<[], [void], "nonpayable">;
+
+  test2: TypedContractMethod<[], [void], "nonpayable">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "test1"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "test2"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+
+  filters: {};
+}

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

@@ -119,6 +119,9 @@ export interface ArithmeticTestsContractInterface extends Interface {
   getFunction(
     nameOrSignature:
       | "addTest"
+      | "checkedAddTest"
+      | "checkedMulTest"
+      | "checkedSubTest"
       | "decryptAndCompareResults16"
       | "decryptAndCompareResults32"
       | "decryptAndCompareResults64"
@@ -134,6 +137,18 @@ export interface ArithmeticTestsContractInterface extends Interface {
     functionFragment: "addTest",
     values: [BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "checkedAddTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "checkedMulTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "checkedSubTest",
+    values: [BigNumberish, BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "decryptAndCompareResults16",
     values: [ArithmeticTestsContract.Check16Struct]
@@ -176,6 +191,18 @@ export interface ArithmeticTestsContractInterface extends Interface {
   ): string;
 
   decodeFunctionResult(functionFragment: "addTest", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "checkedAddTest",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "checkedMulTest",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "checkedSubTest",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "decryptAndCompareResults16",
     data: BytesLike
@@ -257,6 +284,24 @@ export interface ArithmeticTestsContract extends BaseContract {
     "nonpayable"
   >;
 
+  checkedAddTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  checkedMulTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  checkedSubTest: TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
   decryptAndCompareResults16: TypedContractMethod<
     [check16: ArithmeticTestsContract.Check16Struct],
     [bigint],
@@ -314,6 +359,27 @@ export interface ArithmeticTestsContract extends BaseContract {
     [bigint],
     "nonpayable"
   >;
+  getFunction(
+    nameOrSignature: "checkedAddTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "checkedMulTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "checkedSubTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, b: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
   getFunction(
     nameOrSignature: "decryptAndCompareResults16"
   ): TypedContractMethod<

package/typechain-types/contracts/mocks/utils/mpc/BitwiseTestsContract.ts

@@ -84,6 +84,8 @@ export declare namespace BitwiseTestsContract {
   };
 
   export type AllGTCastingValuesStruct = {
+    aBool_s: BigNumberish;
+    bBool_s: BigNumberish;
     a8_s: BigNumberish;
     b8_s: BigNumberish;
     a16_s: BigNumberish;
@@ -95,6 +97,8 @@ export declare namespace BitwiseTestsContract {
   };
 
   export type AllGTCastingValuesStructOutput = [
+    aBool_s: bigint,
+    bBool_s: bigint,
     a8_s: bigint,
     b8_s: bigint,
     a16_s: bigint,
@@ -104,6 +108,8 @@ export declare namespace BitwiseTestsContract {
     a64_s: bigint,
     b64_s: bigint
   ] & {
+    aBool_s: bigint;
+    bBool_s: bigint;
     a8_s: bigint;
     b8_s: bigint;
     a16_s: bigint;

package/typechain-types/contracts/mocks/utils/mpc/Comparison2TestsContract.ts

@@ -84,6 +84,8 @@ export declare namespace Comparison2TestsContract {
   };
 
   export type AllGTCastingValuesStruct = {
+    aBool_s: BigNumberish;
+    bBool_s: BigNumberish;
     a8_s: BigNumberish;
     b8_s: BigNumberish;
     a16_s: BigNumberish;
@@ -95,6 +97,8 @@ export declare namespace Comparison2TestsContract {
   };
 
   export type AllGTCastingValuesStructOutput = [
+    aBool_s: bigint,
+    bBool_s: bigint,
     a8_s: bigint,
     b8_s: bigint,
     a16_s: bigint,
@@ -104,6 +108,8 @@ export declare namespace Comparison2TestsContract {
     a64_s: bigint,
     b64_s: bigint
   ] & {
+    aBool_s: bigint;
+    bBool_s: bigint;
     a8_s: bigint;
     b8_s: bigint;
     a16_s: bigint;

package/typechain-types/contracts/mocks/utils/mpc/OffboardToUserKeyTestContract.ts

@@ -30,6 +30,7 @@ export interface OffboardToUserKeyTestContractInterface extends Interface {
       | "getUserKeyShares"
       | "getUserKeyTest"
       | "getX"
+      | "offboardCombinedTest"
       | "offboardOnboardTest"
       | "offboardToUserTest"
       | "userKeyTest"
@@ -50,6 +51,10 @@ export interface OffboardToUserKeyTestContractInterface extends Interface {
     values: [BytesLike, BytesLike, AddressLike]
   ): string;
   encodeFunctionData(functionFragment: "getX", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "offboardCombinedTest",
+    values: [BigNumberish, AddressLike]
+  ): string;
   encodeFunctionData(
     functionFragment: "offboardOnboardTest",
     values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
@@ -78,6 +83,10 @@ export interface OffboardToUserKeyTestContractInterface extends Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "getX", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "offboardCombinedTest",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "offboardOnboardTest",
     data: BytesLike
@@ -135,7 +144,11 @@ export interface OffboardToUserKeyTestContract extends BaseContract {
     event?: TCEvent
   ): Promise<this>;
 
-  getCTs: TypedContractMethod<[], [[bigint, bigint, bigint, bigint]], "view">;
+  getCTs: TypedContractMethod<
+    [],
+    [[bigint, bigint, bigint, bigint, bigint]],
+    "view"
+  >;
 
   getCt: TypedContractMethod<[], [bigint], "view">;
 
@@ -151,15 +164,21 @@ export interface OffboardToUserKeyTestContract extends BaseContract {
 
   getX: TypedContractMethod<[], [bigint], "view">;
 
+  offboardCombinedTest: TypedContractMethod<
+    [a: BigNumberish, addr: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
   offboardOnboardTest: TypedContractMethod<
     [a8: BigNumberish, a16: BigNumberish, a32: BigNumberish, a64: BigNumberish],
-    [bigint],
+    [void],
     "nonpayable"
   >;
 
   offboardToUserTest: TypedContractMethod<
     [a: BigNumberish, addr: AddressLike],
-    [[bigint, bigint, bigint, bigint]],
+    [void],
     "nonpayable"
   >;
 
@@ -175,7 +194,11 @@ export interface OffboardToUserKeyTestContract extends BaseContract {
 
   getFunction(
     nameOrSignature: "getCTs"
-  ): TypedContractMethod<[], [[bigint, bigint, bigint, bigint]], "view">;
+  ): TypedContractMethod<
+    [],
+    [[bigint, bigint, bigint, bigint, bigint]],
+    "view"
+  >;
   getFunction(
     nameOrSignature: "getCt"
   ): TypedContractMethod<[], [bigint], "view">;
@@ -195,18 +218,25 @@ export interface OffboardToUserKeyTestContract extends BaseContract {
   getFunction(
     nameOrSignature: "getX"
   ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "offboardCombinedTest"
+  ): TypedContractMethod<
+    [a: BigNumberish, addr: AddressLike],
+    [void],
+    "nonpayable"
+  >;
   getFunction(
     nameOrSignature: "offboardOnboardTest"
   ): TypedContractMethod<
     [a8: BigNumberish, a16: BigNumberish, a32: BigNumberish, a64: BigNumberish],
-    [bigint],
+    [void],
     "nonpayable"
   >;
   getFunction(
     nameOrSignature: "offboardToUserTest"
   ): TypedContractMethod<
     [a: BigNumberish, addr: AddressLike],
-    [[bigint, bigint, bigint, bigint]],
+    [void],
     "nonpayable"
   >;
   getFunction(