🔵 Spectral

Spectral is a machine intelligence network empowering users to build onchain AI agents and engage with an onchain agent economy

Raised: $29.82M from Polychain Capital, Circle, Galaxy, Samsung and others

Cost (1 contract): ~$0.27

• We published a thread on how to deploy a contract here

🔵 Merkly

Merkly is a multifunctional omnichain platform, designed to simplify bridging via pioneering interoperability technology

Cost (1 contract): ~$0.01

🔗 Deploy your contract here

🔵 Owlto

Owlto Finance is an intent-centric cross-chain bridging protocol

Raised: $8M from Bixin Ventures, and others.

Valuation: $150M

🔗 Deploy your contract here

🔵 Thirdweb

**Thirdweb **is a full-stack, open-source web3 development platform

Raised: $29M from Coinbase Ventures, and others

🔗 Deploy your contract here

🔵 Remix

Remix is a rich toolset that can be used for the entire journey of contract development by users of any knowledge level, and as a learning lab for teaching and experimenting with Ethereum

This option is more difficult to deploy, but at the same time, such contracts are unique and have more functions

🔗 Deploy your contract here

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Coinbase raised $574.2M from a16z, Polychain Capital, and others

What to do:

• Add the testnet network to your wallet

• Request test tokens from the faucet

• Go to Remix and create a new workspace

• Visit the “Solidity Compiler” tab

• Select version 0.8.0 and click “Auto Compile”

• Open the “Deploy Transactions” tab

• Select MetaMask as Environment

• Create a new file and paste this code:

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

contract BasicMath {
function adder(uint _a, uint _b) external pure returns (uint sum, bool error) {
unchecked {
uint result = _a + _b;
if (result >= _a && result >= _b) {
return (result, false);
} else {
return (0, true);
}
}
}

function subtractor(uint _a, uint _b) external pure returns (uint difference, bool error) {
unchecked {
if (_b <= _a) {
return (_a - _b, false);
} else {
return (0, true);
}
}
}
}

• Deploy the contract and verify the transaction here

• Create a new file again and paste this code:

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

contract ControlStructures {
error AfterHours(uint256 time);
error AtLunch();

function fizzBuzz(uint256 _number) public pure returns (string memory response) {
if (_number % 3 == 0 && _number % 5 == 0) {
return "FizzBuzz";
} else if (_number % 3 == 0) {
return "Fizz";
} else if (_number % 5 == 0) {
return "Buzz";
} else {
return "Splat";
}
}

function doNotDisturb(uint256 _time) public pure returns (string memory result) {
assert(_time < 2400);

if (_time > 2200 || _time < 800) {
revert AfterHours(_time);
} else if (_time >= 1200 && _time <= 1299) {
revert("At lunch!");
} else if (_time >= 800 && _time <= 1199) {
return "Morning!";
} else if (_time >= 1300 && _time <= 1799) {
return "Afternoon!";
} else if (_time >= 1800 && _time <= 2200) {
return "Evening!";
}
}
}

• Deploy the contract and verify the transaction here

• Do the same with the following codes

• Code (3):

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

contract EmployeeStorage {
uint16 private shares;
uint32 private salary;
uint256 public idNumber;
string public name;

constructor(uint16 _shares, string memory _name, uint32 _salary, uint _idNumber) {
shares = _shares;
name = _name;
salary = _salary;
idNumber = _idNumber;
}

function viewShares() public view returns (uint16) {
return shares;
}

function viewSalary() public view returns (uint32) {
return salary;
}

error TooManyShares(uint16 _shares);
function grantShares(uint16 _newShares) public {
if (_newShares > 5000) {
revert("Too many shares");
} else if (shares + _newShares > 5000) {
revert TooManyShares(shares + _newShares);
}
shares += _newShares;
}

/**
* Do not modify this function. It is used to enable the unit test for this pin
* to check whether or not you have configured your storage variables to make
* use of packing.
*
* If you wish to cheat, simply modify this function to always return `0`
* I'm not your boss ¯\_(ツ)_/¯
*
* Fair warning though, if you do cheat, it will be on the blockchain having been
* deployed by you wallet....FOREVER!
*/
function checkForPacking(uint _slot) public view returns (uint r) {
assembly {
r := sload (_slot)
}
}

/**
* Warning: Anyone can use this function at any time!
*/
function debugResetShares() public {
shares = 1000;
}
}

• Verify

• Code (4):

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

contract ArraysExercise {
uint[] numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
uint[] timestamps;
address[] senders;

uint256 constant Y2K = 946702800;

function getNumbers() external view returns (uint[] memory) {
uint[] memory results = new uintUnsupported embed;

for(uint i=0; i<numbers.length; i++) {
results[i] = numbers[i];
}

return results;
}

function resetNumbers() public {
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
}

function appendToNumbers(uint[] calldata _toAppend) public {
uint _counter = _toAppend.length;
for (uint i; i < _counter; i++) {
numbers.push(_toAppend[i]);
}
}

function saveTimestamp(uint _unixTimestamp) public {
timestamps.push(_unixTimestamp);
senders.push(msg.sender);
}

function afterY2K() public view returns (uint256[] memory, address[] memory) {

uint256 counter = 0;

for (uint i = 0; i < timestamps.length; i++) {
if (timestamps[i] > Y2K) {
counter++;
}
}

uint256[] memory timestampsAfterY2K = new uint256Unsupported embed;
address[] memory sendersAfterY2K = new addressUnsupported embed;

uint256 index = 0;

for (uint i = 0; i < timestamps.length; i++) {
if (timestamps[i] > Y2K) {
timestampsAfterY2K[index] = timestamps[i];
sendersAfterY2K[index] = senders[i];
index++;
}
}

return (timestampsAfterY2K, sendersAfterY2K);
}

function resetSenders() public {
delete senders;
}

function resetTimestamps() public {
delete timestamps;
}
}

