package-installer-cli 2.3.0 → 2.4.0

data/bundle-standalone/templates/web3/anchor/template/programs/mysolanaapp/src/lib.rs

@@ -0,0 +1,40 @@
+use anchor_lang::prelude::*;
+
+declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");
+
+#[program]
+pub mod mysolanaapp {
+    use super::*;
+
+    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
+        let account = &mut ctx.accounts.base_account;
+        account.data = 42;
+        Ok(())
+    }
+
+    pub fn update(ctx: Context<Update>, data: u64) -> Result<()> {
+        let account = &mut ctx.accounts.base_account;
+        account.data = data;
+        Ok(())
+    }
+}
+
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+    #[account(init, payer = user, space = 8 + 8)]
+    pub base_account: Account<'info, BaseAccount>,
+    #[account(mut)]
+    pub user: Signer<'info>,
+    pub system_program: Program<'info, System>,
+}
+
+#[derive(Accounts)]
+pub struct Update<'info> {
+    #[account(mut)]
+    pub base_account: Account<'info, BaseAccount>,
+}
+
+#[account]
+pub struct BaseAccount {
+    pub data: u64,
+}

data/bundle-standalone/templates/web3/anchor/template/tests/mysolanaapp.ts

@@ -0,0 +1,26 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Mysolanaapp } from "../target/types/mysolanaapp";
+import assert from "assert";
+
+describe("mysolanaapp", () => {
+  const provider = anchor.AnchorProvider.env();
+  anchor.setProvider(provider);
+
+  const program = anchor.workspace.Mysolanaapp as Program<Mysolanaapp>;
+  const baseAccount = anchor.web3.Keypair.generate();
+
+  it("Initialize the account!", async () => {
+    await program.methods.initialize()
+      .accounts({
+        baseAccount: baseAccount.publicKey,
+        user: provider.wallet.publicKey,
+        systemProgram: anchor.web3.SystemProgram.programId,
+      })
+      .signers([baseAccount])
+      .rpc();
+
+    const account = await program.account.baseAccount.fetch(baseAccount.publicKey);
+    assert.ok(account.data.eq(new anchor.BN(42)));
+  });
+});

data/bundle-standalone/templates/web3/ethersjs/template/README.md

