@gooddollar/goodprotocol 2.0.13 → 2.0.14-beta.0

package/test/token/CeloGasToken.test.ts

@@ -0,0 +1,108 @@
+import { ethers } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import { SuperGoodDollar } from "../../types";
+import { createDAO } from "../helpers";
+import { BigNumber } from "ethers";
+
+const BN = ethers.BigNumber;
+
+describe("Celo Gas Token", () => {
+  let token: SuperGoodDollar, founder;
+  let signers;
+
+  const initialState = async () => {};
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+
+    let { gd: gooddollar } = await loadFixture(createDAO);
+
+    token = (await ethers.getContractAt(
+      "SuperGoodDollar",
+      gooddollar
+    )) as SuperGoodDollar;
+    await token.mint(founder.address, ethers.constants.WeiPerEther.mul(100));
+  });
+
+  it("should debit sender for gas fees", async () => {
+    await loadFixture(initialState);
+
+    await founder.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.constants.WeiPerEther
+    });
+    const vm = await ethers.getImpersonatedSigner(ethers.constants.AddressZero);
+    let ts = await token.totalSupply();
+    let balance = await token.balanceOf(founder.address);
+    const fee = ethers.constants.WeiPerEther.div(100);
+    await token.connect(vm).debitGasFees(founder.address, BigNumber.from(fee));
+    expect(await token.balanceOf(founder.address)).eq(balance.sub(fee));
+    expect(await token.totalSupply()).eq(ts.sub(fee));
+  });
+
+  it("should credit sender for gas fees", async () => {
+    await loadFixture(initialState);
+
+    await founder.sendTransaction({
+      to: ethers.constants.AddressZero,
+      value: ethers.constants.WeiPerEther
+    });
+    const vm = await ethers.getImpersonatedSigner(ethers.constants.AddressZero);
+    let ts = await token.totalSupply();
+    let balance = await token.balanceOf(founder.address);
+    const fee = ethers.constants.WeiPerEther.div(100);
+
+    const [recipient, gateway, fund] = signers;
+    const [refund, recipientFee, gatewayFee, fundFee] = [
+      fee.div(10),
+      fee.div(100),
+      fee.div(200),
+      fee.div(300)
+    ];
+
+    await token.connect(vm).debitGasFees(founder.address, BigNumber.from(fee));
+    await token
+      .connect(vm)
+      .creditGasFees(
+        founder.address,
+        recipient.address,
+        gateway.address,
+        fund.address,
+        refund,
+        recipientFee,
+        gatewayFee,
+        fundFee
+      );
+
+    expect(await token.balanceOf(founder.address)).eq(
+      balance.sub(fee).add(refund)
+    );
+    expect(await token.balanceOf(recipient.address)).eq(recipientFee);
+    expect(await token.balanceOf(gateway.address)).eq(gatewayFee);
+    expect(await token.balanceOf(fund.address)).eq(fundFee);
+    expect(await token.totalSupply()).eq(
+      ts.sub(fee).add(refund).add(recipientFee).add(gatewayFee).add(fundFee)
+    );
+  });
+
+  it("should only be callable by VM", async () => {
+    await loadFixture(initialState);
+
+    await expect(
+      token.debitGasFees(founder.address, BigNumber.from(1))
+    ).revertedWith("VM");
+    await expect(
+      token.creditGasFees(
+        founder.address,
+        founder.address,
+        founder.address,
+        founder.address,
+        1,
+        1,
+        1,
+        1
+      )
+    ).revertedWith("VM");
+  });
+});

package/test/token/SuperGoodDollar.test.ts

@@ -15,7 +15,7 @@ let sf,
   newHost,
   identityMock,
   receiverMock,
-  sgd, // stands for "SuperGoodDollar"
+  sgd: ISuperGoodDollar, // stands for "SuperGoodDollar"
   feesFormula10PctMock;
 
 const alotOfDollars = ethers.utils.parseEther("100000");