• Verify

• Code (5):

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

/**
* @title FavoriteRecords
* @dev Contract to manage a list of approved music records and allow users to add them to their favorites
*/
contract FavoriteRecords {

mapping(string => bool) private approvedRecords;
string[] private approvedRecordsIndex;

mapping(address => mapping(string => bool)) public userFavorites;
mapping(address => string[]) private userFavoritesIndex;

error NotApproved(string albumName);

/**
* @dev Constructor that initializes the approved records list
*/
constructor() {
approvedRecordsIndex = ["Thriller","Back in Black","The Bodyguard","The Dark Side of the Moon","Their Greatest Hits (1971-1975)","Hotel California","Come On Over","Rumours","Saturday Night Fever"];
for (uint i = 0; i < approvedRecordsIndex.length; i++)
{
approvedRecords[approvedRecordsIndex[i]] = true;
}
}

/**
* @dev Returns the list of approved records
* @return An array of approved record names
*/
function getApprovedRecords() public view returns (string[] memory) {
return approvedRecordsIndex;
}

/**
* @dev Adds an approved record to the user's favorites
* @param _albumName The name of the album to be added
*/
function addRecord(string memory _albumName) public {
if (!approvedRecords[_albumName]) {
revert NotApproved({albumName: _albumName});
}
if (!userFavorites[msg.sender][_albumName]) {
userFavorites[msg.sender][_albumName] = true;
userFavoritesIndex[msg.sender].push(_albumName);
}
}

/**
* @dev Returns the list of a user's favorite records
* @param _address The address of the user
* @return An array of user's favorite record names
*/
function getUserFavorites(address _address) public view returns (string[] memory) {
return userFavoritesIndex[_address];
}

/**
* @dev Resets the caller's list of favorite records
*/
function resetUserFavorites() public {
for (uint i = 0; i < userFavoritesIndex[msg.sender].length; i++) {
delete userFavorites[msg.sender][userFavoritesIndex[msg.sender][i]];
}
delete userFavoritesIndex[msg.sender];
}
}

• Verify

• Code (6):

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

/**
* @title GarageManager
* @dev Contract to manage a garage of cars for each user
*/
contract GarageManager {
mapping(address => Car[]) private garages;

struct Car {
string make;
string model;
string color;
uint numberOfDoors;
}

error BadCarIndex(uint256 index);

/**
* @dev Adds a new car to the caller's garage
* @param _make The make of the car
* @param _model The model of the car
* @param _color The color of the car
* @param _numberOfDoors The number of doors of the car
*/
function addCar(string memory _make, string memory _model, string memory _color, uint _numberOfDoors) external {
garages[msg.sender].push(Car(_make, _model, _color, _numberOfDoors));
}

/**
* @dev Retrieves the caller's array of cars
* @return An array of `Car` structs
*/
function getMyCars() external view returns (Car[] memory) {
return garages[msg.sender];
}

/**
* @dev Retrieves a specific user's array of cars
* @param _user The address of the user
* @return An array of `Car` structs
*/
function getUserCars(address _user) external view returns (Car[] memory) {
return garages[_user];
}

/**
* @dev Updates a specific car in the caller's garage
* @param _index The index of the car in the garage array
* @param _make The new make of the car
* @param _model The new model of the car
* @param _color The new color of the car
* @param _numberOfDoors The new number of doors of the car
*/
function updateCar(uint256 _index, string memory _make, string memory _model, string memory _color, uint _numberOfDoors) external {
if (_index >= garages[msg.sender].length) {
revert BadCarIndex({index: _index});
}
garages[msg.sender][_index] = Car(_make, _model, _color, _numberOfDoors);
}

/**
* @dev Deletes all cars in the caller's garage
*/
function resetMyGarage() external {
delete garages[msg.sender];
}
}

• Verify

• Code (7):

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;


abstract contract Employee
{
uint public idNumber;
uint public managerId;

constructor(uint _idNumber, uint _managerId)
{
idNumber = _idNumber;
managerId = _managerId;
}

function getAnnualCost() public virtual returns (uint);
}

contract Salaried is Employee
{
uint public annualSalary;

constructor(uint _idNumber, uint _managerId, uint _annualSalary)
Employee(_idNumber, _managerId)
{
annualSalary = _annualSalary;
}

function getAnnualCost() public override view returns (uint)
{
return annualSalary;
}
}

contract Hourly is Employee
{
uint public hourlyRate;

constructor(uint _idNumber, uint _managerId, uint _hourlyRate) Employee(_idNumber, _managerId)
{
hourlyRate = _hourlyRate;
}

function getAnnualCost() public override view returns (uint)
{
return hourlyRate * 2080;
}
}

contract Manager
{
uint[] public employeeIds;

function addReport(uint _reportId) public
{
employeeIds.push(_reportId);
}

function resetReports() public
{
delete employeeIds;
}
}

contract Salesperson is Hourly
{
constructor(uint _idNumber, uint _managerId, uint _hourlyRate)
Hourly(_idNumber, _managerId, _hourlyRate) {}
}


contract EngineeringManager is Salaried, Manager
{
constructor(uint _idNumber, uint _managerId, uint _annualSalary)
Salaried(_idNumber, _managerId, _annualSalary) {}
}

