ryt-sdk 1.0.0

package/README.md

@@ -0,0 +1,8 @@
+# ryt-sdk
+
+RYT blockchain SDK for provider, wallet, and smart contract interactions.
+
+## Install
+
+```bash
+npm install ryt-sdk

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Configuration options for initializing the RYT SDK
+ */
+export interface SDKConfig {
+    /**
+     * Chain ID of the target blockchain network
+     * @example 1 (Ethereum Mainnet), 137 (Polygon)
+     */
+    chainId: number;
+    /**
+     * List of RPC endpoints used to communicate with the blockchain
+     * The SDK may use fallback logic if multiple URLs are provided
+     * @example ["https://rpc1.example.com", "https://rpc2.example.com"]
+     */
+    rpcUrls: string[];
+    /**
+     * Optional block explorer base URL for the network
+     * Used to generate transaction/address links if provided
+     * @example "https://etherscan.io"
+     */
+    explorer?: string;
+}
+/**
+ * Validates and normalizes SDK configuration
+ *
+ * @param config - User-provided SDK configuration
+ * @returns Validated and normalized configuration
+ *
+ * @throws Error if required fields are missing or invalid
+ *
+ * @example
+ * ```ts
+ * const config = validateConfig({
+ *   chainId: 1234,
+ *   rpcUrls: ["http://localhost:8545"]
+ * });
+ * ```
+ */
+export declare function validateConfig(config: SDKConfig): SDKConfig;

package/dist/config.js

@@ -0,0 +1,37 @@
+/**
+ * Validates and normalizes SDK configuration
+ *
+ * @param config - User-provided SDK configuration
+ * @returns Validated and normalized configuration
+ *
+ * @throws Error if required fields are missing or invalid
+ *
+ * @example
+ * ```ts
+ * const config = validateConfig({
+ *   chainId: 1234,
+ *   rpcUrls: ["http://localhost:8545"]
+ * });
+ * ```
+ */
+export function validateConfig(config) {
+    if (!config) {
+        throw new Error("SDK config is required");
+    }
+    if (typeof config.chainId !== "number" || isNaN(config.chainId)) {
+        throw new Error("Invalid chainId: must be a valid number");
+    }
+    if (!Array.isArray(config.rpcUrls) || config.rpcUrls.length === 0) {
+        throw new Error("rpcUrls must be a non-empty array");
+    }
+    for (const url of config.rpcUrls) {
+        if (typeof url !== "string" || !url.startsWith("http")) {
+            throw new Error(`Invalid RPC URL: ${url}`);
+        }
+    }
+    if (config.explorer !== undefined &&
+        (typeof config.explorer !== "string" || config.explorer.length === 0)) {
+        throw new Error("explorer must be a valid URL string if provided");
+    }
+    return config;
+}

package/dist/contract.d.ts

@@ -0,0 +1,142 @@
+import { ethers } from "ethers";
+import RYTWallet from "./wallet";
+/**
+ * -----------------------------
+ * Library Linking Types
+ * -----------------------------
+ */
+export interface LinkReferences {
+    [file: string]: {
+        [libraryName: string]: Array<{
+            start: number;
+            length: number;
+        }>;
+    };
+}
+/**
+ * Options for standard contract deployment (CREATE)
+ */
+export interface DeployOptions {
+    /** Contract ABI */
+    abi: any[];
+    /** Compiled bytecode */
+    bytecode: string;
+    /** Constructor arguments */
+    args?: any[];
+    /** ETH value to send */
+    value?: bigint | number;
+}
+/**
+ * Options for CREATE2 deployment
+ */
+export interface Create2DeployOptions extends DeployOptions {
+    /** Factory contract address */
+    factoryAddress: string;
+    /** Salt for deterministic address */
+    salt: string;
+}
+/**
+ * Options for UUPS / ERC1967 proxy deployment
+ */
+export interface UUPSDeployOptions {
+    /** Implementation ABI */
+    implementationAbi: any[];
+    /** Implementation bytecode */
+    implementationBytecode: string;
+    /** Initialization calldata */
+    initData?: string;
+}
+/**
+ * Options for library-linked deployment
+ */
+export interface LibraryDeployOptions {
+    /** Contract ABI */
+    abi: any[];
+    /** Contract bytecode */
+    bytecode: string;
+    /** Solidity link references */
+    linkReferences: LinkReferences;
+    /** Library addresses mapping */
+    libraries?: Record<string, string>;
+    /** Constructor arguments */
+    args?: any[];
+}
+/**
+ * ----------------------------------------------------
+ * RYTContract - Core smart contract interaction layer
+ * ----------------------------------------------------
+ *
+ * Supports:
+ * - Read / Write contract calls
+ * - CREATE deployment
+ * - CREATE2 deployment
+ * - Minimal proxy (EIP-1167)
+ * - UUPS / ERC1967 proxy deployment
+ * - Library-linked deployment
+ */
+export default class RYTContract {
+    private wallet;
+    contract: ethers.Contract | null;
+    /**
+     * Create a new contract instance
+     *
+     * @param address - deployed contract address (optional)
+     * @param abi - contract ABI
+     * @param signerOrProvider - wallet or provider instance
+     */
+    constructor(address: string | null, abi: any[], signerOrProvider: RYTWallet | ethers.Provider | any);
+    /**
+     * Call a read-only contract method
+     *
+     * @param method - contract function name
+     * @param params - function arguments
+     * @returns result of contract call
+     */
+    read(method: string, ...params: any[]): Promise<any>;
+    /**
+     * Call a state-changing contract method
+     *
+     * @param method - contract function name
+     * @param params - function arguments
+     * @returns transaction response
+     */
+    write(method: string, ...params: any[]): Promise<any>;
+    /**
+     * Deploy a contract using CREATE opcode
+     *
+     * @param options - deployment options
+     * @returns updated contract instance
+     */
+    deploy(options: DeployOptions): Promise<this>;
+    /**
+     * Deploy contract using CREATE2 factory
+     *
+     * @param options - CREATE2 deployment options
+     * @returns deployed contract address + receipt
+     */
+    deployCreate2(options: Create2DeployOptions): Promise<{
+        receipt: any;
+        contractHash: string;
+    }>;
+    /**
+     * Deploy minimal proxy clone (EIP-1167)
+     *
+     * @param implementationAddress - logic contract address
+     * @returns transaction receipt
+     */
+    deployClone(implementationAddress: string): Promise<ethers.TransactionReceipt | null>;
+    /**
+     * Deploy UUPS proxy contract
+     *
+     * @param options - UUPS deployment options
+     * @returns proxy-wrapped contract instance
+     */
+    deployUUPS(options: UUPSDeployOptions): Promise<RYTContract>;
+    /**
+     * Deploy contract with Solidity libraries linked
+     *
+     * @param options - library deployment options
+     * @returns deployed contract instance
+     */
+    deployWithLibraries(options: LibraryDeployOptions): Promise<this>;
+}

package/dist/contract.js

@@ -0,0 +1,208 @@
+import { ethers } from "ethers";
+import RYTWallet from "./wallet";
+import ERC1967Proxy from "@openzeppelin/contracts/build/contracts/ERC1967Proxy.json";
+/**
+ * -----------------------------
+ * Internal helper: Link libraries into bytecode
+ * -----------------------------
+ *
+ * @param bytecode - raw contract bytecode
+ * @param linkReferences - compiler link references
+ * @param libraries - deployed library addresses
+ * @returns linked bytecode string
+ */
+async function linkLibraries(bytecode, linkReferences, libraries) {
+    let linked = bytecode.startsWith("0x") ? bytecode.slice(2) : bytecode;
+    const patches = [];
+    for (const file of Object.keys(linkReferences)) {
+        for (const libName of Object.keys(linkReferences[file])) {
+            const address = libraries[libName];
+            if (!address) {
+                throw new Error(`Missing address for library ${libName}`);
+            }
+            for (const { start, length } of linkReferences[file][libName]) {
+                patches.push({
+                    start,
+                    length,
+                    address: address.replace(/^0x/, "").toLowerCase(),
+                });
+            }
+        }
+    }
+    patches.sort((a, b) => b.start - a.start);
+    for (const { start, length, address } of patches) {
+        linked =
+            linked.slice(0, start * 2) +
+                address.padStart(length * 2, "0") +
+                linked.slice((start + length) * 2);
+    }
+    return linked;
+}
+/**
+ * ----------------------------------------------------
+ * RYTContract - Core smart contract interaction layer
+ * ----------------------------------------------------
+ *
+ * Supports:
+ * - Read / Write contract calls
+ * - CREATE deployment
+ * - CREATE2 deployment
+ * - Minimal proxy (EIP-1167)
+ * - UUPS / ERC1967 proxy deployment
+ * - Library-linked deployment
+ */
+export default class RYTContract {
+    /**
+     * Create a new contract instance
+     *
+     * @param address - deployed contract address (optional)
+     * @param abi - contract ABI
+     * @param signerOrProvider - wallet or provider instance
+     */
+    constructor(address, abi, signerOrProvider) {
+        this.wallet = signerOrProvider instanceof RYTWallet ? signerOrProvider : null;
+        const provider = signerOrProvider?.getProvider?.() || signerOrProvider;
+        this.contract = address
+            ? new ethers.Contract(address, abi, this.wallet ? this.wallet["wallet"] : provider)
+            : null;
+    }
+    // ----------------------------------------------------
+    // Read & Write
+    // ----------------------------------------------------
+    /**
+     * Call a read-only contract method
+     *
+     * @param method - contract function name
+     * @param params - function arguments
+     * @returns result of contract call
+     */
+    read(method, ...params) {
+        if (!this.contract)
+            throw new Error("Contract not initialized");
+        return this.contract[method](...params);
+    }
+    /**
+     * Call a state-changing contract method
+     *
+     * @param method - contract function name
+     * @param params - function arguments
+     * @returns transaction response
+     */
+    write(method, ...params) {
+        if (!this.contract)
+            throw new Error("Contract not initialized");
+        return this.contract[method](...params);
+    }
+    // ----------------------------------------------------
+    // CREATE Deployment
+    // ----------------------------------------------------
+    /**
+     * Deploy a contract using CREATE opcode
+     *
+     * @param options - deployment options
+     * @returns updated contract instance
+     */
+    async deploy(options) {
+        if (!this.wallet)
+            throw new Error("Wallet required for deploy");
+        const factory = new ethers.ContractFactory(options.abi, options.bytecode, this.wallet["wallet"]);
+        const contract = await factory.deploy(...(options.args ?? []), {
+            value: options.value ?? 0,
+        });
+        await contract.waitForDeployment();
+        this.contract = contract;
+        return this;
+    }
+    // ----------------------------------------------------
+    // CREATE2 Deployment
+    // ----------------------------------------------------
+    /**
+     * Deploy contract using CREATE2 factory
+     *
+     * @param options - CREATE2 deployment options
+     * @returns deployed contract address + receipt
+     */
+    async deployCreate2(options) {
+        if (!this.wallet)
+            throw new Error("Wallet required for deployCreate2");
+        const encodedArgs = options.args && options.args.length > 0
+            ? new ethers.Interface(options.abi).encodeDeploy(options.args)
+            : "0x";
+        const creationCode = ethers.concat([
+            "0x" + options.bytecode,
+            encodedArgs,
+        ]);
+        const factory = new ethers.Contract(options.factoryAddress, [
+            "function deploy(bytes32 salt, bytes code) external payable returns (address)",
+        ], this.wallet["wallet"]);
+        const addr = ethers.getCreate2Address(options.factoryAddress, options.salt, ethers.keccak256(creationCode));
+        const tx = options.value && options.value > 0
+            ? await factory.deploy(options.salt, creationCode, {
+                value: options.value,
+            })
+            : await factory.deploy(options.salt, creationCode);
+        return {
+            receipt: await tx.wait(),
+            contractHash: addr,
+        };
+    }
+    // ----------------------------------------------------
+    // Minimal Proxy (EIP-1167)
+    // ----------------------------------------------------
+    /**
+     * Deploy minimal proxy clone (EIP-1167)
+     *
+     * @param implementationAddress - logic contract address
+     * @returns transaction receipt
+     */
+    async deployClone(implementationAddress) {
+        if (!this.wallet)
+            throw new Error("Wallet required for deployClone");
+        const bytecode = "0x3d602d80600a3d3981f3" +
+            "363d3d373d3d3d363d73" +
+            implementationAddress.slice(2) +
+            "5af43d82803e903d91602b57fd5bf3";
+        const tx = await this.wallet["wallet"].sendTransaction({
+            data: bytecode,
+        });
+        return await tx.wait();
+    }
+    // ----------------------------------------------------
+    // UUPS / ERC1967 Proxy
+    // ----------------------------------------------------
+    /**
+     * Deploy UUPS proxy contract
+     *
+     * @param options - UUPS deployment options
+     * @returns proxy-wrapped contract instance
+     */
+    async deployUUPS(options) {
+        if (!this.wallet)
+            throw new Error("Wallet required for deployUUPS");
+        const implFactory = new ethers.ContractFactory(options.implementationAbi, options.implementationBytecode, this.wallet["wallet"]);
+        const impl = await implFactory.deploy();
+        await impl.waitForDeployment();
+        const implAddress = impl.target;
+        const proxyFactory = new ethers.ContractFactory(ERC1967Proxy.abi, ERC1967Proxy.bytecode, this.wallet["wallet"]);
+        const proxy = await proxyFactory.deploy(implAddress, options.initData ?? "0x");
+        await proxy.waitForDeployment();
+        return new RYTContract(proxy.target, options.implementationAbi, this.wallet);
+    }
+    // ----------------------------------------------------
+    // Library-linked deployment
+    // ----------------------------------------------------
+    /**
+     * Deploy contract with Solidity libraries linked
+     *
+     * @param options - library deployment options
+     * @returns deployed contract instance
+     */
+    async deployWithLibraries(options) {
+        const linkedBytecode = await linkLibraries(options.bytecode, options.linkReferences, options.libraries ?? {});
+        return this.deploy({
+            abi: options.abi,
+            bytecode: linkedBytecode,
+            args: options.args ?? [],
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ------------------------------------------------------
+ * RYT SDK - Public Entry Point
+ * ------------------------------------------------------
+ *
+ * This file exposes the main SDK modules:
+ * - Provider (RPC layer)
+ * - Wallet (signing layer)
+ * - Contract (smart contract interaction layer)
+ *
+ * This is the ONLY file users should import from:
+ *
+ * @example
+ * ```ts
+ * import { RYTProvider, RYTWallet, RYTContract } from "ryt-sdk";
+ * ```
+ */
+/**
+ * Provider module for RPC interactions
+ */
+export { default as RYTProvider } from "./provider";
+/**
+ * Wallet module for signing transactions
+ */
+export { default as RYTWallet } from "./wallet";
+/**
+ * Contract module for smart contract interactions
+ */
+export { default as RYTContract } from "./contract";
+/**
+ * ------------------------------------------------------
+ * Optional: Future unified SDK export (recommended)
+ * ------------------------------------------------------
+ *
+ * Uncomment when you want a single entry API:
+ *
+ * export { default as RYTClient } from "./client";
+ */ 

package/dist/index.js

@@ -0,0 +1,38 @@
+/**
+ * ------------------------------------------------------
+ * RYT SDK - Public Entry Point
+ * ------------------------------------------------------
+ *
+ * This file exposes the main SDK modules:
+ * - Provider (RPC layer)
+ * - Wallet (signing layer)
+ * - Contract (smart contract interaction layer)
+ *
+ * This is the ONLY file users should import from:
+ *
+ * @example
+ * ```ts
+ * import { RYTProvider, RYTWallet, RYTContract } from "ryt-sdk";
+ * ```
+ */
+/**
+ * Provider module for RPC interactions
+ */
+export { default as RYTProvider } from "./provider";
+/**
+ * Wallet module for signing transactions
+ */
+export { default as RYTWallet } from "./wallet";
+/**
+ * Contract module for smart contract interactions
+ */
+export { default as RYTContract } from "./contract";
+/**
+ * ------------------------------------------------------
+ * Optional: Future unified SDK export (recommended)
+ * ------------------------------------------------------
+ *
+ * Uncomment when you want a single entry API:
+ *
+ * export { default as RYTClient } from "./client";
+ */ 

package/dist/provider.d.ts

@@ -0,0 +1,49 @@
+import { ethers } from "ethers";
+import type { SDKConfig } from "./config";
+/**
+ * RYTProvider is a provider instance that connects to the blockchain and allows interaction with it.
+ */
+export default class RYTProvider {
+    private provider;
+    /**
+     * Create a new RYTProvider instance
+     *
+     * @param config - SDK configuration containing RPC URLs
+     * @param rpcUrl - Optional override RPC URL. If not provided, uses first config RPC URL
+     *
+     * @example
+     * ```ts
+     * const provider = new RYTProvider(config);
+     * ```
+     */
+    constructor(config: SDKConfig, rpcUrl?: string);
+    /**
+     * Returns the provider instance
+     *
+     * @returns provider instance
+     */
+    getProvider(): ethers.JsonRpcProvider;
+    /**
+     * Get the latest block number from the blockchain
+     *
+     * @returns Promise resolving to latest block number
+     *
+     * @example
+     * ```ts
+     * const blockNumber = await provider.getBlockNumber();
+     * ```
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Get balance of a given address in wei
+     *
+     * @param address - Ethereum-style wallet address
+     * @returns Promise resolving to balance in wei (BigInt-compatible)
+     *
+     * @example
+     * ```ts
+     * const balance = await provider.getBalance("0x123...");
+     * ```
+     */
+    getBalance(address: string): Promise<bigint>;
+}

package/dist/provider.js

@@ -0,0 +1,62 @@
+import { ethers } from "ethers";
+/**
+ * RYTProvider is a provider instance that connects to the blockchain and allows interaction with it.
+ */
+export default class RYTProvider {
+    /**
+     * Create a new RYTProvider instance
+     *
+     * @param config - SDK configuration containing RPC URLs
+     * @param rpcUrl - Optional override RPC URL. If not provided, uses first config RPC URL
+     *
+     * @example
+     * ```ts
+     * const provider = new RYTProvider(config);
+     * ```
+     */
+    constructor(config, rpcUrl) {
+        const rpc = rpcUrl ?? config.rpcUrls[0];
+        if (!rpc) {
+            throw new Error("No RPC URL provided in config or constructor");
+        }
+        this.provider = new ethers.JsonRpcProvider(rpc);
+    }
+    /**
+     * Returns the provider instance
+     *
+     * @returns provider instance
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Get the latest block number from the blockchain
+     *
+     * @returns Promise resolving to latest block number
+     *
+     * @example
+     * ```ts
+     * const blockNumber = await provider.getBlockNumber();
+     * ```
+     */
+    async getBlockNumber() {
+        return await this.provider.getBlockNumber();
+    }
+    /**
+     * Get balance of a given address in wei
+     *
+     * @param address - Ethereum-style wallet address
+     * @returns Promise resolving to balance in wei (BigInt-compatible)
+     *
+     * @example
+     * ```ts
+     * const balance = await provider.getBalance("0x123...");
+     * ```
+     */
+    async getBalance(address) {
+        if (!ethers.isAddress(address)) {
+            throw new Error(`Invalid address: ${address}`);
+        }
+        return await this.provider.getBalance(address);
+    }
+}

package/dist/wallet.d.ts

@@ -0,0 +1,63 @@
+import { ethers } from "ethers";
+import type RYTProvider from "./provider";
+/**
+ * Transaction request type
+ */
+export type TxRequest = ethers.TransactionRequest;
+/**
+ * RYTWallet is a wallet instance that supports signing transactions and interacting with the blockchain.
+ */
+export default class RYTWallet {
+    private wallet;
+    /**
+     * Create a new RYTWallet instance
+     *
+     * @param privateKey - Ethereum private key (0x...)
+     * @param provider - Optional RYTProvider instance for network access
+     *
+     * @example
+     * ```ts
+     * const wallet = new RYTWallet(PRIVATE_KEY, provider);
+     * ```
+     */
+    constructor(privateKey: string, provider?: RYTProvider);
+    /**
+     * Returns the wallet address
+     *
+     * @returns Wallet public address
+     *
+     * @example
+     * ```ts
+     * const address = wallet.getAddress();
+     * ```
+     */
+    getAddress(): string;
+    /**
+     * Get wallet balance in wei
+     *
+     * @returns Promise resolving to balance (bigint)
+     *
+     * @throws Error if provider is not connected
+     *
+     * @example
+     * ```ts
+     * const balance = await wallet.getBalance();
+     * ```
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Send a signed transaction
+     *
+     * @param tx - Transaction object (to, value, data, etc.)
+     * @returns Promise resolving to transaction response
+     *
+     * @example
+     * ```ts
+     * await wallet.sendTransaction({
+     *   to: "0xabc...",
+     *   value: ethers.parseEther("0.01")
+     * });
+     * ```
+     */
+    sendTransaction(tx: TxRequest): Promise<ethers.TransactionResponse>;
+}

package/dist/wallet.js

@@ -0,0 +1,81 @@
+import { ethers } from "ethers";
+/**
+ * RYTWallet is a wallet instance that supports signing transactions and interacting with the blockchain.
+ */
+export default class RYTWallet {
+    /**
+     * Create a new RYTWallet instance
+     *
+     * @param privateKey - Ethereum private key (0x...)
+     * @param provider - Optional RYTProvider instance for network access
+     *
+     * @example
+     * ```ts
+     * const wallet = new RYTWallet(PRIVATE_KEY, provider);
+     * ```
+     */
+    constructor(privateKey, provider) {
+        if (!privateKey) {
+            throw new Error("Private key is required");
+        }
+        // Ensure private key format is valid
+        if (!privateKey.startsWith("0x")) {
+            throw new Error("Invalid private key format: must start with 0x");
+        }
+        const ethersProvider = provider?.getProvider();
+        this.wallet = ethersProvider
+            ? new ethers.Wallet(privateKey, ethersProvider)
+            : new ethers.Wallet(privateKey);
+    }
+    /**
+     * Returns the wallet address
+     *
+     * @returns Wallet public address
+     *
+     * @example
+     * ```ts
+     * const address = wallet.getAddress();
+     * ```
+     */
+    getAddress() {
+        return this.wallet.address;
+    }
+    /**
+     * Get wallet balance in wei
+     *
+     * @returns Promise resolving to balance (bigint)
+     *
+     * @throws Error if provider is not connected
+     *
+     * @example
+     * ```ts
+     * const balance = await wallet.getBalance();
+     * ```
+     */
+    async getBalance() {
+        if (!this.wallet.provider) {
+            throw new Error("Provider not initialized. Attach a provider to fetch balance.");
+        }
+        return await this.wallet.provider.getBalance(this.wallet.address);
+    }
+    /**
+     * Send a signed transaction
+     *
+     * @param tx - Transaction object (to, value, data, etc.)
+     * @returns Promise resolving to transaction response
+     *
+     * @example
+     * ```ts
+     * await wallet.sendTransaction({
+     *   to: "0xabc...",
+     *   value: ethers.parseEther("0.01")
+     * });
+     * ```
+     */
+    async sendTransaction(tx) {
+        if (!this.wallet) {
+            throw new Error("Wallet not initialized");
+        }
+        return await this.wallet.sendTransaction(tx);
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "ryt-sdk",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "RYT blockchain SDK for provider, wallet, and smart contract interactions",
+  "author": "Muhammad Hammad Mubeen",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "tsx tests/sdk.test.ts",
+    "contractsTest": "tsx tests/sdk.contracts.test.ts"
+  },
+  "keywords": [
+    "blockchain",
+    "sdk",
+    "ryt",
+    "ethereum",
+    "web3",
+    "ethers-v6",
+    "smart-contracts",
+    "create2",
+    "uups",
+    "erc20",
+    "erc721"
+  ],
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "ethers": "^6.8.0"
+  },
+  "devDependencies": {
+    "@openzeppelin/contracts": "^5.4.0",
+    "@openzeppelin/contracts-upgradeable": "^5.4.0",
+    "@types/node": "^20.0.0",
+    "eslint": "^8.0.0",
+    "prettier": "^2.8.0",
+    "rimraf": "^6.0.0",
+    "ts-node": "^10.9.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}