// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import "@openzeppelin/contracts/proxy/Proxy.sol";

contract ERCProxy is Proxy {

    address public implementation;

    constructor(address _impleAddress, CampaignParams memory _campaignParams) {
        implementation = _impleAddress;
    }

    function _implementation() internal view override returns (address) {
        return implementation;
    }
}

import { ethers, upgrades } from "hardhat";

async function main() {
  const Box = await ethers.getContractFactory("Box");
  const proxyInstance = await upgrades.deployProxy(Box, [42], {initializer: 'store'});
  await proxyInstance.deployed();
  console.log("Box Proxy deployed to:", proxyInstance.address);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/create-box.ts --network {}
Box Proxy deployed to: 0x0F20c143a98CdfB3a1487278Bcd310296c674498

import { ethers, upgrades } from "hardhat";

const proxyAddress = "0x8d33046c43808974d76C2874c8BbA8eDc06EF495";
async function upgrade() {
  const BoxV2 = await ethers.getContractFactory("BoxV2");

  console.log("Preparing upgrade...");
  // upgrades.prepareUpgrade() 함수는 새로운 임플 컨트랙트 주소를 반환
  const boxV2Address = await upgrades.prepareUpgrade(proxyAddress, BoxV2);
  console.log("BoxV2 Implemantaion address will be :", boxV2Address);
  const boxV2Proxy = await upgrades.upgradeProxy(proxyAddress, BoxV2);
  console.log("upgraded to same proxy address : ", boxV2Proxy.address);
}

upgrade();

npx hardhat run scripts/upgrade-box.ts --network {}
BoxV2 Implemantaion address will be : 0x4C18BB1a60fb0b9fF5747658cEC416CB91a9AE43
upgraded to same proxy address :  0x0F20c143a98CdfB3a1487278Bcd310296c674498

import { expect } from 'chai';
import { Contract } from 'ethers';
import { ethers } from 'hardhat';
  // contracts
  let box: Contract;

  // Start test block
  describe('Box', function () {
    beforeEach(async function () {
      const Box = await ethers.getContractFactory("Box");
      box = await Box.deploy();
      await box.deployed();
      console.log("box deployed",box.address);
    });

    // Test case
    it('retrieve returns a value previously stored', async function () {
      // Store a value
      await box.store(42);

      // Test if the returned value is the same one
      // Note that we need to use strings to compare the 256 bit integers
      expect((await box.retrieve()).toString()).to.equal('42');
    });
  });

import { expect } from "chai";
import { Contract } from "ethers";
import { ethers, upgrades } from "hardhat";
import { getImplementationAddress } from "@openzeppelin/upgrades-core";

// contracts
let boxProxy: Contract;

// Start test block
describe("Box (proxy)", function () {
  beforeEach(async function () {
    const Box = await ethers.getContractFactory("Box");
    boxProxy = await upgrades.deployProxy(Box, [42], { initializer: "store" });
    console.log("boxProxy deployProxy", boxProxy.address);
    const currentImplAddress = await upgrades.erc1967.getImplementationAddress(
      boxProxy.address
    );
    console.log("currentImplAddress", currentImplAddress);
  });

  // Test case
  it("retrieve returns a value previously initialized", async function () {
    // Test if the returned value is the same one
    // Note that we need to use strings to compare the 256 bit integers
    expect((await boxProxy.retrieve()).toString()).to.equal("42");
  });
});

import { expect } from 'chai';
import { Contract } from 'ethers';
import { ethers, upgrades } from 'hardhat';
  // contracts
  let boxV2: Contract;

// Start test block
describe('BoxV2', function () {
  beforeEach(async function () {
    const BoxV2 = await ethers.getContractFactory("BoxV2");
    boxV2 = await BoxV2.deploy();
    await boxV2.deployed();
    console.log("boxV2 deployed",boxV2.address);
  });

  // Test case
  it('retrieve returns a value previously stored', async function () {
    // Store a value
    await boxV2.store(42);

    // Test if the returned value is the same one
    // Note that we need to use strings to compare the 256 bit integers
    expect((await boxV2.retrieve()).toString()).to.equal('42');
  });

  // Test case
  it('retrieve returns a value previously incremented', async function () {
    // Increment
    await boxV2.increment();

    // Test if the returned value is the same one
    // Note that we need to use strings to compare the 256 bit integers
    expect((await boxV2.retrieve()).toString()).to.equal('1');
  });
});

import { expect } from "chai";
import { Contract } from "ethers";
import { ethers, upgrades } from "hardhat";
// contracts
let boxProxy: Contract;
let boxV2Proxy: Contract;
// Start test block
describe("BoxV2 (proxy)", function () {
  beforeEach(async function () {
    const Box = await ethers.getContractFactory("Box");
    const BoxV2 = await ethers.getContractFactory("BoxV2");

    boxProxy = await upgrades.deployProxy(Box, [42], { initializer: "store" });
    console.log("deployProxy", boxProxy.address);
    let boxV2Implentaion = await upgrades.prepareUpgrade(
      boxProxy.address,
      BoxV2
    );
    console.log("implementation V2 address : ", boxV2Implentaion);
    boxV2Proxy = await upgrades.upgradeProxy(boxProxy.address, BoxV2);
    console.log("upgradeProxy", boxV2Proxy.address);
  });

  // Test case
  it("retrieve returns a value previously incremented", async function () {
    // Increment
    await boxV2Proxy.increment();

    // Test if the returned value is the same one
    // Note that we need to use strings to compare the 256 bit integers
    expect((await boxV2Proxy.retrieve()).toString()).to.equal("43");
  });
});