@coti-io/coti-contracts 1.3.0 → 1.3.1

package/test/pod/privacy/PrivacyPortal.recovery.test.ts

@@ -0,0 +1,263 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { parseUnits } from "ethers"
+
+describe("PrivacyPortal failed-request recovery", function () {
+    async function deployPortalFixture() {
+        const [owner, user, other] = await hre.ethers.getSigners()
+
+        const MockFactory = await hre.ethers.getContractFactory("MockPrivacyPortalFactory")
+        const factory = await MockFactory.deploy(owner.address, owner.address)
+        await factory.waitForDeployment()
+
+        const MockERC20 = await hre.ethers.getContractFactory("MockERC20")
+        const underlying = await MockERC20.deploy("Mock USD", "mUSD", 6)
+        await underlying.waitForDeployment()
+
+        const MockPToken = await hre.ethers.getContractFactory("MockPodERC20ForPortal")
+        const pToken = await MockPToken.deploy()
+        await pToken.waitForDeployment()
+
+        const PortalImpl = await hre.ethers.getContractFactory("PrivacyPortal")
+        const portalImpl = await PortalImpl.deploy()
+        await portalImpl.waitForDeployment()
+
+        const CloneHelper = await hre.ethers.getContractFactory("CloneHelper")
+        const cloneHelper = await CloneHelper.deploy()
+        await cloneHelper.waitForDeployment()
+
+        await cloneHelper.clone(await portalImpl.getAddress())
+        const portalAddress = await cloneHelper.lastClone()
+        const portal = PortalImpl.attach(portalAddress) as Awaited<ReturnType<typeof PortalImpl.deploy>>
+
+        await portal.initialize(
+            await underlying.getAddress(),
+            await pToken.getAddress(),
+            6,
+            false,
+            await factory.getAddress()
+        )
+
+        const amount = parseUnits("100", 6)
+        await underlying.mint(user.address, amount * 2n)
+        await underlying.connect(user).approve(await portal.getAddress(), amount * 2n)
+
+        return { owner, user, other, factory, underlying, pToken, portal, amount }
+    }
+
+    it("refunds locked underlying after a system-failed mint", async function () {
+        const { user, other, underlying, pToken, portal, amount } = await deployPortalFixture()
+
+        const tx = await portal.connect(user).deposit(user.address, amount, 0, 100, {
+            value: 1000,
+        })
+        const receipt = await tx.wait()
+        const depositLog = receipt!.logs
+            .map((log) => {
+                try {
+                    return portal.interface.parseLog(log)
+                } catch {
+                    return null
+                }
+            })
+            .find((parsed) => parsed?.name === "DepositRequested")
+        const requestId = depositLog!.args.mintRequestId as string
+
+        const feesLog = receipt!.logs
+            .map((log) => {
+                try {
+                    return portal.interface.parseLog(log)
+                } catch {
+                    return null
+                }
+            })
+            .find((parsed) => parsed?.name === "OperationFeesPaid")
+        expect(feesLog).to.not.equal(undefined)
+        expect(feesLog!.args.payer).to.equal(user.address)
+        expect(feesLog!.args.correlationId).to.equal(requestId)
+        expect(feesLog!.args.isDeposit).to.equal(true)
+        expect(feesLog!.args.isNativeWrap).to.equal(false)
+        expect(feesLog!.args.portalFee).to.equal(0n)
+        expect(feesLog!.args.podFee).to.equal(1000n)
+        expect(feesLog!.args.podCallbackFee).to.equal(100n)
+        expect(feesLog!.args.amount).to.equal(amount)
+
+        expect(await underlying.balanceOf(await portal.getAddress())).to.equal(amount)
+        await expect(portal.connect(user).refundFailedDeposit(requestId)).to.be.revertedWithCustomError(
+            portal,
+            "DepositMintNotFailed"
+        )
+
+        await pToken.markLastMintRaised()
+        await expect(portal.connect(user).refundFailedDeposit(requestId)).to.be.revertedWithCustomError(
+            portal,
+            "DepositMintNotFailed"
+        )
+
+        await pToken.markLastMintFailed()
+        const before = await underlying.balanceOf(user.address)
+        // Permissionless: a third party may trigger; funds still return to the depositor.
+        await expect(portal.connect(other).refundFailedDeposit(requestId))
+            .to.emit(portal, "DepositRefunded")
+            .withArgs(user.address, requestId, amount)
+
+        expect(await underlying.balanceOf(user.address)).to.equal(before + amount)
+        expect(await underlying.balanceOf(await portal.getAddress())).to.equal(0n)
+        await expect(portal.connect(user).refundFailedDeposit(requestId)).to.be.revertedWithCustomError(
+            portal,
+            "DepositEscrowInvalid"
+        )
+    })
+
+    it("marks withdrawal Failed when the pToken transfer request fails", async function () {
+        const { user, portal, pToken, amount } = await deployPortalFixture()
+
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + 3600)
+        const tx = await portal.connect(user).requestWithdrawWithPermit(
+            user.address,
+            amount,
+            0,
+            1000,
+            100,
+            deadline,
+            27,
+            hre.ethers.ZeroHash,
+            hre.ethers.ZeroHash,
+            { value: 1000 }
+        )
+        const receipt = await tx.wait()
+        const withdrawLog = receipt!.logs
+            .map((log) => {
+                try {
+                    return portal.interface.parseLog(log)
+                } catch {
+                    return null
+                }
+            })
+            .find((parsed) => parsed?.name === "WithdrawalRequested")
+        const withdrawalId = withdrawLog!.args.withdrawalId as string
+        const transferRequestId = withdrawLog!.args.transferRequestId as string
+
+        await expect(portal.cancelFailedWithdrawal(withdrawalId)).to.be.revertedWithCustomError(
+            portal,
+            "WithdrawTransferNotFailed"
+        )
+
+        await pToken.markLastTransferFailed()
+        await expect(portal.cancelFailedWithdrawal(withdrawalId))
+            .to.emit(portal, "WithdrawalFailed")
+            .withArgs(withdrawalId, transferRequestId)
+
+        const feesLog = receipt!.logs
+            .map((log) => {
+                try {
+                    return portal.interface.parseLog(log)
+                } catch {
+                    return null
+                }
+            })
+            .find((parsed) => parsed?.name === "OperationFeesPaid")
+        expect(feesLog).to.not.equal(undefined)
+        expect(feesLog!.args.correlationId).to.equal(withdrawalId)
+        expect(feesLog!.args.isDeposit).to.equal(false)
+        expect(feesLog!.args.portalFee).to.equal(0n)
+        expect(feesLog!.args.podFee).to.equal(1000n)
+        expect(feesLog!.args.podCallbackFee).to.equal(100n)
+
+        const withdrawal = await portal.withdrawals(withdrawalId)
+        expect(withdrawal.status).to.equal(3n) // WithdrawalStatus.Failed
+        await expect(portal.cancelFailedWithdrawal(withdrawalId)).to.be.revertedWithCustomError(
+            portal,
+            "WithdrawalNotPending"
+        )
+        await expect(portal.triggerWithdrawalRelease(withdrawalId)).to.be.revertedWithCustomError(
+            portal,
+            "WithdrawalNotPending"
+        )
+    })
+
+    it("cancels withdrawal after a system-failed pToken transfer", async function () {
+        const { user, portal, pToken, amount } = await deployPortalFixture()
+
+        const deadline = BigInt(Math.floor(Date.now() / 1000) + 3600)
+        const tx = await portal.connect(user).requestWithdrawWithPermit(
+            user.address,
+            amount,
+            0,
+            1000,
+            100,
+            deadline,
+            27,
+            hre.ethers.ZeroHash,
+            hre.ethers.ZeroHash,
+            { value: 1000 }
+        )
+        const receipt = await tx.wait()
+        const withdrawLog = receipt!.logs
+            .map((log) => {
+                try {
+                    return portal.interface.parseLog(log)
+                } catch {
+                    return null
+                }
+            })
+            .find((parsed) => parsed?.name === "WithdrawalRequested")
+        const withdrawalId = withdrawLog!.args.withdrawalId as string
+        const transferRequestId = withdrawLog!.args.transferRequestId as string
+
+        await pToken.markLastTransferSystemFailed()
+        await expect(portal.cancelFailedWithdrawal(withdrawalId))
+            .to.emit(portal, "WithdrawalFailed")
+            .withArgs(withdrawalId, transferRequestId)
+
+        const withdrawal = await portal.withdrawals(withdrawalId)
+        expect(withdrawal.status).to.equal(3n) // WithdrawalStatus.Failed
+    })
+
+    it("rescues native and ERC20 to the factory rescue recipient while paused", async function () {
+        const { owner, other, factory, underlying, portal, pToken } = await deployPortalFixture()
+        const rescueTo = other.address
+        await factory.setRescueRecipient(rescueTo)
+
+        await owner.sendTransaction({ to: await portal.getAddress(), value: parseUnits("1", 18) })
+        await underlying.mint(await portal.getAddress(), parseUnits("50", 6))
+
+        await expect(portal.connect(owner).rescueNative(parseUnits("1", 18))).to.be.revertedWithCustomError(
+            portal,
+            "ExpectedPause"
+        )
+
+        await portal.connect(owner).pause()
+        const rescueNativeAmount = parseUnits("0.4", 18)
+        await expect(portal.connect(owner).rescueNative(rescueNativeAmount))
+            .to.emit(portal, "NativeRescued")
+            .withArgs(rescueTo, rescueNativeAmount)
+
+        const rescueErc20Amount = parseUnits("25", 6)
+        await expect(portal.connect(owner).rescueERC20(await underlying.getAddress(), rescueErc20Amount))
+            .to.emit(portal, "ERC20Rescued")
+            .withArgs(await underlying.getAddress(), rescueTo, rescueErc20Amount)
+
+        await expect(
+            portal.connect(owner).rescueERC20(await pToken.getAddress(), 1)
+        ).to.be.revertedWithCustomError(portal, "CannotRescuePToken")
+    })
+
+    it("sweeps portal fees to the factory fee recipient", async function () {
+        const { owner, user, factory, portal, underlying, amount } = await deployPortalFixture()
+        expect(await factory.feeRecipient()).to.equal(owner.address)
+
+        await portal.connect(owner).setDepositFee(100, 0, parseUnits("1", 18))
+        await underlying.connect(user).approve(await portal.getAddress(), amount)
+        await portal.connect(user).deposit(user.address, amount, 100, 100, { value: 1100 })
+
+        expect(await portal.accumulatedPortalFees()).to.equal(100n)
+        const before = await hre.ethers.provider.getBalance(owner.address)
+        const tx = await portal.connect(owner).withdrawPortalFees(100)
+        const receipt = await tx.wait()
+        const gas = receipt!.gasUsed * receipt!.gasPrice
+        const after = await hre.ethers.provider.getBalance(owner.address)
+        expect(after + gas - before).to.equal(100n)
+        expect(await portal.accumulatedPortalFees()).to.equal(0n)
+    })
+})