contract InheritanceSubmission {
address public salesPerson;
address public engineeringManager;

constructor(address _salesPerson, address _engineeringManager) {
salesPerson = _salesPerson;
engineeringManager = _engineeringManager;
}
}

• On the “Deploy” tab select the same as in the first screenshot

• Click “Transact” and save the contract address

• Now do the same as indicated in the second screenshot

• Press “Transact” again and save the contract address

• Change the contract again and enter the addresses you copied earlier and press “Transact”

• Paste the contract address and confirm the transaction here

• Next, you need to create two new files: Imports and SillyStringUtils

• Paste a code (8):

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

contract ErrorTriageExercise {
/**
* Finds the difference between each uint with it's neighbor (a to b, b to c, etc.)
* and returns a uint array with the absolute integer difference of each pairing.
*/
function diffWithNeighbor(
uint _a,
uint _b,
uint _c,
uint _d
) public pure returns (uint[] memory) {
uint[] memory results = new uintUnsupported embed;

results[0] = _a > _b ? _a - _b : _b - _a;
results[1] = _b > _c ? _b - _c : _c - _b;
results[2] = _c > _d ? _c - _d : _d - _c;

return results;
}

/**
* Changes the _base by the value of _modifier. Base is always >= 1000. Modifiers can be
* between positive and negative 100;
*/
function applyModifier(
uint _base,
int _modifier
) public pure returns (uint returnValue) {
if(_modifier > 0) {
return _base + uint(_modifier);
}
return _base - uint(-_modifier);
}

/**
* Pop the last element from the supplied array, and return the popped
* value (unlike the built-in function)
*/
uint[] arr;

function popWithReturn() public returns (uint returnNum) {
if(arr.length > 0) {
uint result = arr[arr.length - 1];
arr.pop();
return result;
}
}

// The utility functions below are working as expected
function addToArr(uint _num) public {
arr.push(_num);
}

function getArr() public view returns (uint[] memory) {
return arr;
}

function resetArr() public {
delete arr;
}
}

• Verify

• Code (9):

AddressBook.sol

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

import "@openzeppelin/contracts/access/Ownable.sol";

contract AddressBook is Ownable(msg.sender) {
string private salt = "value";
struct Contact {
uint id;
string firstName;
string lastName;
uint[] phoneNumbers;
}

Contact[] private contacts;
mapping(uint => uint) private idToIndex;
uint private nextId = 1;

error ContactNotFound(uint id);

function addContact(string calldata firstName, string calldata lastName, uint[] calldata phoneNumbers) external onlyOwner {
contacts.push(Contact(nextId, firstName, lastName, phoneNumbers));
idToIndex[nextId] = contacts.length - 1;
nextId++;
}

function deleteContact(uint id) external onlyOwner {
uint index = idToIndex[id];
if (index >= contacts.length || contacts[index].id != id) revert ContactNotFound(id);

contacts[index] = contacts[contacts.length - 1];
idToIndex[contacts[index].id] = index;
contacts.pop();
delete idToIndex[id];
}

function getContact(uint id) external view returns (Contact memory) {
uint index = idToIndex[id];
if (index >= contacts.length || contacts[index].id != id) revert ContactNotFound(id);
return contacts[index];
}

function getAllContacts() external view returns (Contact[] memory) {
return contacts;
}
}


Other contract:

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

import "./AddressBook.sol";

contract AddressBookFactory {
string private salt = "value";
function deploy() external returns (AddressBook) {
AddressBook newAddressBook = new AddressBook();
newAddressBook.transferOwnership(msg.sender);
return newAddressBook;
}
}

• Code (9.1):

• Create another file and paste the second part of the code

• In the 4th field, enter the name of the file that you created before

• Copy and deploy the last file

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

import "./9.sol";

contract AddressBookFactory {
string private salt = "value";
function deploy() external returns (AddressBook) {
AddressBook newAddressBook = new AddressBook();
newAddressBook.transferOwnership(msg.sender);
return newAddressBook;
}
}

• Verify

• Code (10):

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

contract UnburnableToken {
string private salt = "value";
mapping(address => uint256) public balances;
uint256 public totalSupply;
uint256 public totalClaimed;
mapping(address => bool) private claimed;

// Custom errors
error TokensClaimed();
error AllTokensClaimed();
error UnsafeTransfer(address _to);

constructor() {
totalSupply = 100000000; // Set the total supply of tokens
}

// Public function to claim tokens
function claim() public {
if (totalClaimed >= totalSupply) revert AllTokensClaimed(); // Check if all tokens have been claimed
if (claimed[msg.sender]) revert TokensClaimed(); // Check if the caller has already claimed tokens

// Update balances and claimed status
balances[msg.sender] += 1000;
totalClaimed += 1000;
claimed[msg.sender] = true;
}

// Public function for safe token transfer
function safeTransfer(address _to, uint256 _amount) public {
// Check for unsafe transfer conditions, including if the target address has a non-zero ether balance
if (_to == address(0) || _to.balance == 0) revert UnsafeTransfer(_to);

// Ensure the sender has enough balance to transfer
require(balances[msg.sender] >= _amount, "Insufficient balance");

// Perform the transfer
balances[msg.sender] -= _amount;
balances[_to] += _amount;
}
}

• Verify

• Code (11):

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.17;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

