migrate to coti-ethers

Author: Spencer Miller

confidentiality-contracts

@@ -10,9 +10,8 @@
     "nativeTransfer": "ts-node src/main.ts nativeTransfer"
   },
   "devDependencies": {
-    "@coti-io/coti-sdk-typescript": "0.6.4",
+    "@coti-io/coti-ethers": "0.1.1-b",
     "dotenv": "^16.4.5",
-    "ethers": "^6.12.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.5"
   }

package.json

@@ -1,48 +1,38 @@
-import {Provider} from "ethers"
-import {
-    buildStringInputText,
-    type ConfidentialAccount,
-    decryptString,
-    decryptUint,
-    generateAesKey
-} from "@coti-io/coti-sdk-typescript"
+import { itString, itUint, Provider, Wallet } from "@coti-io/coti-ethers"
 import {getContract} from "../util/contracts"
 import {assert} from "../util/assert"
 import {validateTxStatus} from "../util/general-utils";
 
 const gasLimit = 12000000
 
-function getDataOnChainContract(user: ConfidentialAccount) {
-    return getContract("DataOnChain", user.wallet)
+function getDataOnChainContract(user: Wallet) {
+    return getContract("DataOnChain", user)
 }
 
-export async function dataOnChainExample(provider: Provider, user: ConfidentialAccount) {
+export async function dataOnChainExample(provider: Provider, user: Wallet) {
     const contract = getDataOnChainContract(user)
     const value = BigInt(100)
     console.log(`setting network encrypted value: ${value}`)
     await (await contract.setSomeEncryptedValue(value, {gasLimit})).wait()
 
     const networkEncryptedValue = await contract.getNetworkSomeEncryptedValue()
     console.log(`Network encrypted value: ${networkEncryptedValue}`)
-    console.log(`Network decrypted value: ${user.decryptUint(networkEncryptedValue)}`)
+    console.log(`Network decrypted value: ${await user.decryptValue(networkEncryptedValue)}`)
 
     await (await contract.setUserSomeEncryptedValue({gasLimit})).wait()
     console.log(`setting user encrypted value: ${value}`)
 
     const userEncryptedValue = await contract.getUserSomeEncryptedValue()
     console.log(`User encrypted value: ${userEncryptedValue}`)
-    console.log(`User decrypted value: ${user.decryptUint(userEncryptedValue)}`)
-
-    const otherUserKey = generateAesKey()
-    console.log(`Other User decrypted value: ${decryptUint(userEncryptedValue, otherUserKey)}`)
+    console.log(`User decrypted value: ${await user.decryptValue(userEncryptedValue)}`)
 
     const value2 = BigInt(555)
     await setValueWithEncryptedInput(contract, user, value2)
 
     await (await contract.add({gasLimit})).wait()
 
     const encryptedResult = await contract.getUserArithmeticResult()
-    const decryptedResult = user.decryptUint(encryptedResult)
+    const decryptedResult = await user.decryptValue(encryptedResult)
     const expectedResult = value + value2
     assert(
         decryptedResult === expectedResult,
@@ -55,10 +45,10 @@ export async function dataOnChainExample(provider: Provider, user: ConfidentialA
 }
 
 async function testUserEncryptedString(contract: ReturnType<typeof getDataOnChainContract>,
-                                       user: ConfidentialAccount) {
+                                       user: Wallet) {
     const testString = 'test string'
     const func = contract.setSomeEncryptedStringEncryptedInput
-    const encryptedString = await buildStringInputText(testString, user, await contract.getAddress(), func.fragment.selector)
+    const encryptedString = await user.encryptValue(testString, await contract.getAddress(), func.fragment.selector) as itString
     let response = await (await contract.setSomeEncryptedStringEncryptedInput(encryptedString, {gasLimit})).wait()
     if (!validateTxStatus(response)) {
         throw Error("tx setSomeEncryptedStringEncryptedInput failed")
@@ -68,7 +58,7 @@ async function testUserEncryptedString(contract: ReturnType<typeof getDataOnChai
         throw Error("tx to setUserSomeEncryptedStringEncryptedInput failed")
     }
     const userEncyData = await contract.getUserSomeEncryptedStringEncryptedInput()
-    const decryptedUserString: string = decryptString(userEncyData, user.userKey)
+    const decryptedUserString = await user.decryptValue(userEncyData)
     assert(testString === decryptedUserString,
         `Expected test result to be ${testString}, but got ${decryptedUserString}`
     )
@@ -77,22 +67,22 @@ async function testUserEncryptedString(contract: ReturnType<typeof getDataOnChai
 
 async function setValueWithEncryptedInput(
     contract: ReturnType<typeof getDataOnChainContract>,
-    user: ConfidentialAccount,
+    user: Wallet,
     value: bigint
 ) {
     console.log(`setting network encrypted value using user encrypted value: ${value}`)
     const func = contract.setSomeEncryptedValueEncryptedInput
     const {
         ciphertext,
         signature
-    } = user.encryptUint(value.valueOf(), await contract.getAddress(), func.fragment.selector)
+    } = await user.encryptValue(value.valueOf(), await contract.getAddress(), func.fragment.selector) as itUint
 
     await (await func(ciphertext, signature, {gasLimit})).wait()
 
     await (await contract.setUserSomeEncryptedValueEncryptedInput({gasLimit})).wait()
 
     const userEncryptedValue = await contract.getUserSomeEncryptedValueEncryptedInput()
-    const decryptedValue = user.decryptUint(userEncryptedValue)
+    const decryptedValue = await user.decryptValue(userEncryptedValue)
     assert(decryptedValue === value, `Expected value to be ${value}, but got ${decryptedValue}`)
     console.log(`User decrypted using user encrypted value: ${decryptedValue}`)
 }

src/examples/dataOnChain.ts

@@ -1,39 +1,38 @@
-import {Provider, Wallet} from "ethers"
-import {buildInputText, type ConfidentialAccount, decryptUint} from "@coti-io/coti-sdk-typescript"
+import {itUint, Provider, Wallet} from "@coti-io/coti-ethers"
 import {getContract} from "../util/contracts"
 import {assert} from "../util/assert"
 
 const gasLimit = 12000000
 
-async function assertBalance(token: ReturnType<typeof getTokenContract>, amount: number, user: ConfidentialAccount) {
+async function assertBalance(token: ReturnType<typeof getTokenContract>, amount: number, user: Wallet) {
     const ctBalance = await token.balanceOf()
-    let balance = Number(decryptUint(ctBalance, user.userKey))
+    let balance = Number(await user.decryptValue(ctBalance))
     assert(balance === amount, `Expected balance to be ${amount}, but got ${balance}`)
     return balance
 }
 
 async function assertAllowance(
     token: ReturnType<typeof getTokenContract>,
     amount: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     spenderAddress: string
 ) {
-    const ctAllowance = await token.allowance(owner.wallet.address, spenderAddress)
-    let allowance = Number(decryptUint(ctAllowance, owner.userKey))
+    const ctAllowance = await token.allowance(owner.address, spenderAddress)
+    let allowance = Number(await owner.decryptValue(ctAllowance))
     assert(allowance === amount, `Expected allowance to be ${amount}, but got ${allowance}`)
 }
 
-function getTokenContract(user: ConfidentialAccount) {
-    return getContract("ERC20Example", user.wallet)
+function getTokenContract(user: Wallet) {
+    return getContract("ERC20Example", user)
 }
 
-export async function erc20Example(provider: Provider, user: ConfidentialAccount) {
+export async function erc20Example(provider: Provider, user: Wallet) {
     const token = getTokenContract(user)
     const otherWallet = new Wallet(Wallet.createRandom(provider).privateKey)
 
     const transferAmount = 5
 
-    let balance = Number(decryptUint(await token.balanceOf(), user.userKey))
+    let balance = Number(await user.decryptValue(await token.balanceOf()))
     if (balance === 0) {
         await (await token.setBalance(100000000, {gasLimit})).wait()
         balance = await assertBalance(token, 100000000, user)
@@ -53,7 +52,7 @@ export async function erc20Example(provider: Provider, user: ConfidentialAccount
 async function clearTransfer(
     token: ReturnType<typeof getTokenContract>,
     initlalBalance: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     transferAmount: number
 ) {
@@ -71,15 +70,15 @@ async function clearTransfer(
 async function confidentialTransfer(
     token: ReturnType<typeof getTokenContract>,
     initlalBalance: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     transferAmount: number
 ) {
     console.log("************* Transfer confidential ", transferAmount, " from my account to Alice *************")
 
     const func = token["transfer(address,uint256,bytes,bool)"]
     const selector = func.fragment.selector
-    const {ciphertext, signature} = await buildInputText(BigInt(transferAmount), owner, await token.getAddress(), selector)
+    const {ciphertext, signature} = await owner.encryptValue(BigInt(transferAmount), await token.getAddress(), selector) as itUint
 
     await (await func(alice.address, ciphertext, signature, false, {gasLimit})).wait()
     return await assertBalance(token, initlalBalance - transferAmount, owner)
@@ -88,7 +87,7 @@ async function confidentialTransfer(
 async function clearTransferFromWithoutAllowance(
     token: ReturnType<typeof getTokenContract>,
     initlalBalance: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     transferAmount: number
 ) {
@@ -101,14 +100,14 @@ async function clearTransferFromWithoutAllowance(
     await (await token.approveClear(alice.address, 0, {gasLimit})).wait()
 
     const func = token["transferFrom(address,address,uint64,bool)"]
-    await (await func(owner.wallet.address, alice.address, transferAmount, true, {gasLimit})).wait()
+    await (await func(owner.address, alice.address, transferAmount, true, {gasLimit})).wait()
 
     return await assertBalance(token, initlalBalance, owner)
 }
 
 async function clearApprove(
     token: ReturnType<typeof getTokenContract>,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     approveAmount: number
 ) {
@@ -119,7 +118,7 @@ async function clearApprove(
 
 async function confidentialApprove(
     token: ReturnType<typeof getTokenContract>,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     approveAmount: number
 ) {
@@ -129,7 +128,7 @@ async function confidentialApprove(
 
     const func = token["approve(address,uint256,bytes)"]
     const selector = func.fragment.selector
-    const {ciphertext, signature} = await buildInputText(BigInt(approveAmount), owner, await token.getAddress(), selector)
+    const {ciphertext, signature} = await await owner.encryptValue(BigInt(approveAmount), await token.getAddress(), selector) as itUint
     await (await func(alice.address, ciphertext, signature, {gasLimit})).wait()
 
     await assertAllowance(token, approveAmount, owner, alice.address)
@@ -138,31 +137,31 @@ async function confidentialApprove(
 async function clearTransferFrom(
     token: ReturnType<typeof getTokenContract>,
     initlalBalance: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     transferAmount: number
 ) {
     console.log("************* TransferFrom clear ", transferAmount, " from my account to Alice *************")
 
     const func = token["transferFrom(address,address,uint64,bool)"]
-    await (await func(owner.wallet.address, alice.address, transferAmount, true, {gasLimit})).wait()
+    await (await func(owner.address, alice.address, transferAmount, true, {gasLimit})).wait()
 
     return await assertBalance(token, initlalBalance - transferAmount, owner)
 }
 
 async function confidentialTransferFrom(
     token: ReturnType<typeof getTokenContract>,
     initlalBalance: number,
-    owner: ConfidentialAccount,
+    owner: Wallet,
     alice: Wallet,
     transferAmount: number
 ) {
     console.log("************* TransferFrom confidential ", transferAmount, " from my account to Alice *************")
 
     const func = token["transferFrom(address,address,uint256,bytes,bool)"]
     const selector = func.fragment.selector
-    let {ciphertext, signature} = await buildInputText(BigInt(transferAmount), owner, await token.getAddress(), selector)
-    await (await func(owner.wallet.address, alice.address, ciphertext, signature, false, {gasLimit})).wait()
+    let {ciphertext, signature} = await owner.encryptValue(BigInt(transferAmount), await token.getAddress(), selector) as itUint
+    await (await func(owner.address, alice.address, ciphertext, signature, false, {gasLimit})).wait()
 
     return await assertBalance(token, initlalBalance - transferAmount, owner)
 }

src/examples/erc20.ts

@@ -1,5 +1,4 @@
-import {Provider, Wallet} from "ethers";
-import {getNativeBalance, transferNative} from "@coti-io/coti-sdk-typescript";
+import {getNativeBalance, Provider, transferNative, Wallet} from "@coti-io/coti-ethers";
 import {getWallet} from "../util/general-utils";
 
 export async function nativeTransfer(provider: Provider) {

src/examples/nativeTransfer.ts

@@ -4,27 +4,28 @@ import {erc20Example} from "./examples/erc20"
 import {loadDeployments} from "./util/contracts"
 import {dataOnChainExample} from "./examples/dataOnChain"
 import {
-    initEtherProvider,
+    CotiNetwork,
+    getDefaultProvider,
     isProviderConnected,
     printAccountDetails,
     printNetworkDetails,
     validateAddress
-} from "@coti-io/coti-sdk-typescript/dist/ethers_utils";
+} from "@coti-io/coti-ethers";
 import {nativeTransfer} from "./examples/nativeTransfer";
 
 dotenv.config()
 
 async function main() {
     loadDeployments()
-    const provider = initEtherProvider();
+    const provider = getDefaultProvider(CotiNetwork.Devnet);
     if (!await isProviderConnected(provider))
         throw Error('provider not connected')
     await printNetworkDetails(provider)
 
     const owner = await setupAccount(provider)
-    await printAccountDetails(provider, owner.wallet.address)
+    await printAccountDetails(provider, owner.address)
 
-    const validAddress = await validateAddress(owner.wallet.address)
+    const validAddress = await validateAddress(owner.address)
     if (!validAddress.valid) {
         throw Error('Invalid address')
     }

src/main.ts

@@ -1,6 +1,6 @@
 import fs from "fs"
 import path from "path"
-import { Contract, Interface, ContractRunner } from "ethers"
+import { Contract, Interface, ContractRunner } from "@coti-io/coti-ethers"
 import type { ERC20Example, AccountOnboard, DataOnChain } from "../../confidentiality-contracts/typechain-types"
 
 type DeployedContract = { ERC20Example: ERC20Example; AccountOnboard: AccountOnboard; DataOnChain: DataOnChain }
@@ -10,14 +10,11 @@ const deployedContracts: Record<string, Contract> = {}
 
 export function loadDeployments() {
   const files = fs.readdirSync(deploymentsDir)
-  // console.log(`Found ${files.length} deployments -> ${files.join(", ")}`)
 
   files.map((f) => {
     const { address, abi } = JSON.parse(fs.readFileSync(path.join(deploymentsDir, f), "utf-8"))
     deployedContracts[f.replace(".json", "")] = new Contract(address, Interface.from(JSON.stringify(abi)))
   })
-
-  // console.log("Loaded all deployments", Object.keys(deployedContracts))
 }
 
 export function getContract<C extends keyof DeployedContract>(name: C, contractRunner: ContractRunner) {

src/util/contracts.ts

@@ -1,4 +1,4 @@
-import {ContractTransactionReceipt, Provider, Wallet} from "ethers";
+import {Provider, Wallet} from "@coti-io/coti-ethers";
 import fs from "fs";
 
 export function getWallet(provider: Provider) {

src/util/general-utils.ts

@@ -1,5 +1,4 @@
-import {ConfidentialAccount, getAccountBalance} from "@coti-io/coti-sdk-typescript/"
-import { Wallet, Provider } from "ethers"
+import { getAccountBalance, Provider, Wallet } from "@coti-io/coti-ethers"
 import {getWallet, setEnvValue} from "./general-utils";
 
 export async function setupAccount(provider: Provider) {
@@ -10,15 +9,15 @@ export async function setupAccount(provider: Provider) {
 
   const toAccount = async (wallet: Wallet, userKey: string | undefined) => {
     if (userKey) {
-      return new ConfidentialAccount(wallet, userKey)
+      return wallet
     }
 
     console.log("************* Onboarding user ", wallet.address, " *************")
-    const account = await ConfidentialAccount.onboard(wallet)
+    await wallet.generateOrRecoverAes()
     console.log("************* Onboarded! created user key and saved into .env file *************")
 
-    setEnvValue("USER_KEY", account.userKey)
-    return account
+    setEnvValue("USER_KEY", wallet.getUserOnboardInfo()?.aesKey!)
+    return wallet
   }
 
   return toAccount(wallet, process.env.USER_KEY)