@mapprotocol/common-contracts 0.1.1 → 0.3.0

package/typechain-types/factories/contracts/factory/Create2Factory__factory.ts

@@ -0,0 +1,163 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  Contract,
+  ContractFactory,
+  ContractTransactionResponse,
+  Interface,
+} from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../common";
+import type {
+  Create2Factory,
+  Create2FactoryInterface,
+} from "../../../contracts/factory/Create2Factory";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "addr",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+    ],
+    name: "Deployed",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes",
+        name: "creationCode",
+        type: "bytes",
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+    ],
+    name: "deploy",
+    outputs: [
+      {
+        internalType: "address",
+        name: "addr",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "codeHash",
+        type: "bytes32",
+      },
+    ],
+    name: "getAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "codeHash",
+        type: "bytes32",
+      },
+    ],
+    name: "getAddressTron",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+const _bytecode =
+  "0x6080604052348015600f57600080fd5b506102f98061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063933559b014610046578063c7aeef0f14610075578063d3a3968614610088575b600080fd5b61005961005436600461018e565b61009b565b6040516001600160a01b03909116815260200160405180910390f35b6100596100833660046101c6565b6100d8565b61005961009636600461018e565b61016c565b6040516000906100b990604160f81b9030908690869060200161028a565b60408051601f1981840301815291905280516020909101209392505050565b60008383516020850184f590506001600160a01b03811661012f5760405162461bcd60e51b815260206004820152600d60248201526c1111541313d657d19052531151609a1b604482015260640160405180910390fd5b60405184906001600160a01b038316907f94bfd9af14ef450884c8a7ddb5734e2e1e14e70a1c84f0801cc5a29e34d2642890600090a39392505050565b6040516000906100b9906001600160f81b03199030908690869060200161028a565b600080604083850312156101a157600080fd5b50508035926020909101359150565b634e487b7160e01b600052604160045260246000fd5b6000806000606084860312156101db57600080fd5b83359250602084013567ffffffffffffffff808211156101fa57600080fd5b818601915086601f83011261020e57600080fd5b813581811115610220576102206101b0565b604051601f8201601f19908116603f01168101908382118183101715610248576102486101b0565b8160405282815289602084870101111561026157600080fd5b826020860160208301376000602084830101528096505050505050604084013590509250925092565b6001600160f81b031994909416845260609290921b6bffffffffffffffffffffffff19166001840152601583015260358201526055019056fea26469706673582212205fb7d781d8404b93aed56d95e5543997fe78a250c5faf35b40c771504b4c853b64736f6c63430008190033";
+
+type Create2FactoryConstructorParams =
+  | [signer?: Signer]
+  | ConstructorParameters<typeof ContractFactory>;
+
+const isSuperArgs = (
+  xs: Create2FactoryConstructorParams
+): xs is ConstructorParameters<typeof ContractFactory> => xs.length > 1;
+
+export class Create2Factory__factory extends ContractFactory {
+  constructor(...args: Create2FactoryConstructorParams) {
+    if (isSuperArgs(args)) {
+      super(...args);
+    } else {
+      super(_abi, _bytecode, args[0]);
+    }
+  }
+
+  override getDeployTransaction(
+    overrides?: NonPayableOverrides & { from?: string }
+  ): Promise<ContractDeployTransaction> {
+    return super.getDeployTransaction(overrides || {});
+  }
+  override deploy(overrides?: NonPayableOverrides & { from?: string }) {
+    return super.deploy(overrides || {}) as Promise<
+      Create2Factory & {
+        deploymentTransaction(): ContractTransactionResponse;
+      }
+    >;
+  }
+  override connect(runner: ContractRunner | null): Create2Factory__factory {
+    return super.connect(runner) as Create2Factory__factory;
+  }
+
+  static readonly bytecode = _bytecode;
+  static readonly abi = _abi;
+  static createInterface(): Create2FactoryInterface {
+    return new Interface(_abi) as Create2FactoryInterface;
+  }
+  static connect(
+    address: string,
+    runner?: ContractRunner | null
+  ): Create2Factory {
+    return new Contract(address, _abi, runner) as unknown as Create2Factory;
+  }
+}

