@coti-io/coti-contracts 0.1.0

package/test/token/PrivateERC721/PrivateERC721.test.ts

@@ -0,0 +1,223 @@
+import hre from "hardhat"
+import { expect } from "chai"
+
+import { setupAccounts } from "../../utils/accounts"
+import { ContractTransactionReceipt, itString } from "@coti-io/coti-ethers"
+
+const gasLimit = 12000000
+
+async function deploy() {
+  const [owner, otherAccount] = await setupAccounts()
+
+  const factory = await hre.ethers.getContractFactory("PrivateERC721URIStorageMock")
+  const contract = await factory.connect(owner).deploy({ gasLimit })
+
+  await contract.waitForDeployment()
+  
+  return { contract, contractAddress: await contract.getAddress(), owner, otherAccount }
+}
+
+describe("Private ERC721", function () {
+  let deployment: Awaited<ReturnType<typeof deploy>>
+
+  before(async function () {
+    deployment = await deploy()
+  })
+
+  describe("Deployment", function () {
+    it("Deployed address should be a valid Ethereum address", async function () {
+      expect(hre.ethers.isAddress(deployment.contractAddress)).to.eq(true)
+    })
+
+    it("Name should match deployment name", async function () {
+      expect(await deployment.contract.name()).to.equal("Example")
+    })
+
+    it("Symbol should match deployment symbol", async function () {
+      expect(await deployment.contract.symbol()).to.equal("EXL")
+    })
+  })
+
+  describe("Minting", function () {
+    const tokenURI = 'https://api.pudgypenguins.io/lil/18707'
+
+    describe("Successful mint", function () {
+      let tx: ContractTransactionReceipt | null
+
+      before(async function () {
+        const { contract, contractAddress, owner, otherAccount } = deployment
+        
+        const encryptedTokenURI = await owner.encryptValue(tokenURI, contractAddress, contract.mint.fragment.selector) as itString
+
+        tx = await (
+          await contract
+            .connect(owner)
+            .mint(
+              otherAccount.address,
+              encryptedTokenURI,
+              { gasLimit })
+        ).wait()
+      })
+      
+      it("Should emit a 'Minted' event", async function () {
+        const { contract } = deployment
+  
+        expect(tx).to.emit(contract, "Minted")
+      })
+
+      it("Should update the owners mapping", async function () {
+        const { contract, otherAccount } = deployment
+  
+        expect(await contract.ownerOf(BigInt(0))).to.equal(otherAccount.address)
+      })
+
+      it("Should update the balances mapping", async function () {
+        const { contract, otherAccount } = deployment
+  
+        expect(await contract.balanceOf(otherAccount.address)).to.equal(BigInt(1))
+      })
+
+    })
+
+    it("Should fail to mint if the encrypted token URI is faulty", async function () {
+      const { contract, contractAddress, otherAccount, owner } = deployment
+
+      const ownerEncryptedTokenURI = await owner.encryptValue(tokenURI, contractAddress, contract.mint.fragment.selector) as itString
+      const otherAccountEncryptedTokenURI = await otherAccount.encryptValue(tokenURI, contractAddress, contract.mint.fragment.selector) as itString
+
+      const encryptedTokenURI = {
+        ciphertext: ownerEncryptedTokenURI.ciphertext,
+        signature: otherAccountEncryptedTokenURI.signature
+      }
+
+      const tx = await contract
+        .connect(otherAccount)
+        .mint(
+          otherAccount.address,
+          encryptedTokenURI,
+          { gasLimit }
+        )
+      
+      expect(tx).to.be.reverted
+    })
+  })
+
+  describe("URI", function () {
+    it("should return 0 for token URI if not set", async function () {
+      const { contract, owner } = deployment
+
+      const tokenId = BigInt(1)
+      const ctURI = await contract.connect(owner).tokenURI(tokenId)
+      const uri = await owner.decryptValue(ctURI)
+      
+      expect(uri).to.equal("")
+    })
+  })
+
+  describe("Transfers", function () {
+    describe("Successful transfer", function () {
+      const tokenId = BigInt(0)
+      const tokenURI = 'https://api.pudgypenguins.io/lil/18707'
+
+      before(async function () {
+        const { contract, owner, otherAccount } = deployment
+
+        await (await contract.connect(otherAccount).approve(owner.address, tokenId, { gasLimit })).wait()
+
+        await (
+          await contract
+            .connect(owner)
+            .transferFrom(otherAccount.address, owner.address, tokenId, { gasLimit })
+        ).wait()
+      })
+
+      it("Should transfer token to other account", async function () {
+        const { contract, owner, otherAccount } = deployment
+  
+        expect(await contract.ownerOf(tokenId)).to.equal(owner.address)
+        expect(await contract.balanceOf(owner.address)).to.equal(BigInt(1))
+        expect(await contract.balanceOf(otherAccount.address)).to.equal(BigInt(0))
+      })
+
+      it("Should allow the new owner to decrypt the token URI", async function () {
+        const { contract, owner } = deployment
+
+        const encryptedTokenURI = await contract.tokenURI(tokenId)
+
+        const decryptedTokenURI = await owner.decryptValue(encryptedTokenURI)
+
+        expect(decryptedTokenURI).to.equal(tokenURI)
+      })
+      
+      it("Should not allow the previous owner to decrypt the token URI", async function () {
+        const { contract, otherAccount } = deployment
+
+        const encryptedTokenURI = await contract.tokenURI(tokenId)
+
+        const decryptedTokenURI = await otherAccount.decryptValue(encryptedTokenURI)
+
+        expect(decryptedTokenURI).to.not.equal(tokenURI)
+      })
+    })
+
+    describe("Failed transfers", function () {
+      const tokenURI = 'https://api.pudgypenguins.io/lil/9040'
+
+      it("Should fail transfer token to other account for when no allowance", async function () {
+        const { contract, contractAddress, owner, otherAccount } = deployment
+
+        const encryptedTokenURI = await owner.encryptValue(tokenURI, contractAddress, contract.mint.fragment.selector) as itString
+  
+        const tokenId = await deployment.contract.totalSupply()
+        
+        await (
+          await contract
+            .connect(owner)
+            .mint(
+              owner.address,
+              encryptedTokenURI,
+              { gasLimit }
+            )
+        ).wait()
+  
+        const tx = await contract
+          .connect(otherAccount)
+          .transferFrom(owner.address, otherAccount.address, tokenId, { gasLimit })
+        let reverted = true
+        try {
+          await tx.wait()
+          reverted = false
+        } catch (error) {}
+        expect(reverted).to.eq(true, "Should have reverted")
+      })
+  
+      it("Should fail to transfer from non-owner", async function () {
+        const { contract, contractAddress, owner, otherAccount } = deployment
+
+        const encryptedTokenURI = await owner.encryptValue(tokenURI, contractAddress, contract.mint.fragment.selector) as itString
+  
+        const tokenId = await deployment.contract.totalSupply()
+        
+        await (
+          await contract
+            .connect(owner)
+            .mint(
+              owner.address,
+              encryptedTokenURI,
+              { gasLimit }
+            )
+        ).wait()
+  
+        const tx = await contract
+          .connect(otherAccount)
+          .transferFrom(owner.address, otherAccount.address, tokenId, { gasLimit })
+        let reverted = true
+        try {
+          await tx.wait()
+          reverted = false
+        } catch (error) {}
+        expect(reverted).to.eq(true, "Should have reverted")
+      })
+    })
+  })
+})