@@ -0,0 +1,12 @@
+# Ethers.js + Solidity Template
+
+This template includes:
+- A basic Solidity contract (SimpleStorage)
+- Deployment and interaction scripts using Ethers.js
+
+## Setup
+```bash
+npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox ethers
+npx hardhat compile
+node scripts/deploy.js
+node scripts/interact.js

data/bundle-standalone/templates/web3/ethersjs/template/contracts/SimpleStorage.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract SimpleStorage {
+    uint256 private data;
+
+    event DataUpdated(uint256 newValue);
+
+    function set(uint256 _data) public {
+        data = _data;
+        emit DataUpdated(_data);
+    }
+
+    function get() public view returns (uint256) {
+        return data;
+    }
+}

data/bundle-standalone/templates/web3/ethersjs/template/hardhat.config.js

@@ -0,0 +1,8 @@
+import "@nomicfoundation/hardhat-toolbox";
+
+export default {
+  solidity: "0.8.20",
+  networks: {
+    hardhat: {},
+  },
+};

data/bundle-standalone/templates/web3/ethersjs/template/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ethersjs-web3-template",
+  "version": "1.0.0",
+  "description": "A simple template for Web3 projects using Ethers.js",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js",
+    "test": "echo \"No test specified\" && exit 0"
+  },
+  "keywords": [
+    "web3",
+    "ethers",
+    "ethereum",
+    "smart-contract",
+    "blockchain",
+    "template"
+  ],
+  "author": "Sharique Chaudhary",
+  "license": "MIT",
+  "dependencies": {
+    "ethers": "^6.13.0",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.0"
+  }
+}

data/bundle-standalone/templates/web3/ethersjs/template/scripts/deploy.ts

@@ -0,0 +1,18 @@
+import { ethers } from "ethers";
+import fs from "fs";
+import path from "path";
+
+const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
+const wallet = new ethers.Wallet("YOUR_PRIVATE_KEY_HERE", provider);
+
+const contractPath = path.resolve("artifacts/contracts/SimpleStorage.sol/SimpleStorage.json");
+const contractJSON = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+
+async function main() {
+  const factory = new ethers.ContractFactory(contractJSON.abi, contractJSON.bytecode, wallet);
+  const contract = await factory.deploy();
+  await contract.waitForDeployment();
+  console.log("Contract deployed to:", contract.target);
+}
+
+main().catch(console.error);

data/bundle-standalone/templates/web3/ethersjs/template/scripts/interact.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+
+const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
+const contractAddress = "DEPLOYED_CONTRACT_ADDRESS";
+const abi = [
+  "function set(uint256 _data) public",
+  "function get() public view returns (uint256)"
+];
+
+const contract = new ethers.Contract(contractAddress, abi, provider);
+
+async function readData() {
+  const value = await contract.get();
+  console.log("Stored value:", value.toString());
+}
+
+readData();

data/bundle-standalone/templates/web3/solidity/solidity-learning/01_data-types/DataTypes.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+
+contract DataTypes {
+    // Boolean
+    bool public isTrue = true;
+
+    // Integer
+    int public myInt = -42;  // int8 to int256
+    uint public myUint = 42; // uint8 to uint256
+
+    // Address
+    // this is my metamask ethereum public key
+    // you can me some ethereum 
+    address public myAddress = 0x42B603B561606Af0FeE2eE10316bEA96722a060d;  
+
+    // Bytes
+    bytes1 public myBytes1 = 0x12;
+    bytes32 public myBytes32 = 0x1234567890123456789012345678901234567890123456789012345678901234;
+
+    // String
+    string public myString = "Hello, Solidity!";
+
+    // Array
+    uint[] public myArray = [1, 2, 3, 4, 5];
+
+    // Struct
+    struct Person {
+        string name;
+        uint age;
+    }
+    Person public person = Person("Alice", 30);
+
+    // Enum
+    enum Status { Pending, Active, Inactive }
+    Status public status = Status.Active;
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/01_data-types/SolidityOperations.sol

@@ -0,0 +1,48 @@
+pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+
+contract Operations {
+    // Arithmetic Operations
+    uint256 public variable_add = 70;
+    uint256 public variable_sub = 50;
+    uint256 public variable_mul = 25;
+    uint256 public variable_div = 80;
+    uint256 public variable_mod = 68;
+
+    function getResults() public {
+        variable_add += 25;
+        variable_sub -= 30;
+        variable_mul *= 25;
+        variable_div /= 5;
+        variable_mod %= 60;
+        return;
+    }
+
+    uint256 public a = 10;
+    uint256 public b = 90;
+    // Comparison Operations
+    function isEqual(uint256 x, uint256 y) public pure returns (bool) {
+        return x == y;
+    }
+
+    function isGreater(uint256 x, uint256 y) public pure returns (bool) {
+        return x > y;
+    }
+
+    function isLess(uint256 x, uint256 y) public pure returns (bool) {
+        return x < y;
+    }
+
+    // Logical Operations
+    function and(bool x, bool y) public pure returns (bool) {
+        return x && y;
+    }
+
+    function or(bool x, bool y) public pure returns (bool) {
+        return x || y;
+    }
+
+    function not(bool x) public pure returns (bool) {
+        return !x;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/02_contructors/Constructor.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+
+contract Constructor {
+    uint256 public x;
+    uint256 public y;
+    address public owner;
+    uint256 public createdAt;
+
+    constructor(uint256 _x, uint256 _y) {
+        x = _x;
+        y = _y;
+        owner = msg.sender;
+        createdAt = block.timestamp;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/03_variables/Variables.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/variables-in-solidity-smart-contracts/
+
+pragma solidity ^0.8.0;
+
+contract SampleContract {
+    //state variable of data type unint declared called "storedData"
+    //Data in this variable will be saved to the block chain
+    uint256 public storedData;
+
+    function getResult() public pure returns (uint256) {
+        //local variable
+        uint256 a = 7;
+        //local variable
+        uint256 b = 3;
+        uint256 result = a + b;
+        //access the local variable
+        return result;
+    }
+
+    function getSenderOfTransaction() public view returns (address) {
+        //access global variables
+        return msg.sender;
+    }
+
+    function getChainId() public view returns (uint256) {
+        //access global variables
+        return block.chainid;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/04_functions/Functions.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/functions
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    string private name;
+
+    //Functions that create transaction on block chain
+    function setName(string memory newName) public {
+        name = newName;
+    }
+
+    //Functions that do not create transaction on block chain (view and pure)
+    function getName() public view returns (string memory) {
+        return name;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/05_visibility/FunctionVisibility.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/visibility
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    // Private – A private function/state variable is only available inside the contract that defines it. It is generally good practice to keep functions private.
+    // Internal – A internal function/state variable is only available inside the contract that defines it AND any contracts that inherit it
+    // External – An external function can only be called by external contacts.  Not visible inside the contract that defines it.
+    // Public – A public function/state variable is available to any contract or third party that wants to call it. Public is the default if visibility is not specified.
+
+    // private state variable
+    string private name;
+    uint256 internal age = 35;
+    string public id = "123";
+
+    // public function
+    function setName(string memory newName) public {
+        name = newName;
+    }
+
+    // public function
+    function getName() public view returns (string memory) {
+        return name;
+    }
+
+    function getAge() public view returns (uint256) {
+        return privateFunction();
+    }
+
+    function privateFunction() private view returns (uint256) {
+        return age;
+    }
+
+    function externalFunction() external pure returns (string memory) {
+        return "external-function";
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/06_pure_and_view_functions/PureAndViewFunction.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/pure-and-view
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    string private name = "John Doe";
+
+    // View functions are read only functions and do not modify the state of the block chain. In other words if you want to read data from the block chain one can use view.
+    function getName() public view returns (string memory) {
+        return name;
+    }
+
+    // Pure functions are more restrictive then view functions and do not modify the state AND do not read the state of the block chain.
+    function sum(int256 a, int256 b) public pure returns (int256) {
+        return a + b;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/07_function_modifiers/Modifiers.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/function-modifiers
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    address public owner;
+    string private name;
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    function setName(string memory newName) public onlyOwner {
+        name = newName;
+    }
+
+    function getName() public view returns (string memory) {
+        return name;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/09_events/Events.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/events
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    string private name;
+
+
+    // event declaration
+    event nameEvent(string newName);
+
+    function setName(string memory newName) public {
+        name = newName;
+        // event emit
+        emit nameEvent(newName);
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/10_error_handling/ErrorHandling.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/error-handling
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    // Assert – is used to check for conditions that should never be possible.  Asserts should always evaluate to true and should never fail.  If it does fail then there is a bug in the code and the assert will use up all gas and the transaction will be rolled back.
+    // Require – Is used to evaluate inputs, preconditions and outputs of functions.  If not true solidity with throw an error and fail.  The require statement will accept an optional error message.  If there is a failure it will NOT use up all gas.
+    // Revert – Is similar to require but only takes one argument which is the error message.  Revert might be better to use when the condition to check is complex.
+    uint256 public balance;
+
+    function deposit(uint256 amount) public {
+        uint256 oldBalance = balance;
+        uint256 newBalance = balance + amount;
+        require(newBalance >= oldBalance, "Overflow");
+
+        balance += amount;
+        assert(balance >= amount);
+
+        if (balance < amount) {
+            revert("underflow");
+        }
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/11_fallback_function/Fallback.sol

@@ -0,0 +1,7 @@
+pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+
+contract FallbackFunctions {
+    fallback() external payable {}   
+    
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/12_for_loop/ForLoop.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/for-loop
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    uint256 public loopCount;
+
+    function doLoop(uint256 n) public {
+        for (uint256 i = 0; i < n; i++) {
+            loopCount += 1;
+        }
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/13_array/Array.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/array
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    uint256[] public myArray; //this is a dynamic array of type uint
+    uint256[] public myArray2 = [1, 2, 3, 4]; //this is a dynamic array with 1, 2 and 3 as default values
+    uint256[10] public myFixedSizeArray; //this is a fixed size array of type uint
+
+    uint256[] intergerArray; //sample array of integers
+    bool[] boolArray; //sample array of booleans
+    address[] addressArray; //sample array of address
+
+    function pushIsToAdd(uint256 i) public {
+        myArray.push(i);
+    }
+
+    function getItemInArray(uint256 index) public view returns (uint256) {
+        return myArray[index];
+    }
+
+    function updateTheArray(uint256 locationInArray, uint256 valueToChange) public {
+        myArray[locationInArray] = valueToChange;
+    }
+
+    function remove(uint256 index) public {
+        delete myArray[index];
+    }
+
+    function removeAndCompact(uint256 index) public {
+        myArray[index] = myArray[myArray.length - 1];
+        myArray.pop();
+    }
+
+    function getLength() public view returns (uint256) {
+        return myArray.length;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/14_mapping/Mapping.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/how-to-create-a-map-in-a-solidity-smart-contract/
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    mapping(address => bool) public myMap; // mapping syntax
+
+    function set(address _addr, bool i) public {
+        myMap[_addr] = i;
+    }
+
+    function get(address _addr) public view returns (bool) {
+        return myMap[_addr];
+    }
+
+    function remove(address _addr) public {
+        delete myMap[_addr];
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/14_mapping/NestedMapping.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/how-to-create-a-map-in-a-solidity-smart-contract/
+
+pragma solidity ^0.8.0;
+
+contract NestedMapsContract {
+    mapping(address => mapping(address => uint256)) public allowance; // nested mapping syntax
+
+    function get(address _addressOwner, address _addressSpender) public view returns (uint256) {
+        return allowance[_addressOwner][_addressSpender];
+    }
+
+    function set(
+        address _addressOwner,
+        address _addressSpender,
+        uint256 amount
+    ) public {
+        allowance[_addressOwner][_addressSpender] = amount;
+    }
+
+    function remove(address _addressOwner, address _addressSpender) public {
+        delete allowance[_addressOwner][_addressSpender];
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/15_enum/Enum.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/enum
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    enum Status {
+        Pending,
+        Shipped,
+        Accepted,
+        Rejected,
+        Canceled
+    }
+
+    Status public status;
+
+    function ship() public {
+        require(status == Status.Pending);
+        status = Status.Shipped;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/16_struct/Struct.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/struct
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    struct Todo {
+        string text;
+        bool completed;
+    }
+
+    Todo[] public todos;
+
+    function create(string memory _text) public {
+        todos.push(Todo(_text, false));
+    }
+
+    function get(uint256 _index) public view returns (string memory, bool) {
+        Todo storage todo = todos[_index];
+        return (todo.text, todo.completed);
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/17_payable_modifier/Payable.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/payable-functions
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    address payable public owner;
+
+    constructor() payable {
+        owner = payable(msg.sender);
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    function withdraw(uint256 amount) public onlyOwner {
+        owner.transfer(amount);
+    }
+
+    function transfer(address payable _to, uint256 amount) public onlyOwner {
+        _to.transfer(amount);
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/18_imports/Contract1.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/importing-into-a-contract
+
+pragma solidity ^0.8.0;
+
+import "./Contract2.sol";
+
+contract MyContract {
+    Contract2 public contract2 = new Contract2();
+
+    function callOtherContract(uint256 a, uint256 b) public view returns (uint256) {
+        return contract2.sum(a, b);
+    }
+}