package/typechain-types/factories/contracts/factory/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { Create2Factory__factory } from "./Create2Factory__factory";

package/typechain-types/factories/contracts/index.ts

@@ -2,4 +2,5 @@
 /* tslint:disable */
 /* eslint-disable */
 export * as base from "./base";
+export * as factory from "./factory";
 export { AuthorityManager__factory } from "./AuthorityManager__factory";

package/typechain-types/hardhat.d.ts

@@ -89,6 +89,10 @@ declare module "hardhat/types/runtime" {
       name: "BaseImplementation",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.BaseImplementation__factory>;
+    getContractFactory(
+      name: "Create2Factory",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.Create2Factory__factory>;
 
     getContractAt(
       name: "AccessManagedUpgradeable",
@@ -185,6 +189,11 @@ declare module "hardhat/types/runtime" {
       address: string | ethers.Addressable,
       signer?: ethers.Signer
     ): Promise<Contracts.BaseImplementation>;
+    getContractAt(
+      name: "Create2Factory",
+      address: string | ethers.Addressable,
+      signer?: ethers.Signer
+    ): Promise<Contracts.Create2Factory>;
 
     deployContract(
       name: "AccessManagedUpgradeable",
@@ -262,6 +271,10 @@ declare module "hardhat/types/runtime" {
       name: "BaseImplementation",
       signerOrOptions?: ethers.Signer | DeployContractOptions
     ): Promise<Contracts.BaseImplementation>;
+    deployContract(
+      name: "Create2Factory",
+      signerOrOptions?: ethers.Signer | DeployContractOptions
+    ): Promise<Contracts.Create2Factory>;
 
     deployContract(
       name: "AccessManagedUpgradeable",
@@ -358,6 +371,11 @@ declare module "hardhat/types/runtime" {
       args: any[],
       signerOrOptions?: ethers.Signer | DeployContractOptions
     ): Promise<Contracts.BaseImplementation>;
+    deployContract(
+      name: "Create2Factory",
+      args: any[],
+      signerOrOptions?: ethers.Signer | DeployContractOptions
+    ): Promise<Contracts.Create2Factory>;
 
     // default types
     getContractFactory(

package/typechain-types/index.ts

@@ -44,3 +44,5 @@ export type { AuthorityManager } from "./contracts/AuthorityManager";
 export { AuthorityManager__factory } from "./factories/contracts/AuthorityManager__factory";
 export type { BaseImplementation } from "./contracts/base/BaseImplementation";
 export { BaseImplementation__factory } from "./factories/contracts/base/BaseImplementation__factory";
+export type { Create2Factory } from "./contracts/factory/Create2Factory";
+export { Create2Factory__factory } from "./factories/contracts/factory/Create2Factory__factory";

package/utils/addressCodec.ts

@@ -0,0 +1,57 @@
+/**
+ * Multi-chain address encoding — converts EVM, Tron, and Solana addresses to hex bytes.
+ */
+import bs58 from "bs58";
+import { tronToHex } from "./tronHelper";
+
+/**
+ * Convert any address format to hex bytes.
+ * - EVM address (0x prefix): return as-is lowercase
+ * - Tron address (T prefix, 34 chars, 0x41 byte): convert via tronToHex
+ * - Solana/other base58 address: base58 decode to full bytes
+ * @param addr - address in any supported format
+ */
+export function addressToHex(addr: string): string {
+    if (addr.startsWith("0x")) {
+        return addr.toLowerCase();
+    }
+
+    if (isTronAddress(addr)) {
+        return tronToHex(addr);
+    }
+
+    if (isBase58(addr)) {
+        const decoded = bs58.decode(addr);
+        return "0x" + Buffer.from(decoded).toString("hex");
+    }
+
+    throw new Error(`Unknown address format: ${addr}`);
+}
+
+/** Check if a string is valid base58 encoding. */
+export function isBase58(addr: string): boolean {
+    const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    for (const char of addr) {
+        if (!base58Chars.includes(char)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/** Check if address is Tron format (T prefix, 34 chars, 0x41 first byte after decode). */
+export function isTronAddress(addr: string): boolean {
+    if (!addr.startsWith("T") || addr.length !== 34 || !isBase58(addr)) return false;
+    try {
+        const decoded = bs58.decode(addr);
+        // Tron: 0x41 (1 byte) + address (20 bytes) + checksum (4 bytes) = 25 bytes
+        return decoded.length === 25 && decoded[0] === 0x41;
+    } catch {
+        return false;
+    }
+}
+
+/** Check if chain name is Solana. */
+export function isSolanaChain(chainName: string): boolean {
+    return chainName === "Sol" || chainName === "sol_test";
+}

package/utils/codeHash.ts

@@ -0,0 +1,75 @@
+/**
+ * Calculate creationCode hash for CREATE2 address prediction.
+ */
+const { keccak256, Interface } = require("ethers");
+
+/**
+ * Get codeHash for a contract deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param contractName - contract name (e.g. "Gateway", "AuthorityManager")
+ * @param args - constructor arguments array
+ */
+export async function getCodeHash(artifacts: any, contractName: string, args: any[] = []): Promise<string> {
+    const artifact = await artifacts.readArtifact(contractName);
+    let bytecode = artifact.bytecode;
+    if (!bytecode.startsWith("0x")) bytecode = "0x" + bytecode;
+
+    if (args.length > 0) {
+        const iface = new Interface(artifact.abi);
+        const encoded = iface.encodeDeploy(args);
+        return keccak256(bytecode + encoded.slice(2));
+    }
+
+    return keccak256(bytecode);
+}
+
+/**
+ * Get codeHash for an ERC1967Proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+export async function getProxyCodeHash(
+    artifacts: any,
+    implAddress: string,
+    implName: string,
+    initArgs: any[] = []
+): Promise<string> {
+    return getCustomProxyCodeHash(artifacts, "ERC1967Proxy", implAddress, implName, initArgs);
+}
+
+/**
+ * Get codeHash for a custom proxy deployment.
+ * @param artifacts - hardhat artifacts (hre.artifacts)
+ * @param proxyName - proxy contract name (e.g. "MyCustomProxy")
+ * @param implAddress - implementation address
+ * @param implName - implementation contract name (for encoding initData)
+ * @param initArgs - arguments for initialize() function
+ */
+export async function getCustomProxyCodeHash(
+    artifacts: any,
+    proxyName: string,
+    implAddress: string,
+    implName: string,
+    initArgs: any[] = []
+): Promise<string> {
+    const proxyArtifact = await artifacts.readArtifact(proxyName);
+    let bytecode = proxyArtifact.bytecode;
+    if (!bytecode.startsWith("0x")) bytecode = "0x" + bytecode;
+
+    let initData = "0x";
+    if (initArgs.length > 0) {
+        const implArtifact = await artifacts.readArtifact(implName);
+        const iface = new Interface(implArtifact.abi);
+        initData = iface.encodeFunctionData("initialize", initArgs);
+    }
+
+    const { AbiCoder } = require("ethers");
+    const constructorArgs = AbiCoder.defaultAbiCoder().encode(
+        ["address", "bytes"],
+        [implAddress, initData]
+    );
+
+    return keccak256(bytecode + constructorArgs.slice(2));
+}

package/utils/deployRecord.ts

@@ -0,0 +1,117 @@
+/**
+ * Deploy record — read/write deployed contract addresses from deploy.json
+ *
+ * Structure:
+ *   {
+ *     "prod": { "Mapo": { "Relay": "0x..." }, "Bsc": { "Gateway": "0x..." } },
+ *     "main": { "Mapo": { "Relay": "0x..." } },
+ *     "test": { "Mapo": { "Relay": "0x..." } }
+ *   }
+ */
+let fs = require("fs");
+let path = require("path");
+
+type DeployData = {
+    [env: string]: {
+        [chain: string]: {
+            [key: string]: string;
+        };
+    };
+};
+
+export interface DeploymentPath {
+    env: string;    // "prod", "main", "test"
+    chain: string;  // "Mapo", "Bsc", "Tron"
+}
+
+export interface DeploymentOptions {
+    basePath?: string;  // defaults to <cwd>/deployments/
+    env: string;        // "prod", "main", "test" — required
+}
+
+function defaultDeployPath(): string {
+    return path.join(process.cwd(), "deployments");
+}
+
+/**
+ * Resolve deployment path from network name and env.
+ * @param network - hardhat network name (e.g. "Bsc", "Mapo_test", "Tron")
+ * @param env - deployment environment: "prod", "main", "test"
+ * @returns { env, chain } for deploy.json lookup
+ */
+export function resolveDeploymentPath(network: string, env: string): DeploymentPath {
+    // Strip _test suffix from network name to get chain name
+    const chain = network.replace(/_?test$/i, "");
+    return { env, chain: chain.charAt(0).toUpperCase() + chain.slice(1) };
+}
+
+/**
+ * Read a deployed contract address from deploy.json.
+ * @param network - hardhat network name
+ * @param key - contract key (e.g. "Gateway", "Authority")
+ * @param opts - optional basePath and env overrides
+ */
+export async function getDeploymentByKey(network: string, key: string, opts: DeploymentOptions): Promise<string> {
+    const deployPath = opts.basePath || defaultDeployPath();
+    const { env, chain } = resolveDeploymentPath(network, opts.env);
+    const data = await readDeployFile(deployPath);
+    const addr = data[env]?.[chain]?.[key];
+    if (!addr) throw new Error(`no ${key} deployment in ${env}.${chain}`);
+    return addr;
+}
+
+/**
+ * Check if a contract address exists and is valid in deploy.json.
+ * @param network - hardhat network name
+ * @param key - contract key
+ * @param opts - optional basePath and env overrides
+ */
+export async function hasDeployment(network: string, key: string, opts: DeploymentOptions): Promise<boolean> {
+    try {
+        const deployPath = opts.basePath || defaultDeployPath();
+        const { env, chain } = resolveDeploymentPath(network, opts.env);
+        const data = await readDeployFile(deployPath);
+        const addr = data[env]?.[chain]?.[key];
+        return !!addr && addr.length > 2 && addr !== "0x";
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Save a deployed contract address to deploy.json.
+ * @param network - hardhat network name
+ * @param key - contract key (e.g. "Gateway")
+ * @param addr - deployed address
+ * @param opts - optional basePath and env overrides
+ */
+export async function saveDeployment(network: string, key: string, addr: string, opts: DeploymentOptions): Promise<void> {
+    const deployPath = opts.basePath || defaultDeployPath();
+    const { env, chain } = resolveDeploymentPath(network, opts.env);
+    const data = await readDeployFile(deployPath);
+    if (!data[env]) data[env] = {};
+    if (!data[env][chain]) data[env][chain] = {};
+    data[env][chain][key] = addr;
+    const filePath = path.resolve(deployPath, "deploy.json");
+    await ensureDir(deployPath);
+    await fs.promises.writeFile(filePath, JSON.stringify(data, null, "\t"));
+}
+
+async function readDeployFile(basePath: string): Promise<DeployData> {
+    const filePath = path.resolve(basePath, "deploy.json");
+    try {
+        const rawdata = await fs.promises.readFile(filePath, "utf-8");
+        return JSON.parse(rawdata);
+    } catch {
+        return {};
+    }
+}
+
+async function ensureDir(dirPath: string): Promise<void> {
+    const absPath = path.resolve(dirPath);
+    try {
+        await fs.promises.stat(absPath);
+    } catch {
+        await fs.promises.mkdir(absPath, { recursive: true });
+    }
+}

package/utils/deployer.ts

@@ -0,0 +1,123 @@
+import { isTronNetwork, TronClient } from "./tronHelper";
+import { evmDeploy, evmDeployProxy, evmUpgradeProxy } from "./evmHelper";
+import { verify as _verify } from "./verifier";
+
+/**
+ * Unified deployer — auto-routes to EVM or Tron based on network name.
+ *
+ * Usage in hardhat tasks:
+ *   const deployer = createDeployer(hre, { autoVerify: true });
+ *   let addr = await deployer.deploy("Gateway", [admin], salt);
+ *   let { proxy, implementation } = await deployer.deployProxy("Gateway", [admin], salt);
+ *   let newImpl = await deployer.upgrade("Gateway", proxyAddr);
+ */
+
+export interface DeployerOptions {
+    autoVerify?: boolean;   // auto verify after deploy/upgrade, defaults to false
+}
+
+export interface DeployResult {
+    address: string;       // primary address (0x hex for EVM, base58 for Tron)
+    hex?: string;          // 0x hex (Tron only, EVM same as address)
+}
+
+export interface DeployProxyResult {
+    proxy: string;         // proxy address (0x hex for EVM, base58 for Tron)
+    implementation: string; // impl address
+    proxyHex?: string;     // Tron hex
+    implementationHex?: string; // Tron hex
+}
+
+export interface Deployer {
+    deploy(contractName: string, args?: any[], salt?: string): Promise<DeployResult>;
+    deployProxy(contractName: string, initArgs?: any[], salt?: string): Promise<DeployProxyResult>;
+    upgrade(contractName: string, proxyAddr: string): Promise<DeployResult>;
+    verify(contractName: string, address: string, constructorArgs?: any[], contractPath?: string): Promise<void>;
+    isTron: boolean;
+    network: string;
+}
+
+/**
+ * Create a unified deployer that auto-routes to EVM or Tron based on network.
+ * @param hre - hardhat runtime environment
+ * @param opts - options (autoVerify: auto-verify after deploy, defaults to false)
+ */
+export function createDeployer(hre: any, opts: DeployerOptions = {}): Deployer {
+    const network = hre.network.name;
+    const isTron = isTronNetwork(network);
+    const autoVerify = opts.autoVerify || false;
+
+    async function tryVerify(contractName: string, address: string, constructorArgs?: any[], contractPath?: string) {
+        if (!autoVerify) return;
+        try {
+            await _verify(hre, { contractName, address, constructorArgs, contractPath });
+        } catch (e: any) {
+            console.log(`[warn] auto-verify failed: ${e.message || e}`);
+        }
+    }
+
+    if (isTron) {
+        const client = TronClient.fromHre(hre);
+
+        return {
+            isTron: true,
+            network,
+
+            async deploy(contractName, args = [], salt = "") {
+                let result = await client.deploy(hre.artifacts, contractName, args, salt);
+                await tryVerify(contractName, result.base58, args);
+                return { address: result.base58, hex: result.hex };
+            },
+
+            async deployProxy(contractName, initArgs = [], salt = "") {
+                let result = await client.deployProxy(hre.artifacts, contractName, initArgs, salt);
+                await tryVerify(contractName, result.implementation.base58);
+                return {
+                    proxy: result.proxy.base58,
+                    implementation: result.implementation.base58,
+                    proxyHex: result.proxy.hex,
+                    implementationHex: result.implementation.hex,
+                };
+            },
+
+            async upgrade(contractName, proxyAddr) {
+                let result = await client.upgradeProxy(hre.artifacts, contractName, proxyAddr);
+                await tryVerify(contractName, result.base58);
+                return { address: result.base58, hex: result.hex };
+            },
+
+            async verify(contractName, address, constructorArgs, contractPath) {
+                await _verify(hre, { contractName, address, constructorArgs, contractPath });
+            },
+        };
+    }
+
+    // EVM
+    const { ethers, artifacts } = hre;
+    return {
+        isTron: false,
+        network,
+
+        async deploy(contractName, args = [], salt = "") {
+            let addr = await evmDeploy(ethers, artifacts, contractName, args, salt);
+            await tryVerify(contractName, addr, args);
+            return { address: addr };
+        },
+
+        async deployProxy(contractName, initArgs = [], salt = "") {
+            let result = await evmDeployProxy(ethers, artifacts, contractName, initArgs, salt);
+            await tryVerify(contractName, result.implementation);
+            return { proxy: result.proxy, implementation: result.implementation };
+        },
+
+        async upgrade(contractName, proxyAddr) {
+            let addr = await evmUpgradeProxy(ethers, contractName, proxyAddr);
+            await tryVerify(contractName, addr);
+            return { address: addr };
+        },
+
+        async verify(contractName, address, constructorArgs, contractPath) {
+            await _verify(hre, { contractName, address, constructorArgs, contractPath });
+        },
+    };
+}