contract WeightedVoting is ERC20 {
string private salt = "value";
using EnumerableSet for EnumerableSet.AddressSet;

error TokensClaimed();
error AllTokensClaimed();
error NoTokensHeld();
error QuorumTooHigh();
error AlreadyVoted();
error VotingClosed();

struct Issue {
EnumerableSet.AddressSet voters;
string issueDesc;
uint256 quorum;
uint256 totalVotes;
uint256 votesFor;
uint256 votesAgainst;
uint256 votesAbstain;
bool passed;
bool closed;
}
struct SerializedIssue {
address[] voters;
string issueDesc;
uint256 quorum;
uint256 totalVotes;
uint256 votesFor;
uint256 votesAgainst;
uint256 votesAbstain;
bool passed;
bool closed;
}

enum Vote {
AGAINST,
FOR,
ABSTAIN
}
Issue[] internal issues;
mapping(address => bool) public tokensClaimed;
uint256 public maxSupply = 1000000;
uint256 public claimAmount = 100;
string saltt = "any";

constructor(string memory _name, string memory _symbol)
ERC20(_name, _symbol)
{
issues.push();
}


function claim() public {
if (totalSupply() + claimAmount > maxSupply) {
revert AllTokensClaimed();
}
if (tokensClaimed[msg.sender]) {
revert TokensClaimed();
}
_mint(msg.sender, claimAmount);
tokensClaimed[msg.sender] = true;
}


function createIssue(string calldata _issueDesc, uint256 _quorum)
external
returns (uint256)
{
if (balanceOf(msg.sender) == 0) {
revert NoTokensHeld();
}
if (_quorum > totalSupply()) {
revert QuorumTooHigh();
}
Issue storage _issue = issues.push();
_issue.issueDesc = _issueDesc;
_issue.quorum = _quorum;
return issues.length - 1;
}


function getIssue(uint256 _issueId)
external
view
returns (SerializedIssue memory)
{
Issue storage _issue = issues[_issueId];
return
SerializedIssue({
voters: _issue.voters.values(),
issueDesc: _issue.issueDesc,
quorum: _issue.quorum,
totalVotes: _issue.totalVotes,
votesFor: _issue.votesFor,
votesAgainst: _issue.votesAgainst,
votesAbstain: _issue.votesAbstain,
passed: _issue.passed,
closed: _issue.closed
});
}


function vote(uint256 _issueId, Vote _vote) public {
Issue storage _issue = issues[_issueId];

if (_issue.closed) {
revert VotingClosed();
}
if (_issue.voters.contains(msg.sender)) {
revert AlreadyVoted();
}

uint256 nTokens = balanceOf(msg.sender);
if (nTokens == 0) {
revert NoTokensHeld();
}

if (_vote == Vote.AGAINST) {
_issue.votesAgainst += nTokens;
} else if (_vote == Vote.FOR) {
_issue.votesFor += nTokens;
} else {
_issue.votesAbstain += nTokens;
}

_issue.voters.add(msg.sender);
_issue.totalVotes += nTokens;

if (_issue.totalVotes >= _issue.quorum) {
_issue.closed = true;
if (_issue.votesFor > _issue.votesAgainst) {
_issue.passed = true;
}
}
}
}

• Verify

• Code (12):

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol";

interface ISubmission {
struct Haiku {
address author;
string line1;
string line2;
string line3;
}

function mintHaiku(
string memory _line1,
string memory _line2,
string memory _line3
) external;

// function ownerOf(uint256 _id) external view returns (address);

function counter() external view returns (uint256);

function shareHaiku(uint256 _id, address _to) external;

function getMySharedHaikus() external view returns (Haiku[] memory);
}

contract HaikuNFT is ERC721, ISubmission {
Haiku[] public haikus;
mapping(address => mapping(uint256 => bool)) public sharedHaikus;
uint256 public haikuCounter;

constructor() ERC721("HaikuNFT", "HAIKU") {
haikuCounter = 1;
}

string salt = "value";

function counter() external view override returns (uint256) {
return haikuCounter;
}

function mintHaiku(
string memory _line1,
string memory _line2,
string memory _line3
) external override {
// Check if the haiku is unique
string[3] memory haikusStrings = [_line1, _line2, _line3];
for (uint256 li = 0; li < haikusStrings.length; li++) {
string memory newLine = haikusStrings[li];
// string memory newHaikuString = string(
// abi.encodePacked(haikusStrings[li])
// );
for (uint256 i = 0; i < haikus.length; i++) {
Haiku memory existingHaiku = haikus[i];
string[3] memory existingHaikuStrings = [
existingHaiku.line1,
existingHaiku.line2,
existingHaiku.line3
];

for (uint256 eHsi = 0; eHsi < 3; eHsi++) {
string memory existingHaikuString = existingHaikuStrings[
eHsi
];
if (
keccak256(abi.encodePacked(existingHaikuString)) ==
keccak256(abi.encodePacked(newLine))
) {
revert HaikuNotUnique();
}
}
}
}

// Mint the haiku NFT
_safeMint(msg.sender, haikuCounter);
haikus.push(Haiku(msg.sender, _line1, _line2, _line3));
haikuCounter++;
}

function shareHaiku(uint256 _id, address _to) external override {
require(_id > 0 && _id <= haikuCounter, "Invalid haiku ID");

Haiku memory haikuToShare = haikus[_id - 1];
require(haikuToShare.author == msg.sender, "NotYourHaiku");

sharedHaikus[_to][_id] = true;
}

function getMySharedHaikus()
external
view
override
returns (Haiku[] memory)
{
uint256 sharedHaikuCount;
for (uint256 i = 0; i < haikus.length; i++) {
if (sharedHaikus[msg.sender][i + 1]) {
sharedHaikuCount++;
}
}

Haiku[] memory result = new HaikuUnsupported embed;
uint256 currentIndex;
for (uint256 i = 0; i < haikus.length; i++) {
if (sharedHaikus[msg.sender][i + 1]) {
result[currentIndex] = haikus[i];
currentIndex++;
}
}

if (sharedHaikuCount == 0) {
revert NoHaikusShared();
}

return result;
}

error HaikuNotUnique();
error NotYourHaiku();
error NoHaikusShared();
}

