@coti-io/coti-contracts 1.0.2 → 1.0.4

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/token/PrivateERC721/extensions/IPrivateERC721URIStorage.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import "../../../utils/mpc/MpcCore.sol";
+
+/**
+ * @dev ERC-721 token with storage based token URI management.
+ */
+interface IPrivateERC721URIStorage {
+    /**
+     * @dev Returns the encrypted Uniform Resource Identifier (URI) for `tokenId` token.
+     */
+    function tokenURI(uint256 tokenId) external view returns (ctString memory);
+}

package/contracts/token/PrivateERC721/extensions/PrivateERC721URIStorage.sol

@@ -47,6 +47,32 @@ abstract contract PrivateERC721URIStorage is IERC4906, PrivateERC721 {
         _setTokenURI(to, tokenId, gtTokenURI, true);
     }
 
+    /**
+     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
+     *
+     */
+    function _setTokenURI(
+        address to,
+        uint256 tokenId,
+        ctString memory ctTokenURI
+    ) internal virtual {
+        gtString memory gtTokenURI = MpcCore.onBoard(ctTokenURI);
+
+        _setTokenURI(to, tokenId, gtTokenURI, true);
+    }
+
+    /**
+     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
+     *
+     */
+    function _setTokenURI(
+        address to,
+        uint256 tokenId,
+        gtString memory gtTokenURI
+    ) internal virtual {
+        _setTokenURI(to, tokenId, gtTokenURI, true);
+    }
+
     /**
      * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
      *
@@ -61,7 +87,7 @@ abstract contract PrivateERC721URIStorage is IERC4906, PrivateERC721 {
             revert ERC721URIStorageNonMintedToken(tokenId);
         }
 
-        utString memory utTokenURI =  MpcCore.offBoardCombined(gtTokenURI, to);
+        utString memory utTokenURI = MpcCore.offBoardCombined(gtTokenURI, to);
 
         if (updateCiphertext) {
             _tokenURIs[tokenId] = utTokenURI;

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.4",
   "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/token/PrivateERC721/extensions/IPrivateERC721URIStorage.ts

@@ -0,0 +1,100 @@
+/* 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 type CtStringStruct = { value: BigNumberish[] };
+
+export type CtStringStructOutput = [value: bigint[]] & { value: bigint[] };
+
+export interface IPrivateERC721URIStorageInterface extends Interface {
+  getFunction(nameOrSignature: "tokenURI"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "tokenURI",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
+}
+
+export interface IPrivateERC721URIStorage extends BaseContract {
+  connect(runner?: ContractRunner | null): IPrivateERC721URIStorage;
+  waitForDeployment(): Promise<this>;
+
+  interface: IPrivateERC721URIStorageInterface;
+
+  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>;
+
+  tokenURI: TypedContractMethod<
+    [tokenId: BigNumberish],
+    [CtStringStructOutput],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "tokenURI"
+  ): TypedContractMethod<
+    [tokenId: BigNumberish],
+    [CtStringStructOutput],
+    "view"
+  >;
+
+  filters: {};
+}

package/typechain-types/contracts/token/PrivateERC721/extensions/index.ts

@@ -1,4 +1,5 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+export type { IPrivateERC721URIStorage } from "./IPrivateERC721URIStorage";
 export type { PrivateERC721URIStorage } from "./PrivateERC721URIStorage";