package/test/utils/accounts.ts

@@ -0,0 +1,55 @@
+import fs from "fs"
+import { CotiNetwork, getDefaultProvider, parseEther, Wallet } from "@coti-io/coti-ethers"
+
+let pks = process.env.SIGNING_KEYS ? process.env.SIGNING_KEYS.split(",") : []
+
+export async function setupAccounts() {
+  const provider = getDefaultProvider(CotiNetwork.Devnet);
+
+  if (pks.length == 0) {
+    const key1 = Wallet.createRandom(provider)
+    const key2 = Wallet.createRandom(provider)
+    pks = [key1.privateKey, key2.privateKey]
+
+    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.`)
+  }
+
+  const wallets = pks.map((pk) => new Wallet(pk, provider))
+  if ((await provider.getBalance(wallets[0].address)) === BigInt("0")) {
+    throw new Error(`Please use faucet to fund account ${wallets[0].address}`)
+  }
+
+  let userKeys = process.env.USER_KEYS ? process.env.USER_KEYS.split(",") : []
+
+  const toAccount = async (wallet: Wallet, userKey?: string) => {
+    if (userKey) {
+      wallet.setAesKey(userKey)
+      return wallet
+    }
+
+    console.log("************* Onboarding user ", wallet.address, " *************")
+    await wallet.generateOrRecoverAes()
+    console.log("************* Onboarded! created user key and saved into .env file *************")
+
+    return wallet
+  }
+
+  let accounts: Wallet[] = []
+  if (userKeys.length !== wallets.length) {
+    await (await wallets[0].sendTransaction({ to: wallets[1].address, value: parseEther("0.1") })).wait()
+
+    accounts = await Promise.all(wallets.map(async (account, i) => await toAccount(account)))
+    setEnvValue("USER_KEYS", accounts.map((a) => a.getUserOnboardInfo()?.aesKey).join(","))
+  } else {
+    accounts = await Promise.all(wallets.map(async (account, i) => await toAccount(account, userKeys[i])))
+  }
+
+  return accounts
+}
+
+function setEnvValue(key: string, value: string) {
+  fs.appendFileSync("./.env", `\n${key}=${value}`, "utf8")
+}

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

@@ -0,0 +1,113 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+let last_random_value = 0
+
+function buildTest(
+  contractName: string,
+  func: string,
+  resFunc: string,
+  params: (bigint | number | boolean)[],
+  ...expectedResults: (number | boolean | bigint)[]
+) {
+  it(`${contractName}.${func}(${params}) should return ${expectedResults}`, async function () {
+    const [owner] = await setupAccounts()
+
+    const factory = await hre.ethers.getContractFactory(contractName, owner)
+    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") {
+      expect(result).to.not.equal(expectedResults[0])
+      last_random_value = result
+    } else if (expectedResults.length === 1) {
+      expect(result).to.equal(expectedResults[0])
+    } else {
+      expect(result).to.deep.equal(expectedResults)
+    }
+  })
+}
+
+function buildTestWithUser(contractName: string, func: string, resFunc: string, param: bigint | number | boolean) {
+  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 contract = await factory.deploy({ gasLimit })
+    await contract.waitForDeployment()
+
+    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)
+    }
+  })
+}
+
+const params = [10, 5]
+const shift = 2
+const bit = false
+const numBits = 7
+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("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)
+
+  buildTestWithUser("OffboardToUserKeyTestContract", "offboardToUserTest", "getCTs", a)
+
+  buildTest("Miscellaneous1TestsContract", "randomTest", "getRandom", [], last_random_value)
+  buildTest("Miscellaneous1TestsContract", "randomBoundedTest", "getRandom", [numBits], last_random_value)
+  buildTest(
+    "Miscellaneous1TestsContract",
+    "booleanTest",
+    "getBooleanResults",
+    [bool_a, bool_b, bit],
+    bool_a && bool_b,
+    bool_a || bool_b,
+    bool_a != (bool_b as boolean),
+    !bool_a,
+    bool_a === (bool_b as boolean),
+    bool_a != (bool_b as boolean),
+    bit ? bool_b : bool_a,
+    bool_a
+  )
+})

package/test/utils/mpc/String.test.ts

@@ -0,0 +1,227 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+import { itString } from "@coti-io/coti-ethers"
+
+const gasLimit = 12000000
+
+async function deploy() {
+  const [owner, otherAccount] = await setupAccounts()
+
+  const factory = await hre.ethers.getContractFactory("StringTestsContract")
+  const contract = await factory.connect(owner).deploy({ gasLimit })
+  await contract.waitForDeployment()
+
+  return { contract, contractAddress: await contract.getAddress(), owner, otherAccount }
+}
+
+function formatString(str: string) {
+    return str.replace(/\0/g, '')
+}
+
+describe("MPC Core", function () {
+  let deployment: Awaited<ReturnType<typeof deploy>>
+
+  before(async function () {
+    deployment = await deploy()
+  })
+
+  describe("Set user-encrypted string using an encrypted value", function () {
+    const str = "Hello, World!"
+
+    it("Should store the string encrypted using the users key", async function () {
+        const { contract, contractAddress, owner } = deployment
+
+        const itString = await owner.encryptValue(
+            str,
+            contractAddress,
+            contract.setUserEncryptedString.fragment.selector
+        ) as itString
+
+        const tx = await contract
+            .connect(owner)
+            .setUserEncryptedString(itString, { gasLimit })
+
+        await tx.wait()
+    })
+
+    it("Should retrieve the string encrypted with the users key", async function () {
+        const { contract, owner } = deployment
+
+        const userEncryptedString = await contract.getUserEncryptedString()
+
+        const decryptedStr = await owner.decryptValue(userEncryptedString)
+
+        expect(decryptedStr).to.equal(str)
+    })
+
+    it("Should fail to decrypt the string encrypted with the users key", async function () {
+        const { contract, otherAccount } = deployment
+
+        const userEncryptedString = await contract.getUserEncryptedString()
+
+        const decryptedStr = await otherAccount.decryptValue(userEncryptedString)
+
+        expect(decryptedStr).to.not.equal(str)
+    })
+  })
+
+  describe("Set network-encrypted string using an encrypted value", function () {
+    const str = "Hi, Mom!"
+
+    it("Should store the string encrypted using the network key", async function () {
+        const { contract, contractAddress, owner } = deployment
+
+        const itString = await owner.encryptValue(
+            str,
+            contractAddress,
+            contract.setNetworkEncryptedString.fragment.selector
+        ) as itString
+
+        const tx = await contract
+            .connect(owner)
+            .setNetworkEncryptedString(itString, { gasLimit })
+
+        await tx.wait()
+    })
+
+    it("Should decrypt the network-encrypted string and store it in clear text", async function () {
+        const { contract, owner } = deployment
+
+        const tx = await contract
+            .connect(owner)
+            .decryptNetworkEncryptedString()
+
+        await tx.wait()
+
+        const decryptedStr = await contract.plaintext()
+
+        expect(formatString(decryptedStr)).to.equal(str)
+    })
+  })
+
+  describe("Set user-encrypted string using a non-encrypted value", function () {
+    const str = "Hello darkness, my old friend."
+
+    it("Should store the string encrypted using the users key", async function () {
+        const { contract, owner } = deployment
+
+        const tx = await contract
+            .connect(owner)
+            .setPublicString(str, { gasLimit })
+
+        await tx.wait()
+    })
+
+    it("Should retrieve the string encrypted with the users key", async function () {
+        const { contract, owner } = deployment
+
+        const userEncryptedString = await contract.getUserEncryptedString()
+
+        const decryptedStr = await owner.decryptValue(userEncryptedString)
+
+        expect(decryptedStr).to.equal(str)
+    })
+  })
+
+  describe("Set isEqual using two encrypted values", function () {
+    const a = "ABC"
+    const b = "DEF"
+
+    describe("Using eq", function () {
+        it("Should set isEqual to true", async function () {
+            const { contract, contractAddress, owner } = deployment
+
+            const itString = await owner.encryptValue(
+                a,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const tx = await contract
+                .connect(owner)
+                .setIsEqual(itString, itString, true, { gasLimit })
+
+            await tx.wait()
+
+            const isEqual = await contract.isEqual()
+
+            expect(isEqual).to.equal(true)
+        })
+
+        it("Should set isEqual to false", async function () {
+            const { contract, contractAddress, owner } = deployment
+
+            const itStringA = await owner.encryptValue(
+                a,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const itStringB = await owner.encryptValue(
+                b,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const tx = await contract
+                .connect(owner)
+                .setIsEqual(itStringA, itStringB, true, { gasLimit })
+
+            await tx.wait()
+
+            const isEqual = await contract.isEqual()
+
+            expect(isEqual).to.equal(false)
+        })
+    })
+
+    describe("Using ne", function () {
+        it("Should set isEqual to true", async function () {
+            const { contract, contractAddress, owner } = deployment
+
+            const itStringA = await owner.encryptValue(
+                a,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const itStringB = await owner.encryptValue(
+                b,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const tx = await contract
+                .connect(owner)
+                .setIsEqual(itStringA, itStringB, false, { gasLimit })
+
+            await tx.wait()
+
+            const isEqual = await contract.isEqual()
+
+            expect(isEqual).to.equal(false)
+        })
+
+        it("Should set isEqual to false", async function () {
+            const { contract, contractAddress, owner } = deployment
+
+            const itString = await owner.encryptValue(
+                a,
+                contractAddress,
+                contract.setIsEqual.fragment.selector
+            ) as itString
+
+            const tx = await contract
+                .connect(owner)
+                .setIsEqual(itString, itString, false, { gasLimit })
+
+            await tx.wait()
+
+            const isEqual = await contract.isEqual()
+
+            expect(isEqual).to.equal(true)
+        })
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  }
+}

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

@@ -0,0 +1,9 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as interfaces from "./interfaces";
+export type { interfaces };
+import type * as token from "./token";
+export type { token };
+import type * as utils from "./utils";
+export type { utils };