@coti-io/coti-contracts 1.0.2 → 1.0.3

package/contracts/access/DataPrivacyFramework/extensions/DataPrivacyFrameworkMpc.sol

@@ -123,6 +123,34 @@ abstract contract DataPrivacyFrameworkMpc is DataPrivacyFramework {
         return MpcCore.xor(a, b);
     }
 
+    function shl(
+        gtUint8 a,
+        uint8 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shl", uintParameter, addressParameter, stringParameter)
+        returns (gtUint8)
+    {
+        return MpcCore.shl(a, b);
+    }
+
+    function shr(
+        gtUint8 a,
+        uint8 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shr", uintParameter, addressParameter, stringParameter)
+        returns (gtUint8)
+    {
+        return MpcCore.shr(a, b);
+    }
+
     function eq(
         gtUint8 a,
         gtUint8 b,
@@ -377,6 +405,34 @@ abstract contract DataPrivacyFrameworkMpc is DataPrivacyFramework {
         return MpcCore.xor(a, b);
     }
 
+    function shl(
+        gtUint16 a,
+        uint16 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shl", uintParameter, addressParameter, stringParameter)
+        returns (gtUint16)
+    {
+        return MpcCore.shl(a, b);
+    }
+
+    function shr(
+        gtUint16 a,
+        uint16 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shr", uintParameter, addressParameter, stringParameter)
+        returns (gtUint16)
+    {
+        return MpcCore.shr(a, b);
+    }
+
     function eq(
         gtUint16 a,
         gtUint16 b,
@@ -631,6 +687,34 @@ abstract contract DataPrivacyFrameworkMpc is DataPrivacyFramework {
         return MpcCore.xor(a, b);
     }
 
+    function shl(
+        gtUint32 a,
+        uint32 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shl", uintParameter, addressParameter, stringParameter)
+        returns (gtUint32)
+    {
+        return MpcCore.shl(a, b);
+    }
+
+    function shr(
+        gtUint32 a,
+        uint32 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shr", uintParameter, addressParameter, stringParameter)
+        returns (gtUint32)
+    {
+        return MpcCore.shr(a, b);
+    }
+
     function eq(
         gtUint32 a,
         gtUint32 b,
@@ -885,6 +969,34 @@ abstract contract DataPrivacyFrameworkMpc is DataPrivacyFramework {
         return MpcCore.xor(a, b);
     }
 
+    function shl(
+        gtUint64 a,
+        uint64 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shl", uintParameter, addressParameter, stringParameter)
+        returns (gtUint64)
+    {
+        return MpcCore.shl(a, b);
+    }
+
+    function shr(
+        gtUint64 a,
+        uint64 b,
+        uint256 uintParameter,
+        address addressParameter,
+        string calldata stringParameter
+    )
+        internal
+        onlyAllowedUserOperation("op_shr", uintParameter, addressParameter, stringParameter)
+        returns (gtUint64)
+    {
+        return MpcCore.shr(a, b);
+    }
+
     function eq(
         gtUint64 a,
         gtUint64 b,

package/contracts/mocks/utils/mpc/ShiftTestsContract.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+contract ShiftTestsContract {
+
+    struct AllGTCastingValues {
+        gtUint8 a8_s;
+        gtUint8 b8_s;
+        gtUint16 a16_s;
+        gtUint16 b16_s;
+        gtUint32 a32_s;
+        gtUint32 b32_s;
+        gtUint64 a64_s;
+        gtUint64 b64_s;
+    }
+
+    struct Check16 {
+        gtUint16 res16_16;
+        gtUint16 res8_16;
+        gtUint16 res16_8;
+    }
+
+    struct Check32 {
+        gtUint32 res32_32;
+        gtUint32 res8_32;
+        gtUint32 res32_8;
+        gtUint32 res16_32;
+        gtUint32 res32_16;
+    }
+
+    struct Check64 {
+        gtUint64 res64_64;
+        gtUint64 res8_64;
+        gtUint64 res64_8;
+        gtUint64 res16_64;
+        gtUint64 res64_16;
+        gtUint64 res32_64;
+        gtUint64 res64_32;
+    }
+
+    uint8 result;
+    uint8 result8;
+    uint16 result16;
+    uint32 result32;
+    uint64 result64;
+
+    function getResult() public view returns (uint8) {
+        return result;
+    }
+
+    function getAllShiftResults() public view returns (uint8, uint16, uint32, uint64) {
+        return (result8, result16, result32, result64);
+    }
+
+    function setPublicValues(AllGTCastingValues memory castingValues, uint8 a, uint8 b) public{
+        castingValues.a8_s = MpcCore.setPublic8(a);
+        castingValues.b8_s = MpcCore.setPublic8(b);
+        castingValues.a16_s =  MpcCore.setPublic16(a);
+        castingValues.b16_s =  MpcCore.setPublic16(b);
+        castingValues.a32_s =  MpcCore.setPublic32(a);
+        castingValues.b32_s =  MpcCore.setPublic32(b);
+        castingValues.a64_s =  MpcCore.setPublic64(a);
+        castingValues.b64_s =  MpcCore.setPublic64(b);
+    }
+
+    function decryptAndCompareResults16(Check16 memory check16) public returns (uint16){
+
+        // Calculate the result
+        uint16 result = MpcCore.decrypt(check16.res16_16);
+
+        require(result == MpcCore.decrypt(check16.res8_16) && result == MpcCore.decrypt(check16.res16_8),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+
+        return result;
+    }
+
+    function decryptAndCompareResults32(Check32 memory check32) public returns (uint32){
+
+        // Calculate the result
+        uint32 result = MpcCore.decrypt(check32.res32_32);
+
+        require(result == MpcCore.decrypt(check32.res8_32) && result == MpcCore.decrypt(check32.res32_8)
+        && result == MpcCore.decrypt(check32.res32_16) && result == MpcCore.decrypt(check32.res16_32),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+
+        return result;
+    }
+
+    function decryptAndCompareResults64(Check64 memory check64) public returns (uint64){
+
+        // Calculate the result
+        uint64 result = MpcCore.decrypt(check64.res64_64);
+
+        require(result == MpcCore.decrypt(check64.res8_64) && result == MpcCore.decrypt(check64.res64_8)
+        && result == MpcCore.decrypt(check64.res64_16) && result == MpcCore.decrypt(check64.res16_64)
+        && result == MpcCore.decrypt(check64.res64_32) && result == MpcCore.decrypt(check64.res32_64),
+            "decryptAndCompareAllResults: Failed to decrypt and compare all results");
+
+        return result;
+    }
+
+    function shlTest(uint8 a, uint8 b) public returns (uint8, uint16, uint32, uint64) {
+        AllGTCastingValues memory castingValues;
+        setPublicValues(castingValues, a, b);
+
+        result8 = MpcCore.decrypt(MpcCore.shl(castingValues.a8_s, b));
+        result16 = MpcCore.decrypt(MpcCore.shl(castingValues.a16_s, b));
+        result32 = MpcCore.decrypt(MpcCore.shl(castingValues.a32_s, b));
+        result64 = MpcCore.decrypt(MpcCore.shl(castingValues.a64_s, b));
+        return (result8, result16, result32, result64);
+    }
+
+    function shrTest(uint8 a, uint8 b) public returns (uint8) {
+        AllGTCastingValues memory castingValues;
+        setPublicValues(castingValues, a, b);
+
+        result = MpcCore.decrypt(MpcCore.shr(castingValues.a8_s, b));
+        require(result == MpcCore.decrypt(MpcCore.shr(castingValues.a16_s, b)) && result == MpcCore.decrypt(MpcCore.shr(castingValues.a32_s, b))
+        && result == MpcCore.decrypt(MpcCore.shr(castingValues.a64_s, b)),
+            "shrTest failed");
+        return result;
+    }
+
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coti-io/coti-contracts",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A library for smart contract development on the COTI network.",
   "author": "COTI Development",
   "repository": {

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/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

@@ -113,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/index.ts

@@ -9,6 +9,7 @@ export type { MinMaxTestsContract } from "./MinMaxTestsContract";
 export type { Miscellaneous1TestsContract } from "./Miscellaneous1TestsContract";
 export type { MiscellaneousTestsContract } from "./MiscellaneousTestsContract";
 export type { OffboardToUserKeyTestContract } from "./OffboardToUserKeyTestContract";
+export type { ShiftTestsContract } from "./ShiftTestsContract";
 export type { StringTestsContract } from "./StringTestsContract";
 export type { TransferScalarTestsContract } from "./TransferScalarTestsContract";
 export type { TransferTestsContract } from "./TransferTestsContract";

package/typechain-types/contracts/utils/mpc/MpcInterface.sol/ExtendedOperations.ts

@@ -51,6 +51,8 @@ export interface ExtendedOperationsInterface extends Interface {
       | "RandBoundedBits"
       | "Rem"
       | "SetPublic"
+      | "Shl"
+      | "Shr"
       | "Sub"
       | "Transfer"
       | "TransferWithAllowance"
@@ -167,6 +169,14 @@ export interface ExtendedOperationsInterface extends Interface {
     functionFragment: "SetPublic",
     values: [BytesLike, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "Shl",
+    values: [BytesLike, BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "Shr",
+    values: [BytesLike, BigNumberish, BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "Sub",
     values: [BytesLike, BigNumberish, BigNumberish]
@@ -225,6 +235,8 @@ export interface ExtendedOperationsInterface extends Interface {
   ): Result;
   decodeFunctionResult(functionFragment: "Rem", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "SetPublic", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "Shl", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "Shr", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "Sub", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "Transfer", data: BytesLike): Result;
   decodeFunctionResult(
@@ -445,6 +457,18 @@ export interface ExtendedOperations extends BaseContract {
     "nonpayable"
   >;
 
+  Shl: TypedContractMethod<
+    [metaData: BytesLike, lhs: BigNumberish, rhs: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
+  Shr: TypedContractMethod<
+    [metaData: BytesLike, lhs: BigNumberish, rhs: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+
   Sub: TypedContractMethod<
     [metaData: BytesLike, lhs: BigNumberish, rhs: BigNumberish],
     [bigint],
@@ -681,6 +705,20 @@ export interface ExtendedOperations extends BaseContract {
     [bigint],
     "nonpayable"
   >;
+  getFunction(
+    nameOrSignature: "Shl"
+  ): TypedContractMethod<
+    [metaData: BytesLike, lhs: BigNumberish, rhs: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "Shr"
+  ): TypedContractMethod<
+    [metaData: BytesLike, lhs: BigNumberish, rhs: BigNumberish],
+    [bigint],
+    "nonpayable"
+  >;
   getFunction(
     nameOrSignature: "Sub"
   ): TypedContractMethod<

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

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

package/typechain-types/factories/contracts/GasTest__factory.ts

@@ -0,0 +1,75 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  Contract,
+  ContractFactory,
+  ContractTransactionResponse,
+  Interface,
+} from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../common";
+import type { GasTest, GasTestInterface } from "../../contracts/GasTest";
+
+const _abi = [
+  {
+    inputs: [],
+    name: "test1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "test2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+const _bytecode =
+  "0x608060405234801561001057600080fd5b506102d0806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806366e41cb71461003b5780636b59084d14610045575b600080fd5b61004361004d565b005b61004361006a565b60006100596002610072565b9050610066816001610126565b5050565b600061006660025b6040517fd9b60b600000000000000000000000000000000000000000000000000000000081527f0400000000000000000000000000000000000000000000000000000000000000600482015267ffffffffffffffff8216602482015260009060649063d9b60b60906044016020604051808303816000875af11580156100fc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101209190610281565b92915050565b600060646339bd1d8d61013c60048060026101f5565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b1681527fffffff000000000000000000000000000000000000000000000000000000000090911660048201526024810186905267ffffffffffffffff851660448201526064016020604051808303816000875af11580156101ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101ee9190610281565b9392505050565b600081600281111561020957610209610252565b60ff16600884600481111561022057610220610252565b61ffff16901b61ffff16601086600481111561023e5761023e610252565b62ffffff16901b171760e81b949350505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b60006020828403121561029357600080fd5b505191905056fea264697066735822122024b86f1e2c83704d02af06383a52cfa1bb753ac769faefd6871f17140246e1f564736f6c63430008130033";
+
+type GasTestConstructorParams =
+  | [signer?: Signer]
+  | ConstructorParameters<typeof ContractFactory>;
+
+const isSuperArgs = (
+  xs: GasTestConstructorParams
+): xs is ConstructorParameters<typeof ContractFactory> => xs.length > 1;
+
+export class GasTest__factory extends ContractFactory {
+  constructor(...args: GasTestConstructorParams) {
+    if (isSuperArgs(args)) {
+      super(...args);
+    } else {
+      super(_abi, _bytecode, args[0]);
+    }
+  }
+
+  override getDeployTransaction(
+    overrides?: NonPayableOverrides & { from?: string }
+  ): Promise<ContractDeployTransaction> {
+    return super.getDeployTransaction(overrides || {});
+  }
+  override deploy(overrides?: NonPayableOverrides & { from?: string }) {
+    return super.deploy(overrides || {}) as Promise<
+      GasTest & {
+        deploymentTransaction(): ContractTransactionResponse;
+      }
+    >;
+  }
+  override connect(runner: ContractRunner | null): GasTest__factory {
+    return super.connect(runner) as GasTest__factory;
+  }
+
+  static readonly bytecode = _bytecode;
+  static readonly abi = _abi;
+  static createInterface(): GasTestInterface {
+    return new Interface(_abi) as GasTestInterface;
+  }
+  static connect(address: string, runner?: ContractRunner | null): GasTest {
+    return new Contract(address, _abi, runner) as unknown as GasTest;
+  }
+}