@@ -65,7 +65,8 @@ before(async function () {
     founder
   ).deploy();
 
-  sgd = await deploySuperGoodDollar(sfContracts, [
+  console.log("deploying test supergooddollar...");
+  sgd = (await deploySuperGoodDollar(sfContracts, [
     "SuperGoodDollar",
     "SGD",
     0, // cap
@@ -73,7 +74,7 @@ before(async function () {
     identityMock.address,
     receiverMock.address,
     founder.address
-  ]);
+  ])) as ISuperGoodDollar;
 
   await sgd.mint(founder.address, alotOfDollars);
 });
@@ -244,13 +245,17 @@ describe("SuperGoodDollar", async function () {
   it("should not be able to initialize again", async () => {
     await loadFixture(initialState);
     await expect(
-      sgd["initialize(string,string,uint256,address,address,address,address)"](
+      sgd[
+        "initialize(string,string,uint256,address,address,address,address,address,address)"
+      ](
         "x",
         "y",
         1,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
         ethers.constants.AddressZero
       )
     ).revertedWith("Initializable: contract is already initialized");
@@ -268,7 +273,7 @@ describe("SuperGoodDollar", async function () {
   it("update the GoodDollar logic", async function () {
     await loadFixture(initialState);
     const sgdProxiable = await ethers.getContractAt(
-      "UUPSProxiable",
+      "contracts/token/superfluid/UUPSProxiable.sol:UUPSProxiable",
       sgd.address,
       founder.signer
     );
@@ -295,13 +300,17 @@ describe("SuperGoodDollar", async function () {
 
     expect(await sgd.getHost()).equal(newHost.address);
     await expect(
-      sgd["initialize(string,string,uint256,address,address,address,address)"](
+      sgd[
+        "initialize(string,string,uint256,address,address,address,address,address,address)"
+      ](
         "x",
         "y",
         1,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
         ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
         ethers.constants.AddressZero
       )
     ).revertedWith("Initializable: contract is already initialized");

package/test/utils/AdminWallet.test.ts

@@ -30,7 +30,17 @@ describe("AdminWallet", () => {
   before(async () => {
     signers = await ethers.getSigners();
     founder = signers[0];
-    [whitelisted, stranger, stranger2, blacklisted, newUser, newUser2, admin, admin2, toWhitelist] = signers.slice(10);
+    [
+      whitelisted,
+      stranger,
+      stranger2,
+      blacklisted,
+      newUser,
+      newUser2,
+      admin,
+      admin2,
+      toWhitelist
+    ] = signers.slice(10);
     let { identity: id, nameService, gd } = await loadFixture(createDAO);
     identity = await ethers.getContractAt("IdentityV2", id);
     gooddollar = await ethers.getContractAt("GoodDollar", gd);
@@ -40,7 +50,10 @@ describe("AdminWallet", () => {
       { kind: "uups" }
     )) as AdminWallet;
 
-    await identity.grantRole(ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")), adminWallet.address);
+    await identity.grantRole(
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+      adminWallet.address
+    );
 
     toppingTimes = await adminWallet.toppingTimes();
     toppingAmount = await adminWallet.toppingAmount();
@@ -80,15 +93,21 @@ describe("AdminWallet", () => {
   });
 
   it("should have owner", async () => {
-    expect(await adminWallet.hasRole(ethers.constants.HashZero, signers[0].address)).to.eq(true);
+    expect(
+      await adminWallet.hasRole(ethers.constants.HashZero, signers[0].address)
+    ).to.eq(true);
   });
 
   it("should not top admin list when empty", async () => {
-    await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith("Admin list is empty");
+    await expect(adminWallet["topAdmins(uint256)"](0)).revertedWith(
+      "Admin list is empty"
+    );
   });
 
   it("should add admins", async () => {
-    await adminWallet.addAdmins([whitelisted, admin, admin2].map(_ => _.address));
+    await adminWallet.addAdmins(
+      [whitelisted, admin, admin2].map(_ => _.address)
+    );
     expect(await adminWallet.isAdmin(whitelisted.address)).true;
     expect(await adminWallet.isAdmin(admin.address)).to.true;
     expect(await adminWallet.isAdmin(admin2.address)).to.true;
@@ -105,14 +124,22 @@ describe("AdminWallet", () => {
     expect(await ethers.provider.getBalance(admin2.address)).eq(0);
     await adminWallet["topAdmins(uint256)"](0);
     const newBalance = await ethers.provider.getBalance(admin2.address);
-    const adminTopAmount = await adminWallet.adminToppingAmount().then(_ => _.toString());
+    const adminTopAmount = await adminWallet
+      .adminToppingAmount()
+      .then(_ => _.toString());
     expect(newBalance).to.be.equal(adminTopAmount);
   });
 
   it("should reimburse gas for admins", async () => {
-    const expectedTopping = await adminWallet.adminToppingAmount().then(_ => _.toString());
-    const adminWalletBalance = await ethers.provider.getBalance(adminWallet.address);
-    expect(expectedTopping).to.be.equal(ethers.utils.parseUnits("90000000", "gwei"));
+    const expectedTopping = await adminWallet
+      .adminToppingAmount()
+      .then(_ => _.toString());
+    const adminWalletBalance = await ethers.provider.getBalance(
+      adminWallet.address
+    );
+    expect(expectedTopping).to.be.equal(
+      ethers.utils.parseUnits("90000000", "gwei")
+    );
     expect(adminWalletBalance).gt(1);
     let oldBalance = await ethers.provider.getBalance(admin2.address);
     let toTransfer = oldBalance.div(2);
@@ -124,7 +151,12 @@ describe("AdminWallet", () => {
     oldBalance = await ethers.provider.getBalance(admin2.address);
     expect(oldBalance).to.be.lte(toTransfer);
 
-    await adminWallet.connect(admin2)["whitelist(address,string)"](toWhitelist.address, "did:test" + Math.random());
+    await adminWallet
+      .connect(admin2)
+      ["whitelist(address,string)"](
+        toWhitelist.address,
+        "did:test" + Math.random()
+      );
     const newBalance = await ethers.provider.getBalance(admin2.address);
     expect(newBalance).to.be.gte(expectedTopping);
   });
@@ -136,7 +168,9 @@ describe("AdminWallet", () => {
 
   it("should allow admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin)["whitelist(address,string)"](whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
 
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
     await adminWallet.connect(admin).removeWhitelist(whitelisted.address);
@@ -146,14 +180,18 @@ describe("AdminWallet", () => {
   it("should not allow non-admin to whitelist and remove whitelist", async () => {
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
     await expect(
-      adminWallet.connect(stranger)["whitelist(address,string)"](whitelisted.address, "did:test")
+      adminWallet
+        .connect(stranger)
+        ["whitelist(address,string)"](whitelisted.address, "did:test")
     ).revertedWith("Caller is not admin");
     expect(await identity.isWhitelisted(whitelisted.address)).to.false;
-    await adminWallet.connect(admin)["whitelist(address,string)"](whitelisted.address, "did:test");
+    await adminWallet
+      .connect(admin)
+      ["whitelist(address,string)"](whitelisted.address, "did:test");
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
-    await expect(adminWallet.connect(stranger).removeWhitelist(whitelisted.address)).revertedWith(
-      "Caller is not admin"
-    );
+    await expect(
+      adminWallet.connect(stranger).removeWhitelist(whitelisted.address)
+    ).revertedWith("Caller is not admin");
     expect(await identity.isWhitelisted(whitelisted.address)).to.true;
   });
 
@@ -168,13 +206,15 @@ describe("AdminWallet", () => {
 
   it("should not allow non-admin to blacklist and remove blacklist", async () => {
     expect(await identity.isBlacklisted(blacklisted.address)).to.false;
-    await expect(adminWallet.connect(stranger).blacklist(blacklisted.address)).revertedWith("Caller is not admin");
+    await expect(
+      adminWallet.connect(stranger).blacklist(blacklisted.address)
+    ).revertedWith("Caller is not admin");
     expect(await identity.isBlacklisted(blacklisted.address)).to.false;
     await adminWallet.connect(admin).blacklist(blacklisted.address);
     expect(await identity.isBlacklisted(blacklisted.address)).to.true;
-    await expect(adminWallet.connect(stranger).removeBlacklist(blacklisted.address)).revertedWith(
-      "Caller is not admin"
-    );
+    await expect(
+      adminWallet.connect(stranger).removeBlacklist(blacklisted.address)
+    ).revertedWith("Caller is not admin");
     expect(await identity.isBlacklisted(blacklisted.address)).to.true;
     await adminWallet.connect(admin).removeBlacklist(blacklisted.address);
     expect(await identity.isBlacklisted(blacklisted.address)).to.false;
@@ -182,15 +222,16 @@ describe("AdminWallet", () => {
 
   it("should not allow to top wallet if user balance is too high", async () => {
     const walletBalance = await ethers.provider.getBalance(adminWallet.address);
-    const tx = await (await adminWallet.connect(admin).topWallet(whitelisted.address)).wait();
-    const walletBalanceAfter = await ethers.provider.getBalance(adminWallet.address);
-    expect(walletBalance).eq(walletBalanceAfter);
-    expect(tx.logs.length).eq(0);
+    await expect(
+      adminWallet.connect(admin).topWallet(whitelisted.address)
+    ).revertedWith("hasBalance");
   });
 
   it("should not allow to top wallet if user gd balance unchanged", async () => {
     expect(await ethers.provider.getBalance(newUser.address)).eq(0);
-    await expect(adminWallet.connect(admin).topWallet(newUser.address)).revertedWith("User has not used G$");
+    await expect(
+      adminWallet.connect(admin).topWallet(newUser.address)
+    ).revertedWith("User has not used G$");
   });
 
   it("should allow to top wallet if user gd balance changed", async () => {
@@ -223,32 +264,50 @@ describe("AdminWallet", () => {
     });
 
     await gooddollar.mint(newUser.address, 1);
-    await expect(adminWallet.connect(admin).topWallet(newUser.address)).revertedWith(
-      "User wallet has been topped too many times today"
-    );
+    await expect(
+      adminWallet.connect(admin).topWallet(newUser.address)
+    ).revertedWith("User wallet has been topped too many times today");
   });
 
   it("should whitelist user", async () => {
     expect(await identity.isWhitelisted(stranger2.address)).to.false;
-    await adminWallet.connect(admin2)["whitelist(address,string)"](stranger2.address, "did:test3");
+    await adminWallet
+      .connect(admin2)
+      ["whitelist(address,string)"](stranger2.address, "did:test3");
     expect(await identity.isWhitelisted(stranger2.address)).to.true;
   });
 
   it("should not allow whitelisting with existing did", async () => {
-    await expect(adminWallet.connect(admin2)["whitelist(address,string)"](stranger.address, "did:test")).revertedWith(
-      "DID already registered"
-    );
+    await expect(
+      adminWallet
+        .connect(admin2)
+        ["whitelist(address,string)"](stranger.address, "did:test")
+    ).revertedWith("DID already registered");
   });
 
   it("should not allow anyone to upgrade", async () => {
-    await expect(adminWallet.connect(admin2).upgradeTo(adminWallet.address)).revertedWith("not owner");
+    await expect(
+      adminWallet.connect(admin2).upgradeTo(adminWallet.address)
+    ).revertedWith("not owner");
   });
 
   it("should allow owner to upgrade", async () => {
-    const newver = await (await ethers.getContractFactory("AdminWallet")).deploy();
-    await expect(adminWallet.connect(founder).upgradeTo(newver.address)).not.reverted;
-
-    await upgrades.forceImport(adminWallet.address, await ethers.getContractFactory("AdminWallet"), { kind: "uups" });
-    await expect(upgrades.upgradeProxy(adminWallet.address, await ethers.getContractFactory("AdminWallet"))).not.throws;
+    const newver = await (
+      await ethers.getContractFactory("AdminWallet")
+    ).deploy();
+    await expect(adminWallet.connect(founder).upgradeTo(newver.address)).not
+      .reverted;
+
+    await upgrades.forceImport(
+      adminWallet.address,
+      await ethers.getContractFactory("AdminWallet"),
+      { kind: "uups" }
+    );
+    await expect(
+      upgrades.upgradeProxy(
+        adminWallet.address,
+        await ethers.getContractFactory("AdminWallet")
+      )
+    ).not.throws;
   });
 });

package/test/utils/BuyAndBridgeHelper.test.ts

@@ -1,26 +1,14 @@
 import { ethers, upgrades } from "hardhat";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import {
-  GoodReserveCDai,
-  DistributionBridgeMock,
-  IGoodDollar
-} from "../../types";
+import { GoodReserveCDai, DistributionBridgeMock, IGoodDollar } from "../../types";
 import { createDAO } from "../helpers";
 
 export const NULL_ADDRESS = ethers.constants.AddressZero;
 
-describe("BuyAndBridgeHelper ", () => {
+xdescribe("BuyAndBridgeHelper ", () => {
   let goodReserve: GoodReserveCDai;
-  let goodDollar: IGoodDollar,
-    deployedDAO,
-    genericCall,
-    avatar,
-    founder,
-    signers,
-    setDAOAddress,
-    nameService,
-    cDai;
+  let goodDollar: IGoodDollar, deployedDAO, genericCall, avatar, founder, signers, setDAOAddress, nameService, cDai;
 
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
@@ -58,16 +46,10 @@ describe("BuyAndBridgeHelper ", () => {
 
     await setDAOAddress("UNISWAP_ROUTER", signers[0].address);
 
-    const exchangeHelperFactory = await ethers.getContractFactory(
-      "ExchangeHelper"
-    );
+    const exchangeHelperFactory = await ethers.getContractFactory("ExchangeHelper");
     const bnbFactory = await ethers.getContractFactory("BuyAndBridgeHelper");
 
-    const exchangeHelper = await upgrades.deployProxy(
-      exchangeHelperFactory,
-      [nameService.address],
-      { kind: "uups" }
-    );
+    const exchangeHelper = await upgrades.deployProxy(exchangeHelperFactory, [nameService.address], { kind: "uups" });
 
     await setDAOAddress("EXCHANGE_HELPER", exchangeHelper.address);
 
@@ -87,9 +69,7 @@ describe("BuyAndBridgeHelper ", () => {
     expect(await exchangeHelper.gd()).equal(goodDollar.address);
     expect(await exchangeHelper.fuseBridge()).equal(bridge.address);
     expect(await exchangeHelper.multiChainBridge()).equal(bridge.address);
-    expect(await exchangeHelper.anyGoodDollar()).equal(
-      ethers.constants.AddressZero
-    );
+    expect(await exchangeHelper.anyGoodDollar()).equal(ethers.constants.AddressZero);
   });
 
   it("should buy and bridge to Fuse", async () => {
@@ -124,9 +104,7 @@ describe("BuyAndBridgeHelper ", () => {
     const priceAfter = await goodReserve["currentPrice()"]();
     const gdxBalanceAfter = await goodReserve.balanceOf(founder.address);
     const bridgeBalanceAfter = await goodDollar.balanceOf(bridge.address);
-    const helperGdBalanceAfter = await goodDollar.balanceOf(
-      exchangeHelper.address
-    );
+    const helperGdBalanceAfter = await goodDollar.balanceOf(exchangeHelper.address);
 
     expect(helperGdBalanceAfter).eq(0); //G$s should be at the fuse bridge
     expect(helperBalanceAfter).equal(0);
@@ -143,7 +121,7 @@ describe("BuyAndBridgeHelper ", () => {
     expect(events[0].args.data).to.equal(founder.address.toLowerCase());
   });
 
-  it("should buy and bridge to Celo", async () => {
+  xit("should buy and bridge to Celo", async () => {
     const { exchangeHelper, bridge } = await loadFixture(fixture);
     let daiAmount = ethers.utils.parseEther("100");
     const dai = await ethers.getContractAt("DAIMock", deployedDAO.daiAddress);
@@ -176,9 +154,7 @@ describe("BuyAndBridgeHelper ", () => {
     const priceAfter = await goodReserve["currentPrice()"]();
     const gdxBalanceAfter = await goodReserve.balanceOf(founder.address);
     const bridgeBalanceAfter = await goodDollar.balanceOf(bridge.address);
-    const helperGdBalanceAfter = await goodDollar.balanceOf(
-      exchangeHelper.address
-    );
+    const helperGdBalanceAfter = await goodDollar.balanceOf(exchangeHelper.address);
 
     expect(helperGdBalanceAfter).gt(0); //in case of the mock it doesnt call transferFrom, so bought G$s stay in helper when testing multichain
     expect(helperBalanceAfter).equal(0);

package/truffle-config.js

@@ -63,7 +63,10 @@ module.exports = {
       network_id: 1
     },
     kovan: {
-      provider: () => new Web3.providers.HttpProvider(`https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
+      provider: () =>
+        new Web3.providers.HttpProvider(
+          `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`
+        ),
       network_id: 42, // Ropsten's id
       gas: 5500000, // Ropsten has a lower block limit than mainnet
       confirmations: 2, // # of confs to wait between deployments. (default: 0)
@@ -71,7 +74,10 @@ module.exports = {
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
     ropsten: {
-      provider: () => new Web3.providers.HttpProvider(`https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
+      provider: () =>
+        new Web3.providers.HttpProvider(
+          `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`
+        ),
       network_id: 3, // Ropsten's id
       gas: 5000000, // Ropsten has a lower block limit than mainnet
       confirmations: 2, // # of confs to wait between deployments. (default: 0)
@@ -79,7 +85,8 @@ module.exports = {
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
     goerli: {
-      provider: () => new Web3.providers.HttpProvider(`https://rpc.ankr.io/eth_goerli`),
+      provider: () =>
+        new Web3.providers.HttpProvider(`https://rpc.ankr.io/eth_goerli`),
       network_id: 5, // Ropsten's id
       gas: 3000000, // Ropsten has a lower block limit than mainnet
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
@@ -93,7 +100,8 @@ module.exports = {
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
     fusespark: {
-      provider: () => new Web3.providers.HttpProvider(`https://rpc.fusespark.io`),
+      provider: () =>
+        new Web3.providers.HttpProvider(`https://rpc.fusespark.io`),
       network_id: 123, // Ropsten's id
       gas: 8000000, // Ropsten has a lower block limit than mainnet
       confirmations: 1, // # of confs to wait between deployments. (default: 0)
@@ -108,8 +116,18 @@ module.exports = {
       timeoutBlocks: 20, // # of blocks before a deployment times out  (minimum/default: 50)
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     },
+    mainnet: {
+      provider: () =>
+        new Web3.providers.HttpProvider(`https://cloudflare-eth.com`),
+      network_id: 1,
+      gas: 150000,
+      skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
+    },
     alfajores: {
-      provider: () => new Web3.providers.HttpProvider(`https://alfajores-forno.celo-testnet.org`),
+      provider: () =>
+        new Web3.providers.HttpProvider(
+          `https://alfajores-forno.celo-testnet.org`
+        ),
       network_id: 44787, // Ropsten's id
       gas: 150000, // Ropsten has a lower block limit than mainnet
       confirmations: 1, // # of confs to wait between deployments. (default: 0)
@@ -133,7 +151,7 @@ module.exports = {
   // Configure your compilers
   compilers: {
     solc: {
-      version: "0.8.16", // Fetch exact version from solc-bin (default: truffle's version)
+      version: "0.8.19", // Fetch exact version from solc-bin (default: truffle's version)
       settings: {
         // See the solidity docs for advice about optimization and evmVersion
         optimizer: {