package/test/privacyBridge/UnifiedPrivacyBridges.test.cjs

@@ -37,9 +37,11 @@ function validateEnvironment() {
  * @returns {ethers.Wallet}
  */
 function makeSdkWallet() {
-    const raw = process.env.PRIVATE_KEY;
-    if (!raw) throw new Error('PRIVATE_KEY not set in .env');
-    const pk = raw.startsWith('0x') ? raw : '0x' + raw;
+    const raw =
+        process.env.PRIVATE_KEY ||
+        (process.env.SIGNING_KEYS ? process.env.SIGNING_KEYS.split(",")[0]?.trim() : null);
+    if (!raw) throw new Error("PRIVATE_KEY (or SIGNING_KEYS) not set in .env");
+    const pk = raw.startsWith("0x") ? raw : "0x" + raw;
     return new ethers.Wallet(pk, ethers.provider);
 }
 

package/test/utils/mpc/CheckedSignedArithmetic256.test.ts

@@ -0,0 +1,163 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../accounts"
+
+const gasLimit = 12000000
+const MAX_INT256 = (1n << 255n) - 1n
+const MIN_INT256 = -(1n << 255n)
+
+type Deployed = {
+  contract: any
+  owner: any
+}
+
+async function deployNamed(name: string): Promise<Deployed> {
+  const [owner] = await setupAccounts()
+  const factory = await hre.ethers.getContractFactory(name, owner as any)
+  const contract = await factory.deploy({ gasLimit })
+  await contract.waitForDeployment()
+  return { contract, owner }
+}
+
+async function expectRevert(txPromise: Promise<any>, owner: any) {
+  const tx = await txPromise
+  try {
+    await tx.wait()
+    expect.fail("expected transaction to revert")
+  } catch (e) {
+    const receipt = await owner.provider?.getTransactionReceipt(tx.hash)
+    expect(receipt?.status).to.equal(0)
+  }
+}
+
+describe("Checked Signed Arithmetic", function () {
+  describe("narrow (8/16/32/64)", function () {
+    let deployment: Deployed
+
+    before(async function () {
+      deployment = await deployNamed("ArithmeticSignedNarrowTestsContract")
+    })
+
+    for (const func of [
+      "basicSigned8Test",
+      "basicSigned16Test",
+      "basicSigned32Test",
+      "basicSigned64Test",
+      "minDivMinusOne8Test",
+    ]) {
+      it(`${func} should preserve signed integer semantics`, async function () {
+        const { contract } = deployment
+        const tx = await contract.getFunction(func)({ gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+      })
+    }
+
+    for (const func of [
+      "checkedAdd8OverflowTest",
+      "checkedSub8UnderflowTest",
+      "checkedMul8OverflowTest",
+    ]) {
+      it(`${func} should revert`, async function () {
+        const { contract, owner } = deployment
+        await expectRevert(contract.getFunction(func)({ gasLimit }), owner)
+      })
+    }
+  })
+
+  describe("int128", function () {
+    let deployment: Deployed
+
+    before(async function () {
+      deployment = await deployNamed("ArithmeticSigned128TestsContract")
+    })
+
+    for (const func of [
+      "basicSigned128Test",
+      "minDivMinusOne128Test",
+      "plainMul128WrapTest",
+    ]) {
+      it(`${func} should preserve signed integer semantics`, async function () {
+        const { contract } = deployment
+        const tx = await contract.getFunction(func)({ gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+      })
+    }
+
+    for (const func of [
+      "checkedAdd128OverflowTest",
+      "checkedSub128UnderflowTest",
+      "checkedMul128OverflowTest",
+    ]) {
+      it(`${func} should revert`, async function () {
+        const { contract, owner } = deployment
+        await expectRevert(contract.getFunction(func)({ gasLimit }), owner)
+      })
+    }
+  })
+
+  describe("int256", function () {
+    let deployment: Deployed
+
+    before(async function () {
+      deployment = await deployNamed("ArithmeticSigned256TestsContract")
+    })
+
+    for (const func of [
+      "basicSigned256ArithmeticTest",
+      "basicSigned256ComparisonTest",
+      "basicSigned256MuxAndHelpersTest",
+      "minDivMinusOne256Test",
+      "plainMul256WrapTest",
+    ]) {
+      it(`${func} should preserve signed integer semantics`, async function () {
+        const { contract } = deployment
+        const tx = await contract.getFunction(func)({ gasLimit })
+        const receipt = await tx.wait()
+        expect(receipt?.status).to.equal(1)
+      })
+    }
+
+    it("checkedAdd should return an in-range signed result", async function () {
+      const { contract } = deployment
+      const tx = await contract.getFunction("checkedAddTest")(100n, -40n, { gasLimit })
+      await tx.wait()
+      expect(await contract.getFunction("getAddResult")()).to.equal(60n)
+    })
+
+    it("checkedAdd should revert on signed overflow", async function () {
+      const { contract, owner } = deployment
+      await expectRevert(contract.getFunction("checkedAddTest")(MAX_INT256, 1n, { gasLimit }), owner)
+    })
+
+    it("checkedSub should return an in-range signed result", async function () {
+      const { contract } = deployment
+      const tx = await contract.getFunction("checkedSubTest")(-100n, -40n, { gasLimit })
+      await tx.wait()
+      expect(await contract.getFunction("getSubResult")()).to.equal(-60n)
+    })
+
+    it("checkedSub should revert on signed underflow", async function () {
+      const { contract, owner } = deployment
+      await expectRevert(contract.getFunction("checkedSubTest")(MIN_INT256, 1n, { gasLimit }), owner)
+    })
+
+    it("checkedMul should return an in-range signed result", async function () {
+      const { contract } = deployment
+      const tx = await contract.getFunction("checkedMulTest")(-12n, 9n, { gasLimit })
+      await tx.wait()
+      expect(await contract.getFunction("getMulResult")()).to.equal(-108n)
+    })
+
+    it("checkedMul should revert on positive signed overflow", async function () {
+      const { contract, owner } = deployment
+      await expectRevert(contract.getFunction("checkedMulTest")(1n << 128n, 1n << 128n, { gasLimit }), owner)
+    })
+
+    it("checkedMul should revert on min-int negation overflow", async function () {
+      const { contract, owner } = deployment
+      await expectRevert(contract.getFunction("checkedMulTest")(MIN_INT256, -1n, { gasLimit }), owner)
+    })
+  })
+})

package/test/utils/mpc/NegativeCases.test.ts

@@ -420,7 +420,7 @@ describe("Negative Test Cases - 8/16/32/64-bit", function () {
     it("Should handle subtraction resulting in zero", async function () {
       const [owner] = await setupAccounts()
 
-      const factory = await hre.ethers.getContractFactory("ArithmeticTestsContract", owner as any)
+      const factory = await hre.ethers.getContractFactory("ArithmeticSubTestsContract", owner as any)
       const contract = await factory.deploy({ gasLimit })
       await contract.waitForDeployment()
 
@@ -438,7 +438,7 @@ describe("Negative Test Cases - 8/16/32/64-bit", function () {
     it("Should handle max value operations for 8-bit", async function () {
       const [owner] = await setupAccounts()
 
-      const factory = await hre.ethers.getContractFactory("ArithmeticTestsContract", owner as any)
+      const factory = await hre.ethers.getContractFactory("ArithmeticAddTestsContract", owner as any)
       const contract = await factory.deploy({ gasLimit })
       await contract.waitForDeployment()
 
@@ -457,7 +457,7 @@ describe("Negative Test Cases - 8/16/32/64-bit", function () {
     it("Should handle max value operations for 16-bit", async function () {
       const [owner] = await setupAccounts()
 
-      const factory = await hre.ethers.getContractFactory("ArithmeticTestsContract", owner as any)
+      const factory = await hre.ethers.getContractFactory("ArithmeticAddTestsContract", owner as any)
       const contract = await factory.deploy({ gasLimit })
       await contract.waitForDeployment()
 

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

@@ -60,12 +60,12 @@ const bool_a = true
 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("ArithmeticAddTestsContract", "addTest", "getAddResult", params, a + b)
+  buildTest("ArithmeticAddTestsContract", "checkedAddTest", "getAddResult", params, a + b)
+  buildTest("ArithmeticSubTestsContract", "subTest", "getSubResult", params, a - b)
+  buildTest("ArithmeticSubTestsContract", "checkedSubTest", "getSubResult", params, a - b)
+  buildTest("ArithmeticMulTestsContract", "mulTest", "getMulResult", params, a * b)
+  buildTest("ArithmeticMulTestsContract", "checkedMulTest", "getMulResult", params, a * b)
 
   buildTest("MiscellaneousTestsContract", "divTest", "getDivResult", params, a / b)
   buildTest("MiscellaneousTestsContract", "remTest", "getRemResult", params, a % b)

package/typechain-types/@openzeppelin/contracts/access/AccessControl.ts

@@ -206,7 +206,7 @@ export interface AccessControl extends BaseContract {
   >;
 
   renounceRole: TypedContractMethod<
-    [role: BytesLike, account: AddressLike],
+    [role: BytesLike, callerConfirmation: AddressLike],
     [void],
     "nonpayable"
   >;
@@ -250,7 +250,7 @@ export interface AccessControl extends BaseContract {
   getFunction(
     nameOrSignature: "renounceRole"
   ): TypedContractMethod<
-    [role: BytesLike, account: AddressLike],
+    [role: BytesLike, callerConfirmation: AddressLike],
     [void],
     "nonpayable"
   >;

package/typechain-types/@openzeppelin/contracts/access/IAccessControl.ts

@@ -186,7 +186,7 @@ export interface IAccessControl extends BaseContract {
   >;
 
   renounceRole: TypedContractMethod<
-    [role: BytesLike, account: AddressLike],
+    [role: BytesLike, callerConfirmation: AddressLike],
     [void],
     "nonpayable"
   >;
@@ -221,7 +221,7 @@ export interface IAccessControl extends BaseContract {
   getFunction(
     nameOrSignature: "renounceRole"
   ): TypedContractMethod<
-    [role: BytesLike, account: AddressLike],
+    [role: BytesLike, callerConfirmation: AddressLike],
     [void],
     "nonpayable"
   >;