• Verify

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $65M from Polychain, Polygon, Celestia and others

What to do:

• Go to GitHub (create an account beforehand if you don't have one)

• Next, go to "Codespace"

• Click on "Blank template"

• Paste this code into the terminal

wget https://raw.githubusercontent.com/dxzenith/eclipse-testnet/main/eclipse.sh && chmod +x eclipse.sh && ./eclipse.sh

• Wait until everything is installed and then follow the steps that will be described in the terminal

• Next, where there is a step with a wallet, also follow all the instructions

• After all the steps, you will get the Program Address

• Paste this address into this form

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

💲 Raised: $12M from Polychain Capital, The Spartan Group, OKX Ventures, NGC Ventures and others

The project has recently launched an incentivized testnet

Nubit | Bitcoin Thunderbolt

@nubit_org

Nubit Alpha Testnet Incentivized Campaign is live!

Phase 1: Community Assemble starts today.

We're thrilled to kick off this journey and invite you to join us.

909

9:14 AM • Jun 8, 2024

Nubit's incentivized testnet is divided into 3 phases:

Phase 1: Community Assemble

Phase 2: Light Node Quest

Phase 3: Testnet Adventure

How to participate in the testnet:

• Go to the website and add the Nubit network to your Keplr wallet

• Open the menu in Keplr, then click "Manage Chain Visibility" and add the Nubit network

• Copy your Nubit address

• Request test tokens from the faucet

• Connect your wallet and socials to the website

• Send test tokens to any address

• Make several of these transactions

• Complete the tasks on Galxe

How to run a node:

• Install MobaXterm

• Rent a server on Contabo

• Save your account credentials and VPS details (IP and password)

• Connect to the leased server via root

• Execute the commands in the list

sudo apt update && sudo apt update -y sudo apt install curl git wget build-essential jq screen -y

• Update and install the necessary packages

• Enter "Y" if requested

• Then press "Enter"

• Create screen

screen -S nubit

• Run light node:

curl -sL1 https://nubit.sh | bash

• Switch to copying more:

Control+A+[

• The result will look like below. Save your mnemonic, public key, and auth key:

NAME: my_nubit_key ADDRESS: nubitxxxxxxxxxx
MNEMONIC: xxxxxxxxxx
PUBKEY xxxxxxxxx 
AUTH KEY xxxxxxxxxx

• Press Q to exit copying more. Press Control+A and then press D to exit the screen

• You can also reveal and save your Mnemonic (24 Words) by entering the following:

sudo cat $HOME/nubit-node/mnemonic.txt

• After 15 minutes, verify your Nubit light node pubkey here

• Replace the automatic seed (optional)

• Install nano

sudo apt-get update 
sudo apt-get install nano 

• Open notepad

nano $HOME/nubit-node/mnemonic.txt

• Replace seed

• Press CNTR+X, Y then Enter

• Check to see if the seed has been replaced

cat $HOME/nubit-node/mnemonic.txt

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $4M

A few days ago, the project launched a testnet

Union

@union_build

A new era of ZK-powered interop is here.

Union Public Testnet is LIVE: app.union.build

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 100%

25.3K

1:48 PM • Jun 26, 2024

How to interact:

• Go to the website and connect your wallet

• Request test tokens from the faucet

• Transfer test tokens from Union to Sepolia

• Complete the tasks on Galxe

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $180M from Paradigm, a16z and others

We have published several videos about Farcaster: 1 | 2 | 3

Also, join our Farcaster Hub on Telegram

How to run a node:

• Visit Alchemy or Infura website and Log in

• Click on “Create new API Key”

• Create Endpoints Ethereum(mainnet) and Optimism(mainnet) and save it

• Save HTTPS

• Next, you need to rent a server, use these hosting:

• AWS EC2

• Digital Ocean

• Google Cloud Platform

• Requirements:- 16 GB of RAM - 4 CPU cores or vCPUs - 140 GB of free storage - A public IP address with ports 2282 - 2285 exposed

• Create your server and save your password

• Open the terminal (console)

• Insert the following code:

sudo apt update
sudo apt upgrade -y

curl -sSL https://download.thehubble.xyz/bootstrap.sh | bash

• After running the command, insert Ethereum Endpoints, Optimism, and your FID

• Synchronizing a node can take up to an hour, so you can close the console window, it is running in the background

• Node monitoring is automatically installed with the node. For this, copy the IP address of your node and paste it in [enter ip address of your Droplet]

• Copy the result and paste it into a new window in your browser to monitor the node

• To update your node, go back to its console and stop it by inserting the following command:

docker stop $(docker ps -a -q)

• After that, insert the following command to start the node again

cd ~/hubble && ./hubble.sh upgrade

To check the status of your node, open the browser and enter: :3000 in url field, for example: 12.123.123.12:3000 ✅ That’s all! 🌐 FOLLOW OUR SOCIALS ✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $22.6M from Hack VC, dao5, StarkWare and others

The project has recently launched testnet 3

What to do:

• Download and install Aligned to send proofs in the testnet

curl -L https://raw.githubusercontent.com/yetanotherco/aligned_layer/main/batcher/aligned/install_aligned.sh | bash

• Download an example SP1 proof file with it's ELF file using:

curl -L https://raw.githubusercontent.com/yetanotherco/aligned_layer/main/batcher/aligned/get_proof_test_files.sh | bash

• Send the proof

rm -rf ~/aligned_verification_data/ &&
aligned submit \
--proving_system SP1 \
--proof ~/.aligned/test_files/sp1_fibonacci.proof \
--vm_program ~/.aligned/test_files/sp1_fibonacci-elf \
--aligned_verification_data_path ~/aligned_verification_data \
--conn wss://batcher.alignedlayer.com

• You should get a response

[2024-06-17T22:06:03Z INFO  aligned] Proof submitted to aligned. See the batch in the explorer:
    https://explorer.alignedlayer.com/batches/0x8ea98526e48f72d4b49ad39902fb320020d3cf02e6506c444300eb3619db4c13
[2024-06-17T22:06:03Z INFO  aligned] Batch inclusion data written into /Users/maurofab/aligned_verification_data/8ea98526e48f72d4b49ad39902fb320020d3cf02e6506c444300eb3619db4c13_225.json
[2024-06-17T22:06:03Z INFO  aligned] All messages responded. Closing connection...
https://explorer.alignedlayer.com/batches/0x8ea98526e48f72d4b49ad39902fb320020d3cf02e6506c444300eb3619db4c13```

• You can use the link to the explorer to check the status of your transaction. Then after three blocks, you can check if it has been verified with:

aligned verify-proof-onchain \
--aligned-verification-data ~/aligned_verification_data/*.json \
--rpc https://ethereum-holesky-rpc.publicnode.com \
--chain holesky

• You should get this result:

[2024-06-17T21:58:43Z INFO  aligned] Your proof was verified in Aligned and included in the batch!

• If the proof wasn't verified you should get this result:

[2024-06-17T21:59:09Z INFO  aligned] Your proof was not included in the batch.

• If you want to verify your proof in your own contract, use a static call to the Aligned contract. You can use the following Caller Contract as an example

• Tweet the link to your batch verification with #aligned and tag @alignedlayer

• Go to Galxe page and complete the tasks

• Answers: A, B, B, B, B, B, B

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $142M from Polychain Capital, HashKey Capital, Framework Ventures, Shima Capital and others

A few days ago, the project launched a new Public Testnet bArtio B2

How to interact:

• Request test tokens from the faucet (To use the faucet, you must have a min of 0.01 ETH on the Ethereum Mainnet)

• Next, follow the link and connect your wallet to add the new network

• Swap your $BERA to $STGUSDC and other tokens

• Switch to the "Pool" tab and add tokens to the pool to get $BGT

• Mint $HONEY on this website

• Connect your wallet to this site and deposit test tokens as collateral

• Supply/borrow $HONEY

• Go to the next website and connect the wallet

• Open different Long/Short positions in the "Berpetuals" tab

• In the "Vaults" tab, deposit tokens

• You can also create your invitation link in the "Referrals" tab

• On the next site, you need to deposit tokens in Gauge Vaults, delegate tokens to the validator, and redeem BGT for BERA

• Later, in the "Rewards" tab, you will be able to receive rewards

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

💲 Raised: $20M from Dragonfly, Pantera, Spartan group and others

Morph has launched new quests on the test network.

"A program designed to reward, engage, and celebrate our vibrant ecosystem, where every step you take earns you Morph Points for future airdrops”

What to do:

• Add the network to your wallet

• Request test tokens from the Holesky faucet

• Join Discord and on the channel "discord-faucet" enter the command /faucet+your wallet address

• Visit the website and connect your wallet

• Click on "Voting power" to get daily points and box

• Click “Vote now”, select any project and vote

• Transfer test $ETH to Morph Holesky network

• Swap tokens and add liquidity on the site

• Supply & Borrow tokens here

• Buy/sell NFTs on this page

• Complete the tasks on Galxe: 1 | 2 (answers: B, D, C)

Additional interaction

• Install Bitget Wallet, import the wallet or complete the previous tasks again

• Morph Ambassador/Mod Application

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

💲 Raised: $41.4M from Polychain Capital and others

The project has recently launched the Movement Community Program

How to participate:

• Add the network to your wallet (EVM | Aptos | Sui)

• Request test tokens from the faucet

• Follow the link and connect your Sui wallet

• Create and mint the NFT (the site may not work correctly)

• For the testnet you need Razor Wallet

• Visit the website and connect your Razor wallet

• Swap test tokens and add liquidity

• Complete the tasks on Zealy and Galxe

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

💲 Raised: $96M from Paradigm, Polychain Capital, HashKey Capital, Binance Labs, OKX Ventures and others

The project has recently launched Testnet-4 Launch. Testnet will be performed through a quest on Galxe

How to interact:

▶ Chapter 0: Onboarding

• Install OKX Web3 Wallet

• In the upper right corner of the network selection, select "All Networks"

• In the main wallet section, click "Manage" and in the token search field, enter sBTC (BTC Signet)

• Press "+" to add the asset

• Copy your address in the BTC Signet network

• Go to Babylon Discord’s #faucet-signet-btc channel (you must be verified to access it)

• Send your request starting with !faucet followed by your address

• Submit the transaction hash that you received from the faucet

• Finish the task on Galxe

▶ Chapter 1: Testnet Staking

• Complete the social tasks

• Visi the website and connect your wallet

• Stake $BTC to any validator

• Leave feedback on Discord on the #feedback channel, copy the link to your message and finish the task on Galxe

• Leave feedback on the forum

▶ Additional interaction

• Follow the link and connect your wallet

• Deposit test sBTC on the “Bitcoin > Deposit” tab

• Next, stake the tokens in the "stBTC" tab

• Also, Babylon has its own NFT collection with a 100k supply

• You can also run a node (guide)

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

20% of $ATLA tokens are allocated to Incentives

The project has recently launched the Olympia testnet

What to do:

• Go to the website and connect your wallet

• Switch the network to Atleta Olympia

• Request test tokens from the “Faucet” tab

• You can get additional 250 $ATLA for verifying your email

• Switch to the “Staking” tab and stake some of test tokens

• Participate in the available proposals in the “Governance” tab and create your own proposal

• You can create a proposal only if you have at least 100 $ATLA on your account

• By completing these tasks every day, you will earn XP

• Also, complete the quest on Galxe (you need to have Galxe Web3 Score >= 100)
Deadline: 06/30

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $20M from HashKey, GSR, AU21, Big Brain and others

Yesterday, the project launched an incentivized testnet. There will be 4 phases in total. One phase lasts one week

What to do:

• Install Keplr and create or import a wallet

• Add Nillion Testnet network to your wallet on the website

• Open the wallet and add a network in the "Manage Chain Visibility" tab

• Request test tokens from the faucet

• Send some tokens to other wallets (you can use our wallet: nillion1lh20aty4upexa8zgauzgquvez0xkpjr85y9clt)

• Follow the link and connect your Keplr

• Select a validator and delegate test $NIL to him

• You can check transactions here

• Run Nillion SDK (official guide)

• Developers can earn $1,000 per week by participating in the Building Blind (more details)

• Complete the tasks on Zealy

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $16.9M from Binance Labs, SVK Crypto, Woodstock Fund and others

12.7% of tokens are allocated to airdrop. Launch of mainnet scheduled for Q2 2024

What to do:

• Connet your GitHub and email to the website

• Click “Migrate staking portfolio”

• In the "Stake" section, deposit your tokens

• Also, unstake part of the tokens

• Make a donation

• In the "Settings" tab, customize your profile

• Builders can get 1000 points for registering their OSS project

• Complete tasks from the home page

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

The project is a participant in season 7 of the Most Valuable Builder (MVB) Accelerator Program by Binance Labs

8.8% of tokens allocated to Genesis airdrop and incentivized testnet + 11.2% allocated for future rewards (on TGE without locks)

The project has recently launched a closed testnet and node

Nesa

@nesaorg

Today is the official launch of Nesa Testnet.

Due to high demand, we are inviting whitelisted registrants in phases over the next two weeks.

1) Each day, check your email for an invitation.
2) When you receive your invite, register your account on beta.nesa.ai

605

1:16 AM • May 18, 2024

What to do:

• Go to the website and enter your email to be added to the whitelist

• Expect a letter in the mail, then register on the website

• Then claim your testnet tokens from the faucet and start interacting with a platform

• Join Discord and get all possible roles (#👥・role-list channel)

• Also, get roles on Guild

• Complete the tasks on Galxe

• Nesa Validator Node Interest Registration Form

Nesa

@nesaorg

Now Open: Nesa Validator Node Registration. The lowest machine requirements EVER for AI.

Join the network and power the future of AI using as little as your laptop at home with 4GB RAM.

Register now: forms.gle/zvojfDcq18X9uT…
Testnet validators will be admitted on a rolling

5,568

10:15 PM • May 20, 2024

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $3M

Not so long ago, the project launched a testnet with a point system (official guide)

Zulu Network

@zulu_network

Summary from the last few posts:
Zulu's Phase 1 Testnet: Lwazi is live!

Now you can earn ZGP (Zulu Genesis Points) for future rewards!

Lwazi Testnet program link: testnet.zulunetwork.io/lwazi

What do you need to do to earn? Read this: medium.com/@zulu_network/…

How about learning

Zulu Network

@zulu_network

And now, the moment you all have been waiting for!

Get ready to earn ZGP (Zulu Genesis Points)!
Participate in our test net, earn points get a chance for big future rewards!

Link: testnet.zulunetwork.io/lwazi

How to Guide: medium.com/@zulu_network/…

60

4:14 AM • Apr 5, 2024

What to do:

• Follow the link and connect your wallet, select Bitcoin Testnet (UniSat Wallet)

• Request test tokens from Discord and the faucet

• Also, take test tokens here and bridge it

• Then, swap tokens and add liquidity on the website

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

💲 Raised: $7.5M from Binance, Delphi digital, Big brain holdings and others

The project has launched a testnet that will last for 8 weeks, after which the mainnet is planned to be launched

Initia 🪢

@initia

A new multi-chain world begins, Initia’s Public Testnet is live.

The Initiation starts now at initia.xyz.

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 100%

5,030

9:10 AM • May 14, 2024

How to interact:

• Install the wallet and request the test tokens from the faucet

(The Initia Faucet uses Gitcoin Passport to verify Proof of Humanity, you need to have at least 20 score)

• Follow the link and connect your wallet

• Select and mint your name on Usernames

• Swap 1 $INIT for $USDC, $TIA or $ETH here

• Delegate some $INIT to the validators

• Stake $INIT to LP validators

• Return to the main page of the testnet and get rewards for staking and NFT for completing tasks

• After you get all the NFTs, you will receive 600 XP and will be offered to mint Jennie, a pet that needs to be cared for and fed at least once a week. After getting Jennie, you will get a new control panel with the pet, where you can track your progress.

• In the next step, you will feed your pet by opening the “Feed Jennie” tab. There will be a variety of food to choose from, but ideally, you should feed your pet the best food

There are currently 4 apps available in which you can farm XP:

• Next, click on "Earn more XP" and complete 3 tasks:

- Enter referral code: AI5NF2C1

- Follow Initia on Twitter

- Join Initia Discord

Earn more Initia XP

InitAI

• Bridge tokens to InitAI via the bridge

• Create your NFT collection on the website

• Mint other NFTs

Tucana Dex

• Bridge $INIT to Tucana via the bridge

• Use DEX and Perp

BlackWing

• Enter the invite code: jthbhz | xahst2 | r1hlfn | w3c4fw | loygla | toegym | zkjvm5 | a4cymq |

jw7ejf

• Connect your Twitter, Gmail and Telegram

• Deposited to Blackwing and get BXP

• Swap part of $BXP to $BUSD

• Start trading in the "Trade" tab

Update: Week 4

• Transfer 1 $USDC to Blackwing

• Transfer 1 $INIT to Init AI

• Transfer 0.1 $TIA to Noon

• Transfer 5 $TUC to Tucana

• Transfer 0.0001 $ETH to Minimove

• Transfer 1 $INIT to Civitia

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

Raised: $11.5M from Polychain Capital, Placeholder Ventures and ABCDE

How to interact:

• Visit the website and click “Add Botanix Testnet First”

• Request test tokens

• Take additional test tokens here

• Install the Unisat wallet

• Transfer test tokens to Unisat here

• Go to the Avocadoswap website and connect your wallet

• Swap tokens and add liquidity

• Complete the tasks on Galxe and Zealy

• Fill out the form and

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

The launch of the $KDO token has been confirmed

We wrote about Taiko here:

ATOMS

@atoms_res

Using this list, you will get an airdrop from Taiko

Recently, @taikoxyz launched the last testnet before the mainnet and published a list of winners who will receive important NFTs

$TKO token confirmed

ZERO-COST

Here is a full list of interactions with Hekla Testnet

191

6:32 AM • May 8, 2024

Recently, Kodo launched a testnet on Taiko Hekla

What to do:

• Request test tokens from the faucet

• Bridge test $ETH to Hekla network

• Visit the website and connect your wallet

• Swap available test tokens

• Add liquidity

• Also, test the “Bribe” tab

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!

The Birth of Bitcoin Runes

In April 2024, coinciding with a Bitcoin halving event, Bitcoin Runes were introduced to address the limitations of previous token standards like BRC-20 on the Bitcoin blockchain. Earlier protocols faced criticism for inefficiency and imposing significant network load.

How Bitcoin Runes Operate

Bitcoin Runes leverage the UTXO model of the Bitcoin blockchain, avoiding the generation of unspendable UTXOs that contribute to blockchain bloat. Tokens in the Runes system are issued and managed through a 'genesis' UTXO, recording essential details like the token's name, symbol, and total supply. These tokens can be divided and transferred while retaining their fungibility.

Potential Uses and Influence

The advent of Bitcoin Runes offers diverse applications, particularly in creating and managing memecoins and other fungible tokens more efficiently on the Bitcoin network. Additionally, being compatible with the Lightning Network, Runes can foster new forms of decentralized finance (DeFi) on Bitcoin, potentially expanding the platform's user base.

Challenges and Considerations

Despite their advantages, Bitcoin Runes may encounter challenges such as symbol squatting, akin to URL squatting on the internet, where individuals reserve desirable token symbols without actual usage, potentially leading to complications.

Runes Market and Ecosystem

Interacting with Runes requires specialized services as standard Bitcoin wallets do not display additional transaction information and their UI is not adapted to the protocol. To perform any operations, a specialized service is needed.

The most versatile option is Xverse, available as a mobile app or browser extension, supporting multiple token standards on the Bitcoin network built on Runes, Ordinals, and Stacks protocols.

You can also consider UnisatWallet and OKX wallet, as they support both Runes and tokens based on Ordinals.

To track new collections and create, mint, and transfer "runes," you can use the Luminex service. Simply connect a compatible wallet to access all essential operations.

Tokens issued can be listed for sale on specialized trading platforms:

UniSat, once popular as one of the first trading services for Ordinals, now also supports tokens based on Runes.

OKX Web3 is the trading platform of the eponymous cryptocurrency exchange, supporting both Runes and Inscriptions.

MagicEden, formerly the largest NFT marketplace in the Solana ecosystem, is now a cross-chain platform for NFT trading.

It's important to note that the Runes market is highly fragmented, so liquidity, trading volumes, and prices may differ across platforms. Before conducting any transactions, it's advisable to assess available offers on multiple platforms.

Runes Dashboard

**🔗 Dune

What Lies Ahead for Runes?

Rodarmor intends to implement direct trading between users in the near future. This could reduce reliance on centralized cryptocurrency exchanges and address the issue of Replace-By-Fee (RBF). RBF involves replacing a previous unconfirmed transaction with a new version containing a higher transaction fee, aiming to incentivize miners to prioritize transactions with higher fees.

Moreover, Rodarmor anticipates that with the approval of the OP_CAT Bitcoin Improvement Proposal (BIP), it will become feasible to bridge Runes tokens to Layer 2 networks. He predicts that this BIP will be introduced to Bitcoin within the next year. OP_CAT is an operation code (opcode) in the original Bitcoin script, where "CAT" stands for "concatenate," allowing two elements in a script to be combined. Satoshi Nakamoto disabled this opcode to prevent DoS attacks.

✅ That’s all!

🌐 FOLLOW OUR SOCIALS

✨ Collect this entry showing your support to our team! More collects-more guides!