DEV Community: sydneylai

exploring business models for open-source projects

sydneylai — Fri, 26 May 2023 17:56:22 +0000

I'm on this journey to build a profitable open-source project (OSS). In my career I’ve worked as a developer advocate and helping devs navigate how to optimize their productivity with useful developer tools. I also deeply align with the vision of democratizing access to toolings to provide optionality for builders.

I’ve seen role models in OSS and am on a journey to deconstruct their business models and see how this can be applied to open-source projects. For a few years I’ve been actively contributing to community-owned projects and toolings. If we take a look at the industry leaders:

Red Hat:

owned by IBM
Est. Revenue in fiscal year 2019 (before acquired by IBM) ~ $3.4B in revenue
business model: enterprise solutions on LinuxOS, apps and services on OSS

MongoDB (Database):

OSS NoSQL database
business model: commercial licenses, enterprise support, and cloud-based services

Docker (Containerization):

tool to build, package, and distribute applications using containers
business model: commercial offerings (Docker Enterprise) for enterprise-grade container management

My experience having been involved in Yearn, token swaps (ie SushiSwap) and Gitcoin:

business model: transaction fees (requires volume and velocity), TVL portfolio growth
most of these OSS projects are funded by community money or Foundation grants

The next step is exploring productizing AI-enabled products that improves the pain-points for devs or technical consumers. I’ve worked at companies where AI-assisted dev tools were greatly frowned upon. The 3 leading models for me are subscription plans, enterprise edition and building out a marketplace. The marketplace will be the long-term vision as the cold start problem then really requires momentum to overcome.

Revenue models for open-source:

commercial licenses
subscription plans ←
enterprise edition ←
support and maintenance
consulting and professional services
Cloud hosting
marketplace ←
data services

If you have any suggestions or want to share your own journey building revenue-generating OSS, would love to start a conversation. My next steps are iterating on product and adoption, based on user-feedback on nascent AI developer experiences.

Anyone currently using AI-assisted indexing to build their "second brain"?

sydneylai — Tue, 23 May 2023 18:33:27 +0000

1. How are you currently using AI-assisted indexing to build your information storage and retrieval?

2. Are we moving beyond input-oriented Notion documenting?

As a self-proclaimed builder and lifelong learner, I often find myself juggling multiple projects and striving for continuous improvement. Our brains are not naturally wired for long-term storage and recall, which is why exploring methods that optimize our learning process becomes crucial. I recently have been experimenting with combining the PARA method and AI-assisted tools which is designed to help create a “second brain” for effective recall and organization.

I did a quick search for “if i had a second brain” and found 20 million results on Reddit and 135 million on Google, it's clear there’s a user-base actively seeking ways to enhance their cognitive abilities and productivity. The PARA method, developed by Tiago Forte, provides a framework for organizing information into four categories: Projects, Areas, Resources, and Archives, enabling efficient knowledge structuring and retrieval. It’s like a kanban board for current knowledge acquisition vs long term storage knowledge indexing.

It’s taxing for us to max-out our bandwidth with memory-intensive knowledge storing. Whereas we can recall a database of information to make more informed strategic decisions.

Alongside the PARA method, I’m exploring AI-assisted screen recording, specifically with a focus on encryption and secure data storage, as an added layer of recall. What’s top of mind for me is how AI-assisted apps handle encryption and security.

Encryption:

Implementing end-to-end encryption for sensitive data protection
Using strong encryption algorithms to safeguard data during storage and transmission
Employing multi-factor authentication to enhance security

Secure data storage:

Exploring privacy-focused and compliant cloud-based storage solutions
Implementing robust access controls and permission settings
Regularly backing up data and adopting disaster recovery measures

3. How are you using AI-assisted screen recording for enhancing productivity?

4. What is the general consensus or your thoughts on how you’ve been incorporating AI-assisted indexing to build out your reference knowledgebase?

Feel free to share below on how you’re currently building your second brain or coordinating your recall method.

Your chaotic first Solidity tutorial

sydneylai — Sun, 12 Feb 2023 15:24:22 +0000

I'll do my best to guide you through your first Solidity tutorial, let's dig in!

To provide you some context on why Solidity: Solidity is a high-level programming language that is used to write smart contracts for the Ethereum blockchain. In this tutorial, we will be exploring the basics of Solidity and how it is used to create decentralized applications (dApps) that run on the Ethereum network.

If you're new to the world of blockchain and decentralized apps, don't worry! This tutorial is designed to be beginner-friendly and will guide you through the process of learning how to write smart contracts in Solidity. Whether you're a software developer looking to learn a new programming language or someone who is simply interested in learning more about blockchain technology, this tutorial is for you.

In the following tutorial, we will cover topics such as variables, functions, events, mappings, arrays, contracts, inheritance, modifiers, and Ether transactions. By the end of this tutorial, you will have a half-baked understanding of the basics of Solidity and you will have deployed your first Solidity contract. Let's get started!

Set-up

Install NVM

$ - install nvm

if you have Homebrew already installed

$ brew install nvm

Install version 16

$ nvm install 16

Create a directory

$ mkdir hardhat-tutorial
$ cd hardhat-tutorial

Create a Node. js project

$ npm init

$ npm install --save-dev hardhat

We want the package to be a development dependency

Install & Update Script

https://github.com/nvm-sh/nvm

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

$ nano ~/.zshrc
$ source ~/.zshrc
$ npx hardhat

And choose the JS option

Install Solidity in your VSCode, from the Marketplace

Walking through the Lock.sol file

constructor - what you run when you deploy a contract
block.timestamp - returns the timestamp of the block
msg.sender - refers to which ever address that deploys this contract

withdrawl - is a public function that anyone can call

However line 28 you can see there is a requirement that you must be the owner to withdrawl

require(msg.sender == owner, "You aren't the owner");

Changing wallet receive functions

Before

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }

    function withdraw() public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

After

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;
    address payable public receiver;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime, address _receiver) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
        receiver = payable(_receiver);
    }

    function withdraw(address to) public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner || msg.sender == receiver, "You aren't the owner or receiver");

        emit Withdrawal(address(this).balance, block.timestamp);

        payable(to).transfer(address(this).balance);
    }
}

1. Compile

$ npx hardhat compile

We need to compile the contract before we are able to deploy it on chain!

2. Run Tests

$ npx hardhat test

They all fail because we changed the constructor so now the deployment fixture no longer works!

Lock.js

Get ethers to get signers

Before

const {
  time,
  loadFixture,
} = require("@nomicfoundation/hardhat-network-helpers");
const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
const { expect } = require("chai");

describe("Lock", function () {
  // We define a fixture to reuse the same setup in every test.
  // We use loadFixture to run this setup once, snapshot that state,
  // and reset Hardhat Network to that snapshot in every test.
  async function deployOneYearLockFixture() {
    const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
    const ONE_GWEI = 1_000_000_000;

    const lockedAmount = ONE_GWEI;
    const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;

    // Contracts are deployed using the first signer/account by default
    const [owner, otherAccount] = await ethers.getSigners();

    const Lock = await ethers.getContractFactory("Lock");
    const lock = await Lock.deploy(unlockTime, { value: lockedAmount });

    return { lock, unlockTime, lockedAmount, owner, otherAccount };
  }

  describe("Deployment", function () {
    it("Should set the right unlockTime", async function () {
      const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.unlockTime()).to.equal(unlockTime);
    });

    it("Should set the right owner", async function () {
      const { lock, owner } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.owner()).to.equal(owner.address);
    });

    it("Should receive and store the funds to lock", async function () {
      const { lock, lockedAmount } = await loadFixture(
        deployOneYearLockFixture
      );

      expect(await ethers.provider.getBalance(lock.address)).to.equal(
        lockedAmount
      );
    });

    it("Should fail if the unlockTime is not in the future", async function () {
      // We don't use the fixture here because we want a different deployment
      const latestTime = await time.latest();
      const Lock = await ethers.getContractFactory("Lock");
      await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
        "Unlock time should be in the future"
      );
    });
  });

  describe("Withdrawals", function () {
    describe("Validations", function () {
      it("Should revert with the right error if called too soon", async function () {
        const { lock } = await loadFixture(deployOneYearLockFixture);

        await expect(lock.withdraw()).to.be.revertedWith(
          "You can't withdraw yet"
        );
      });

      it("Should revert with the right error if called from another account", async function () {
        const { lock, unlockTime, otherAccount } = await loadFixture(
          deployOneYearLockFixture
        );

        // We can increase the time in Hardhat Network
        await time.increaseTo(unlockTime);

        // We use lock.connect() to send a transaction from another account
        await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
          "You aren't the owner"
        );
      });

      it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
        const { lock, unlockTime } = await loadFixture(
          deployOneYearLockFixture
        );

        // Transactions are sent using the first signer by default
        await time.increaseTo(unlockTime);

        await expect(lock.withdraw()).not.to.be.reverted;
      });
    });

    describe("Events", function () {
      it("Should emit an event on withdrawals", async function () {
        const { lock, unlockTime, lockedAmount } = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw())
          .to.emit(lock, "Withdrawal")
          .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
      });
    });

    describe("Transfers", function () {
      it("Should transfer the funds to the owner", async function () {
        const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw()).to.changeEtherBalances(
          [owner, lock],
          [lockedAmount, -lockedAmount]
        );
      });
    });
  });
});

Add a receiver

const [owner, otherAccount, receiver] = await ethers.getSigners();

Get receiver address

const lock = await Lock.deploy(unlockTime, receiver.address{ value: lockedAmount });

Test your current status

At this point your current js file should look like the following:

const {
  time,
  loadFixture,
} = require("@nomicfoundation/hardhat-network-helpers");
const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
const { expect } = require("chai");

describe("Lock", function () {
  // We define a fixture to reuse the same setup in every test.
  // We use loadFixture to run this setup once, snapshot that state,
  // and reset Hardhat Network to that snapshot in every test.
  async function deployOneYearLockFixture() {
    const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
    const ONE_GWEI = 1_000_000_000;

    const lockedAmount = ONE_GWEI;
    const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;

    // Contracts are deployed using the first signer/account by default
    const [owner, otherAccount, receiver] = await ethers.getSigners();

    const Lock = await ethers.getContractFactory("Lock");
    const lock = await Lock.deploy(unlockTime, receiver.address, { value: lockedAmount });

    return { lock, unlockTime, receiver, lockedAmount, owner, otherAccount };
  }

  describe("Deployment", function () {
    it("Should set the right unlockTime", async function () {
      const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.unlockTime()).to.equal(unlockTime);
    });

    it("Should set the right owner", async function () {
      const { lock, owner } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.owner()).to.equal(owner.address);
    });

    it("Should receive and store the funds to lock", async function () {
      const { lock, lockedAmount } = await loadFixture(
        deployOneYearLockFixture
      );

      expect(await ethers.provider.getBalance(lock.address)).to.equal(
        lockedAmount
      );
    });

    it("Should fail if the unlockTime is not in the future", async function () {
      // We don't use the fixture here because we want a different deployment
      const latestTime = await time.latest();
      const Lock = await ethers.getContractFactory("Lock");
      await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
        "Unlock time should be in the future"
      );
    });
  });

  describe("Withdrawals", function () {
    describe("Validations", function () {
      it("Should revert with the right error if called too soon", async function () {
        const { lock } = await loadFixture(deployOneYearLockFixture);

        await expect(lock.withdraw()).to.be.revertedWith(
          "You can't withdraw yet"
        );
      });

      it("Should revert with the right error if called from another account", async function () {
        const { lock, unlockTime, otherAccount } = await loadFixture(
          deployOneYearLockFixture
        );

        // We can increase the time in Hardhat Network
        await time.increaseTo(unlockTime);

        // We use lock.connect() to send a transaction from another account
        await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
          "You aren't the owner"
        );
      });

      it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
        const { lock, unlockTime } = await loadFixture(
          deployOneYearLockFixture
        );

        // Transactions are sent using the first signer by default
        await time.increaseTo(unlockTime);

        await expect(lock.withdraw()).not.to.be.reverted;
      });
    });

    describe("Events", function () {
      it("Should emit an event on withdrawals", async function () {
        const { lock, unlockTime, lockedAmount } = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw())
          .to.emit(lock, "Withdrawal")
          .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
      });
    });

    describe("Transfers", function () {
      it("Should transfer the funds to the owner", async function () {
        const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw()).to.changeEtherBalances(
          [owner, lock],
          [lockedAmount, -lockedAmount]
        );
      });
    });
  });
});

Currently you should be passing your first 3 tests

Now we can go fix the actual tests

Now add a receiver parameter

await expect(Lock.deploy(latestTime, receiver.address, { value: 1 })).to.be.revertedWith(

Now define and include the signer object

      const latestTime = await time.latest();
      const Lock = await ethers.getContractFactory("Lock");
      const [owner, otherAccount, receiver] = await ethers.getSigners();

Run the test again and at this point your fourth test should pass

Now include the same receiver

        const { lock, receiver } = await loadFixture(deployOneYearLockFixture);

        await expect(lock.withdraw(receiver.address)).to.be.revertedWith(

You're not withdrawing to yourself but to the receiver

await expect(lock.connect(otherAccount).withdraw(otherAccount.address)).to.be.revertedWith(

You are now not the owner or receiver

Now update and include receivers

Lock.js

const {
  time,
  loadFixture,
} = require("@nomicfoundation/hardhat-network-helpers");
const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
const { expect } = require("chai");

describe("Lock", function () {
  // We define a fixture to reuse the same setup in every test.
  // We use loadFixture to run this setup once, snapshot that state,
  // and reset Hardhat Network to that snapshot in every test.
  async function deployOneYearLockFixture() {
    const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
    const ONE_GWEI = 1_000_000_000;

    const lockedAmount = ONE_GWEI;
    const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;

    // Contracts are deployed using the first signer/account by default
    const [owner, otherAccount, receiver] = await ethers.getSigners();

    const Lock = await ethers.getContractFactory("Lock");
    const lock = await Lock.deploy(unlockTime, receiver.address, { value: lockedAmount });

    return { lock, unlockTime, receiver, lockedAmount, owner, otherAccount };
  }

  describe("Deployment", function () {
    it("Should set the right unlockTime", async function () {
      const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.unlockTime()).to.equal(unlockTime);
    });

    it("Should set the right owner", async function () {
      const { lock, owner } = await loadFixture(deployOneYearLockFixture);

      expect(await lock.owner()).to.equal(owner.address);
    });

    it("Should receive and store the funds to lock", async function () {
      const { lock, lockedAmount } = await loadFixture(
        deployOneYearLockFixture
      );

      expect(await ethers.provider.getBalance(lock.address)).to.equal(
        lockedAmount
      );
    });

    it("Should fail if the unlockTime is not in the future", async function () {
      // We don't use the fixture here because we want a different deployment
      const latestTime = await time.latest();
      const Lock = await ethers.getContractFactory("Lock");
      const [owner, otherAccount, receiver] = await ethers.getSigners();
      await expect(Lock.deploy(latestTime, receiver.address, { value: 1 })).to.be.revertedWith(
        "Unlock time should be in the future"
      );
    });
  });

  describe("Withdrawals", function () {
    describe("Validations", function () {
      it("Should revert with the right error if called too soon", async function () {
        const { lock, receiver } = await loadFixture(deployOneYearLockFixture);

        await expect(lock.withdraw(receiver.address)).to.be.revertedWith(
          "You can't withdraw yet"
        );
      });

      it("Should revert with the right error if called from another account", async function () {
        const { lock, unlockTime, otherAccount } = await loadFixture(
          deployOneYearLockFixture
        );

        // We can increase the time in Hardhat Network
        await time.increaseTo(unlockTime);

        // We use lock.connect() to send a transaction from another account
        await expect(lock.connect(otherAccount).withdraw(otherAccount.address)).to.be.revertedWith(
          "You aren't the owner or receiver"
        );
      });

      it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
        const { lock, unlockTime, receiver } = await loadFixture(
          deployOneYearLockFixture
        );

        // Transactions are sent using the first signer by default
        await time.increaseTo(unlockTime);

        await expect(lock.withdraw(receiver.address)).not.to.be.reverted;
      });
    });

    describe("Events", function () {
      it("Should emit an event on withdrawals", async function () {
        const { lock, unlockTime, lockedAmount, receiver} = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw(receiver.address))
          .to.emit(lock, "Withdrawal")
          .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
      });
    });

    describe("Transfers", function () {
      it("Should transfer the funds to the receiver", async function () {
        const { lock, unlockTime, lockedAmount, owner, receiver } = await loadFixture(
          deployOneYearLockFixture
        );

        await time.increaseTo(unlockTime);

        await expect(lock.withdraw(receiver.address)).to.changeEtherBalances(
          [receiver, lock],
          [lockedAmount, -lockedAmount]
        );
      });
    });
  });
});

Lock.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;
    address payable public receiver;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime, address _receiver) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
        receiver = payable(_receiver);
    }

    function withdraw(address to) public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner || msg.sender == receiver, "You aren't the owner or receiver");

        emit Withdrawal(address(this).balance, block.timestamp);

        payable(to).transfer(address(this).balance);
    }
}

Deploy.js Original

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;

  const lockedAmount = hre.ethers.utils.parseEther("1");

  const Lock = await hre.ethers.getContractFactory("Lock");
  const lock = await Lock.deploy(unlockTime, { value: lockedAmount });

  await lock.deployed();

  console.log(
    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
  );
}

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

Has to pass as an argument to deploy it

[owner, receiver] = await ethers.getSigners()

And add a receiver addresss

const lock = await Lock.deploy(unlockTime, receiver.address, { value: lockedAmount });

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const { ethers } = require("hardhat");
const hre = require("hardhat");

async function main() {
  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;

  const lockedAmount = hre.ethers.utils.parseEther("1");
  [owner, receiver] = await ethers.getSigners()
  const Lock = await hre.ethers.getContractFactory("Lock");
  const lock = await Lock.deploy(unlockTime, receiver.address, { value: lockedAmount });

  await lock.deployed();

  console.log(
    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
  );
}

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

$ node scripts/deploy.js

Need two terminals to run the node

If your hardhat is not globally installed, ensure the second terminal has to be in the same folder

$ npx hardhat node --verbose

Deployed 🎉

Deploy your tokens to the receiver

$ npx hardhat --network localhost run scripts.deploy.js

I guess you can call yourself a solidity dev now

⚒️ @sydneylai

Thanks to mentor @afk0b

Build a Decentralized Ridesharing App - For Beginners

sydneylai — Tue, 26 Apr 2022 17:16:10 +0000

Author Twitter: @sydneylai

So the question I asked myself is why we don't have a decentralized Uber or ridesharing app.

I realized it's pretty hard to build, so in today's lesson I'm going to showcase a beginner example of how to build a database of drivers and passengers and how to match them.

MVP: Matching drivers and passengers based on their matching zip codes in their metro area. Showcase publishing and subscribing within the terminal
Creating the json files for the passengers and drivers

Idea:
Create a set of aggregators in the middle between the publishers and the subscribers. For example Google News: the news gets published but Google News aggregates the news. Instead of Google News, now IPFS is in the middle and the topic is drivers and passengers. The idea is the passenger broadcasts their location and the driver subscribes to their topic. The driver will publish and the passenger will subscribe.

Level 1: passenger publish, and all drivers in that area will subscribe
Level 2: Driver will publish to that specifically and the passenger will subscribe or tell the Driver that they accept that fare. The acceptance will then be published to the driver's topic.

Resources Used:
https://blog.ipfs.io/25-pubsub/
https://docs.ipfs.io/reference/cli/#ipfs-pubsub

Design:

List of drivers
- Driver Object should be a JSON object, python dictionary of values
  - Name of driver, the value (zipcode) of the driver
List of passengers
- Passenger Object should be a JSON object, python dictionary of values
  - Name of driver, the value (zipcode) of the driver
Function: randomly assigns Driver and Passenger if they are in the same zipcode
Result: Driver 1 is matched with Passenger 1

Backend "database":

(Decentralized) P2P database IPFS/distributed file systems
(Centralized) Created a small SQL database example to show comparison
The centralized database was in the demo.py file

The Idea: Is to wrap the shell commands with python code so can write python code in the command line - however this would require writing API REQUESTS

What we ended executing on: We demonstrated the demo by using curl commands in the terminal

Centralized Example

I will showcase what a centralized approach would look like, to contrast against a decentralized ridesharing approach. This centralized approach is what developers are typically more familiar with.

Python file
Centralized database with SQL

import sqlite3
import logging
from sqlite3 import Error

#first create connection function
def create_connection(db_file):
    """ create a database connection to the SQLite database
        specified by db_file
    :param db_file: database file
    :return: Connection object or None
    """
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        return conn
    except Error as e:
        print(e)

    return conn

#second create table function
def create_table(conn, create_table_sql):
    """ create a table from the create_table_sql statement
    :param conn: Connection object
    :param create_table_sql: a CREATE TABLE statement
    :return:
    """
    try:
        c = conn.cursor()
        c.execute(create_table_sql)
    except Error as e:
        print(e)
def create_driver(conn, driver):
    """
    Create a new driver
    :param conn:
    :param driver:
    :return:
    """

    sql = ''' INSERT INTO drivers(name,zipcodes)
              VALUES(?,?) '''
    cur = conn.cursor()
    cur.execute(sql, driver)
    conn.commit()
# this inserts the driver into the database

    return cur.lastrowid
#third create a main function to create the passenger, in this example you would create a API request to publish the passenger (Decetralized matching, you create the copy and the idea is that it becomes decentralied)

def create_passenger(conn, passenger):
    """
    Create a new passenger
    :param conn:
    :param passenger:
    :return:
    """

    sql = ''' INSERT INTO passengers(name,zipcodes)
              VALUES(?,?) '''
    cur = conn.cursor()
    cur.execute(sql, passenger)
    conn.commit()
# this return function is a webrequest return, you would return the value of the webrequest - success!

    return cur.lastrowid
#fourth create a main function to create the drivers and passenger tables

def create_drivers_passengers():
    database = r"pythonsqlite.db"

    # create a database connection
    conn = create_connection(database)
    with conn:
        # create a new driver
        driver1 = ('John', '92802');
        driver1ID = create_driver(conn, driver1)

        # passenger
        passenger_1 = ('Sydney','92704')
        passenger_2 = ('Rob','92802')

        # create passenger
        create_passenger(conn, passenger_1)
        create_passenger(conn, passenger_2)


def create_drivers_passengers_table():
    database = r"pythonsqlite.db"

    sql_create_drivers_table = """ -- drivers table
                                CREATE TABLE IF NOT EXISTS drivers (
                                    id integer PRIMARY KEY,
                                    name text NOT NULL,
                                    zipcodes text NOT NULL
                                    );"""

    sql_create_passengers_table = """-- passengers table
                                CREATE TABLE IF NOT EXISTS passengers (
                                    id integer PRIMARY KEY,
                                    name text NOT NULL,
                                    zipcodes text NOT NULL
                                );"""
    # create a database connection
    conn = create_connection(database)

    # create tables to create the connection
    if conn is not None:
        # create drivers table
        create_table(conn, sql_create_drivers_table)

        # create passengers table
        create_table(conn, sql_create_passengers_table)
    else:
        print("Error! cannot create the database connection.")

#Fifth, reconnect database and extract from that database

# This would have been an API Request to my 127001 - would subscribe and get back all the passengers
def select_all_passengers(conn):
    """
    Query all rows in the passengers table
    :param conn: the Connection object
    :return:
    """
    cur = conn.cursor()
    cur.execute("SELECT * FROM passengers")

    rows = cur.fetchall()
#fetch all the rows but this does not return anything
    passenger_list=[]
    for row in rows:
        print(row)
        passenger={"name":row[1],"zipcode":row[2]}
        #reconnect db and extract from that db
        passenger_list.append(passenger)
    return passenger_list    


#run this function, and call this function
def select_all_drivers(conn):
    """
    Query all rows in the drivers table
    :param conn: the Connection object
    :return:
    """
    cur = conn.cursor()
    cur.execute("SELECT * FROM drivers")

    rows = cur.fetchall()
    driver_list=[]
    for row in rows:
        driver={"name":row[1],"zipcode":row[2]}
        #reconnect db and extract from that db
        driver_list.append(driver)
        print(row)
    return driver_list

def drivers():
    database = r"pythonsqlite.db"
    conn = create_connection(database)
    return select_all_drivers(conn)
def passengers():
    database = r"pythonsqlite.db"
    conn = create_connection(database)
    return select_all_passengers(conn)
def match(
    passenger
#make passenger as an argument to match
):
    driver_list = drivers()
    passenger_zipcode = passenger["zipcode"]
    for driver in driver_list:
        driverzipcode = driver["zipcode"]
        if driverzipcode == passenger_zipcode:
        #== bc test for equality
            drivername = driver["name"]
            passengername = passenger["name"]
            return f"{drivername} = {passengername}"
            #rememeber to format with f
def main():
    create_drivers_passengers_table()
    #create_drivers_passengers() - this is redundant, does not need to be run more than once
    database = r"pythonsqlite.db"
    conn = create_connection(database)
    #select_all_passengers(conn) - these are stepping stones to get database to work
    #select_all_drivers(conn) - these are stepping stones to get database to work

    passenger_list = passengers()
    #conn is the connection to the database
    logging.warning(passenger_list)
    passenger = passenger_list[1]
    #takes first passenger out of the list and calls it passenger
    message = match(passenger)
    print (message)
main()

Create Table

create connection function
create table function
create main function to create drivers and passengers

Edit the template to equal to passengers

Table names must map, and turn those into DB

Driver Name
Driver Zipcodes
Passenger Name
Pasenger Zipcodes

Lesson: database is hardcoded within python file

Decentralized Example

Building a decentralized example of ridesharing matching, showcases how we as developers have to rethink how to build a "database" of drivers and passengers.

Create a json file for each driver and each passenger
Matching the driver and passengers with the IPFS pubsub method via curl commands in the terminal to showcase peer to peer to matching

driver1.json

    {
    "name":"Todd", "zipcode":"33101"
}

driver2.json

{
    "name":"Bob", "zipcode":"33129"
}

passenger1.json

    {
    "name":"John", "zipcode":"33101"
}

passenger2.json

    {
    "name":"Sally", "zipcode":"33129"
}

These json files require less code than a traditional python file with a centralized database.

Create a Topic - via JSON file
Every passenger would have their own JSON (JSON formmated payloads) file, so if this app had 20M passengers there would be 20M JSON files. So here you can see another perspective of having a decentralized database because you would need 20M individual JSON files rather than having 20M rows in a single database.
Create a Passenger File
Create a Driver File
Publish passenger file to passenger topic
Publish driver file to driver topic
Subscribe to passenger topic to get location

At this point I've created JSON files for Passengers and Drivers.

Create a database as an end point

Install the IPFS
https://docs.ipfs.io/install/command-line/#official-distributions
Once IPFS is installed you can call the daemon from the Command Line.

To store Drivers and Passengers, each profile would be json files in IPFS.
- List of Drivers with zip codes as a file
- List of Passengers with zip codes as a file
Every file would be published with a curl command to the local host 127001.
Each driver/passenger would publish their own request, and pull each other's profiles. Each file would be their own driver/passenger profile.

Lesson: at this point, I have:
- Learned how to interact with IPFS
- Installed IPFS in the terminal https://docs.ipfs.io/install/command-line/#official-distributions

Start the daemon

Installing the IPFS is like building the post-office. Publishing a JSON file would be putting a letter in the mail.

Start the daemon to run in the background, like opening the post-office:

```sudo ipfs daemon```

by starting the IPFS daemon

IPFS generates a hash in the system to provide a unique identifier.

Driver1 Hash

"Hash":"QmWFRKVtsJCdwPaD3SozvSwMdhxo3EJLpEv4LMoPcqopoX"

Driver 2 Hash

"Hash":"QmUr2jDAeWpVFX6s6fkCLGoQCn8SpDaQQMqZazJSiomZKj"

At this stage, we are trying list all file objects loaded in IPFS, to do so we need to know our Hash.

When running curl commands we directly interacted with IPFS.

The webapp would send request to sever (or in this case, a decenetralized file system) and now all these hashes are stored in a JSON server.

Lesson: At this point I am able to upload the JSON files for Drivers and Passengers with a curl command.

Next Steps:
1. assign a Topic
2. and then pub/sub

A topic can be constructed however you want, so if you had a topic for a particular zip code, then everyone subscribed to that zip code will see all messages published to it. For example:

curl -X POST -F file=@myfile "http://127.0.0.1:5001/api/v0/pubsub/pub?arg=90011"

Would publish to the topic (in this case a zip code) "90011" if you wanted to sub, so you can retrieve all messages sent to that zip code with the following:

curl -X POST "http://127.0.0.1:5001/api/v0/pubsub/sub?arg=90011"

In the terminal, this command should retrieve all previous CIDs (content identifier) I've created:

    ipfs pin ls

QmejvEPop4D7YUadeGqYWmZxHhLc4JBUCzJJHWMzdcMe2y indirect
QmQ5vhrL7uv6tuoN9KeVBwd4PwfQkXdVVmDLUZuTNxqgvm indirect
QmYCvbfNbCwFR45HiNP45rwJgvatpiW38D961L5qAhUM5Y indirect
QmdvS8djomKst8dkkahdCsDkyWjkH3D5yeXu9s5PC74VuB recursive
QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB indirect
QmU5k7ter3RdjZXu3sHghsga1UQtrztnQxmTL22nPnsu3g indirect
QmUr2jDAeWpVFX6s6fkCLGoQCn8SpDaQQMqZazJSiomZKj recursive
QmWFRKVtsJCdwPaD3SozvSwMdhxo3EJLpEv4LMoPcqopoX recursive
QmZnzGhPM5mo8BSWcABeWXavkjpjFsu8yoMg5HQ7A998ty recursive
QmeGVdbzX2gn8wFyK5cQok4UctCfZrS1phPJe5ZEi5FhpW recursive
QmQGiYLVAdSHJQKYFRTJZMG4BXBHqKperaZtyKGmCRLmsF indirect
QmQPeNsJPyVWPFDVHb77w8G42Fvo15z4bG2X8D2GhfbSXc recursive
QmTReW6Cu4E7PARfJ9FUU5y3r215rVvqmQtripsSAwFBxc recursive
QmQy6xmJhrcC5QLboAcGFcAE1tC8CrwDVkrHdEYJkLscrQ indirect
QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn recursive

Create a topic

https://blog.ipfs.io/25-pubsub/
https://docs.ipfs.io/reference/cli/#ipfs-pubsub-ls

sub to the topic

ipfs pubsub passengers

publish to a topic

ipfs pubsub pub passengers passengers/passenger1.json

Result:

What ends up happening:
1. passsenger publishes to a zipcode
2. driver subs to a zipcode
3. gets matched through pubsub

Publish to a Driver topic

sub to the topic

ipfs pubsub drivers

publish to a topic

ipfs pubsub pub drivers drivers/driver1.json

Result:

What you see here is John is a passenger in zip code 33101 and Todd is a driver in zip code 33101 and are matched in IPFS.

Lesson Learned

learned a new mental model on databases, so instead of the traditional one database with various files, I had to "host" each individual file in IPFS. Instead of having a database of passenger and drivers, I needed to create a single JSON file per driver and per passenger, and so instead of having a database of 20M drivers and passengers, I would need to create 20M individual JSON files
learned pubsub, publishing to an IPFS Topic and subscribing to an IPFS Topic which allows passenger to publish their zip code to an IPFS Topic which is then matched with a driver that subscribes to an IPFS Topic
how conceptually difficult it is to make a decentralized ridesharing app, but at the same time the core matching mechanism of pairing json files to json files requires less lines of code
learn how to make a database and connecting to it

Note to devs

Take into consideration that this is just an educational tutorial. If you were to build a decentralized ridesharing app there are inherent privacy and safety concerns of matching strangers on a decentralized trust network.

Additional Resources

Project can be found: https://github.com/sydneylai/rideshare

Quickie on Cloud vs IPFS

sydneylai — Mon, 31 Jan 2022 15:40:53 +0000

There's been a lot of chatter about the metaverse, so I wanted to explore how we as humanity will build the various verses. This reminded me of how there are various cloud service providers ranging from Azure, IBM, AWS to Google Cloud. As I dove into IPFS this theme reminded me of the LAN parties of the 90s, with various gaming worlds operating simultaneously and peer-to-peer.

Now this article will not be detailing the metaverse backend architecture, I will first begin with looking at cloud infrastructure vs IPFS infrastructure as a primer, as this is a fundamental shift of how we once understood programming. Instead of creating one database with 20M user profiles, now you would create one JSON file per user profile.

Storage is saving data information on a hard-drive. Then came cloud storage, where a company came in to offer storage services for you so that you did not have to lug around your hard drive. Cloud storage allows you to store internet data through a provider who manages and operates data as a service. You can retrieve your data on demand. IPFS introduces storage across a network of storage providers rather than a centralized provider such as Google Cloud.

Difference between Cloud vs IPFS

Cloud developers can access their builds across their work computers in Google Cloud Console. Sharing documentation and access rights with colleagues allows for a remote team not tied down to where the company's on prem servers are. If developers ever want to access their Cloud service, they would still need internet connectivity and pay their subscription fee. The key disadvantage for cloud storage is that it only works with an internet connection. Although, most situations in work and life provide for internet access, there are places and times when this just isn’t possible. Thus, you run the risk of not all parties being able to work on the same project.

Developers using IPFS have no-central-administration feature, therefore a file may not necessarily be stored on one node. There may be many nodes storing small pieces of that file. This means that instead of retrieving the file from one location, you actually retrieve the file from multiple nodes at once, massively reducing bandwidth. If a portion of your data is compromised, not all your information is in jeopardy as your information is dispersed. IPFS provides efficient data storage, distribution, and data permanence that allows for offline-oriented paradigms.

Why This Matters

To explain the architecture I'll use a consumer-based approach. When a user uploads data, that data is sent to servers run by Example Startup, and those servers store that data on a company owned IPFS node.

"This is how IPFS commonly works today (web2.0 style, use server to make available over IPFS) but ultimately the goal would be for the client itself to make it available over IPFS (Step 1, already available over IPFS), then contact the company owned IPFS node, and ask it to help persist it (or/and ask your peers)." - Discordian, Developer Advocate at Filecoin

For data to be available on the IPFS network, at least one node has to be hosting the data. Thus, IPFS allows us to retrieve that based on what the data is, not where the data is. This means no more fishing around your cloud folders trying to remember which folders you had put those company documents.

If you share a viral TikTok with everybody, your friends. The way the video clip would be retrieved is everyone clicking on the link to the video. This then takes them to the website that the video is hosted on and every single one of your coworkers’ computers has to individually reach out to the website’s server to download the video. This situation puts enormous strain on our internet infrastructure and is why certain sites are not designed for traffic load capacity crashes.

IPFS does not use a website’s server to send the video to every single person that’s trying to view it, IPFS looks for the video’s CID, or “content identifier”. The CID is akin to the hash for the content. This CID is based on what the content is, not where the content is located. The site will ask the IPFS network for the video that corresponds to the CID it was just given, regardless of where it is stored, rather than fetching that content from the website’s server.

Introducing IPFS to a developer’s stack requires a mindshift change on how one develops in web3.

Resources:

If you'd like a detailed document of how I build the technical architecture of the metaverse, please comment below to request, or if any other build requests.

IPFS Docs: https://ipfs.io/#install
NFT Storage: https://nft.storage/
Tutorial on how I make & store NFTs: https://dev.to/sydneylai/create-and-host-nfts-with-25-lines-of-code-4l4e

Build an NFT Wallet with OutSystems & Filecoin

sydneylai — Fri, 22 Oct 2021 23:31:01 +0000

Author: @sydneylai

You hear about NFTs as collectables or images, but how do we store or collect them? Today we will build an NFT wallet and host them on IPFS as a unique NFT.

We host the images in IPFS because this a peer to peer and a decentralized form of storage, rather than a centralized solution like AWS or Google Cloud. Therefore if AWS goes down or you forget to pay your Cloud subscription, you still have a hosting solution that assigned a unique identifier or content identifier (CID).

Once you have a unique image, you can either distribute your NFTs on a marketplace, put it on a smart contract or turn it into a game. I'll include resources below for how else you can continue to build. This tutorial is for beginners who want to learn how to create and host their NFTs.

Start Here

Exposing a REST API for NFT Storage and OutSystems

Tools you'll need:

OutSystems IDE https://outsyste.ms/developers
Filecoin's NFT Storage https://nft.storage/

Filecoin and IPFS Explained

Vocab 101

CID - content ID
Pinning - asking the node to keep the data, so that it's not trashed, if you pin it hte data presists
Quede vs Pinning - next deal brokered to get on the Filecoin network

Making an NFT Wallet and Hosting NFTs

https://nft.storage/

Here is your hosted image, with a CID

Hosting NFTs on marketplaces or wallets typically request ETH and gas. NFT developers who want free decentralized storage, you will be able to host your images on-chain with NFT.storage.

Just upload your data and you'll receive an IPFS hash of the content (a CID) that can be used in on-chain NFT data as a pointer to the content.

How it works:

Upload your data, get back an IPFS hash of the content (a CID) that can be used in on-chain NFT data as a pointer.
Storage + Retrieval is free!
Metadata is returned in proper formats!
Fetch it back via IPFS (pinned redundantly >3x)
Backed up to Filecoin (stored redundantly >5x)

Filecoin provides long term storage for the data ensuring that even if nft.storage is attacked or taken down the NFT data persists.

Consume API

You can upload either a single file or consume the API to upload multiple files in a directory. The API follows a typical POST and GET Method.

**/Upload** - Consuming the API / Post Method

Explains uploads, throws it on some IPFS nodes, available over the network, not just centralized, it's free, the storage providers.
https://nft.storage/api-docs/

Consume NFT Storage API

Step 1: Start with a mobile app

When you launch Service Studio, you want to create a mobile application by clicking on "From Scratch" and then "Phone app".

Name your application.

Here you can design your application however you'd like. In this process, I'm creating an NFT wallet with a simple scrolling mechanism similar to the Instagram layout.

Step 2: Consume the NFT Storage REST API

Click on Service, as we are building a service to consume the REST API

Right Click on REST and consume REST API

Add Multiple Methods

Find the YAML file here
https://nft.storage/api-docs/

Convert the NFT Storage YAML file to a JSON
https://nft.storage/schema.yml

Convert with
https://www.convertjson.com/yaml-to-json.htm

Check and address any errors and warnings

Step 3: Create and map out your REST API

Add Authorizations to your Methods

Double-click on the orange REST API Method titled "Click" > "Heads and Authentication"

In the Request headers dropdown select "Authorization"

Click on the "Test" tab and include a CID in the URL parameter values. You can find your CID HERE if you are logged in.

in Request headers values, Authorization, include:

Bearer[KEY TOKEN]

Bearer - When things are stored in, there is a storage deal made, what each API call is doing in the background

click on "Test" to see an

"ok":true value

Copy to response body
Click on Finish
Hit the green Publish button

Now repeat Step 3 for the rest of the REST API Methods titled "delete", "list", "status", "store" respectively

On the "List" method,

Include a future date for the before parameter

Copy over and match the fields

While you're creating an Authorization input parameter for both "Status" and "Store" you may get an error or empty payload, just click "Finish"

Hit the green Publish button

Step 4: Create a Service Action
Right Click on "Service Action" and title your action "List"

The logic flow will visually appear

In the Logic tab,
Integrations > REST > NFTStorageAPI >

Drag the "list" Run Server Action into the logic flow and click on the icon until you see the "Authorization" dropdown

It's empty

In "list" Run Server Action, copy all four input parameters, and paste in the "List2" Service Action

Now include the Before and Limit within the List Run Server Action you just created on the Logic Flow

Assign the "list" Run Sever Action by dragging an "Assign" blue icon from the left tray into the logic flow, below the "list" icon

Assign the variable with "Response"

💡 You may get errors asking to make your structures public

Step 5: Integrate your API wrapper

To integrate your API, head to Interface > Home Screen and "Fetch Data from Other Sources", which I've named "ShowStorage"

In the upper left-hand side there is a 🔌 icon where I will manage my dependencies. I want all the modules that I've created before, to be referenced.

Head to the Logic tab and locate "List" Service Action, click on and drag the icon into the logic flow.

Head to the interface tab and double-click on the Output Parameter we've named "Response", set the Data Type to a ListResponse matching the Response Output Parameter in the Logic tab.

On the logic flow, drag and drop an Assign into the logic flow. In the drop-down, assign Response and List3.Response (or whichever number list you have show up).

In your Run Server Action titled "List", set

before: "CurrDateTime()"
Authorization: " "Bearer TOKEN" "

Your Authoization Bearer TOKEN is a string so must close in quotes.

Step 6: Connect the database and images

On the Interface tab in the Mainflow UI Flow, add a Block widget and add an Input Parameter titled "CID".

Double-Click on the "Home" Screen icon and select "Widget Tree" on the top right.

In Content, drag and drop a Block widget and set the sources:

Source Block "MainFlow\Block1"
CID "ShowStorage.Response.value.Current.cid"

Include three "x.y Expression" widgets within Content

In the first Expression, map the expression to

ShowStorage.Response.value.Current.cid

Folder structure is seen here:

The second Expression, can be expressed as follows:

FormatDateTime(ShowStorage.Response.value.Current.created, "d MMM yyyy HH:mm")

The third Expression, we can showcase the pinning service.

The Images

In the Interface tab, click on the Block1 widget. Drag and drop an Image widget from the left.

Set the Type to "External URL"

"https://" + CID + ".ipfs.dweb.link"

In the API wrapper that I've titled "IPFSNFTStorage", create an Input Parameter within the "store" REST API Method. The Input Parameter will be named "Binary Image" and set the Data Type to "Binary Data".

Now copy the three input parameters in store and create a Service Action titled "Upload" within the Service Actions folder. Paste the three input parameters within the "Upload" Service Action

Double-click on "Upload" Service Action and drag the store REST API Method onto the logic flow

The "Store" Run Server Action is like requestion something from someone, in this case asking someone for the image.

Therefore the Assign widget in the logic flow will be the response to the request:

Success ⭐

You have integrated your NFT Storage API and your mobile application can now display hosted NFTs

Continuing Education

Listen to Patrick Collins, developer advocate at Chainlink explain securing blockchain oracles on Decoded Podcast.

Video Tutorial

https://youtu.be/3Zy7XfDnev0

Create and host NFTs with 25 lines of code

sydneylai — Mon, 18 Oct 2021 17:39:38 +0000

Author: @sydneylai

You often hear about the 10,000 NFT collection, but how does someone make thousands of unique images? Today we will build an algorithmically generate image dataset and host them on IPFS as a unique NFT.

Once you have a unique image, you can either distribute your NFTs on a marketplace, put it on a smart contract or turn it into a game. I'll include resources below for how else you can continue to build. This tutorial is for absolute beginners who want to learn how to create and host their NFTs.

Tools you'll need:

Download Images

Consolidated Folder found on my Github

Otherwise, if you want to create your own selection:

objects: https://craftpix.net/freebies/free-staves-2d-weapon-pack/
characters: https://craftpix.net/freebies/2d-fantasy-elf-free-sprite-sheets/
background: https://craftpix.net/freebies/free-elven-land-game-battle-backgrounds/

Create Image Folders

Create a master folder, you can name it "NFT1"
Create a folder to organize your:

backgrounds
characters
objects

Code Breakdown

Install Pillow Library

pip install Pillow

Go into python, create a python file name "main.py"

emacs main.py

In your python file, you want to include the following code.

Here is the python code needed to create your image collection.


from os import path, mkdir
from PIL import Image

output_folder = "generated"
if not path.exists(output_folder):
    mkdir(output_folder)

def generate_image(background, character, object, file_name):
  background_file = path.join("backgrounds", f"{background}.png")
  background_image = Image.open(background_file)

  #Create character
  character_file = path.join("characters", f"{character}.png")
  character_image = Image.open(character_file)
  coordinates = (int(1920/2-character_image.width/2), int(1000-character_image.height)) #x, y
  background_image.paste(character_image, coordinates, mask=character_image)

  #Create object
  if object != "none":
    object_file = path.join("objects", f"{object}.png")
    object_image = Image.open(object_file)
    coordinates = (int(1920/2+character_image.width/2+30), int(1000-object_image.height)) #x, y
    background_image.paste(object_image, coordinates, mask=object_image)
    output_file = path.join(output_folder, f"{file_name}.png")
    background_image.save(output_file)

for background in ["background1", "background2", "background3"]:
    for character in ["elf1", "elf2", "elf3"]:
        for object in ["object1", "object2", "object3"]:
            generate_image(background, character, object, file_name=f"{background}{character}{object}")

Coordinates

Calculating the coordinates is how you will layer the image files on top of each other. For example, if you have collectable dogs and they have objects like hats, you will be able to place various hats on the template frame of the dog image.

Calculate the length and width of your background image, and know where to place your characters.

coordinates = (int(1920/2-character_image.width/2), int(1000-character_image.height)) #x, y

Calculate the length and width of your background image, and know where to place your objects.

coordinates = (int(1920/2+character_image.width/2+30), int(1000-object_image.height)) #x, y

Special thanks to Albert Sanchez Lafuente. If additional math is needed for figuring out coordinates on your image read.

for loops

for background in ["background1", "background2", "background3"]:
    for character in ["elf1", "elf2", "elf3"]:
        for object in ["object1", "object2", "object3"]:

This portion of the code allows you to create you generative art. Ensure that your naming convention is consistent with the files in the folders you are referencing

If I want to create a custom design, or limited unique art, you can tell python to generate a specific combination or reference a specific file.

generate_image(background="background1", character="elf1", object="object1", file_name="example1")

Generate

Run your main.py file

python3 main.py

Your algorithmically generated image dataset will appear in "generated" folder

Hosting NFTs

https://nft.storage/

Here is your hosted image, with a CID

Hosting NFTs on marketplaces or wallets typically request ETH and gas. NFT developers who want free decentralized storage, you will be able to host your images on-chain with NFT.storage.

Just upload your data and you'll receive an IPFS hash of the content (a CID) that can be used in on-chain NFT data as a pointer to the content.

How it works:

Upload your data, get back an IPFS hash of the content (a CID) that can be used in on-chain NFT data as a pointer.
Storage + Retrieval is free!
Metadata is returned in proper formats!
Fetch it back via IPFS (pinned redundantly >3x)
Backed up to Filecoin (stored redundantly >5x)

Filecoin provides long term storage for the data ensuring that even if nft.storage is attacked or taken down the NFT data persists.

Consume API

You can upload either a single file or consume the API to upload multiple files in a directory. The API follows a typical POST and GET Method.

Next Steps

Start building your NFTs! Join Filecoin's Hackathon and showcase your NFT projects, win prize money.

https://hackathons.filecoin.io/

Continuing Education

Listen to Patrick Collins, developer advocate at Chainlink explain securing blockchain oracles on Decoded Podcast.

Video Tutorial

Tech Stack to build your crypto, NFT or Apps

sydneylai — Wed, 05 May 2021 16:34:05 +0000

Tech Stack to build your crypto, NFT or Apps

Pick a blockchain protocol

You've heard of it. You want it. You have some. How are NFTs and crypto built? These web3 (blockchain) and decentralized applications are built on an architecture that is alien from what I've learned in my classic developer bootcamp.

I'll provide an intro to beginner tools you can use to get started. We will focus on the Ethereum protocol (there are many others) as it's the main protocol that crypto (built on ERC-20), dApps (decentralized apps) (built on ERC-20), and NFTs (built on ERC-721, ERC-1155) are built on. The adoption rate for the Ethereum protocol is staggering in comparison to other protocols, with 3000+ applications and overall Q1 NFT sales for 2021 topping $2B.

(Growth of Ethereum)

What's the same compared to traditional programming

Compared to traditional programming, testing and integration are reasonably similar. The languages used are the same in addition to Solidity, an object-oriented programming language for writing smart contracts. The languages a developer should be familiar with are C++, Python, and JavaScript.

What's different compared to traditional programming

Deployment is very different, and because the blockchain is immutable, every time you deploy it's permanent. A developer will need to audit code to ensure the security of code and certainty. Therefore data storage and maintenance differ as well.

One important difference compared to traditional development is that the data with which the contract interacts must already be on the blockchain.

To inject data onto the blockchain requires an oracle, which allows other contracts to consume it. An oracle must be secure or vulnerabilities will be exposed and attacked.

If the oracle is faulty or compromised, the Chainlink SDK can be used as a network of nodes that provide data and information from off-blockchain sources to on-blockchain smart contracts via oracles.

"Instead of calling an API to your backend, it's going to call an API to the blockchain and it's going to read off whatever the state of that blockchain is. It's going to be a different environment just because you don't have the kind of ownership of your smart contracts on your backend as you do in the traditional sense." - Patrick Collins, Developer Advocate at Chainlink

Listen to a Patrick Collins explain securing oracles on Decoded Podcast [Spotify]

Tools for Web3 Developers (Build an app or crypto)

Frameworks

Truffle - Most popular smart contract development, testing, and deployment framework. The Truffle suite includes Truffle, Ganache, and Drizzle.

Hardhat - Flexible, extensible and fast Ethereum development environment.

OpenZeppelin SDK - A suite of tools to help you develop, compile, upgrade, deploy and interact with smart contracts.

Brownie - Brownie is a Python framework for deploying, testing, and interacting with Ethereum smart contracts.

Bootstrap/Out-of-Box tools

Truffle boxes - Packaged components for the Ethereum ecosystem

Communicating with Ethereum

dfuse - A TypeScript library to use dfuse Ethereum API

Resources

Ethereum Stack Exchange - Post and search questions to help your development life cycle.

MetaCartel 💰 - If you have a project built on Ethereum and need $5K - $10K in developer grants, you can apply here or any Q&A DM here

Optional Build for Web2 Developers (Build an app)

OutSystems full-stack platform for the development of mobile and web enterprise applications, which run in the cloud, on-premises, or in hybrid environments.

If the web3 stack set-up is too complex and you want something up and running you can build as a solo dev with OutSystems, a developer platform that allows you to build web and mobile applications on the enterprise level. This allows you to quickly build a full-stack application regardless of your framework, as long as you know basic application architecture.

Here's a video where I will walk you through how to connect a database, manage dependencies for plugins, and replicate a full-stack build of a mobile wallet to hold your ETH and various tokens. This app is easy to build with the OutSystems developer platform and you will have yourself a super sweet personal wallet!

What you will learn:

Introduction to rapid development for mobile
How to quickly build applications with developer tools
Walkthrough of how to create API integrations in-app with AI scripts
Introduction to ERC20, wallets, and other blockchain token protocols
Enjoy the ease of building and implementing your own private wallet

Building NFTs

OpenSea SDK - A peer-to-peer marketplace for rare digital items. Buy, sell, auction, and discover collectibles.

ERC-721: “Single” if you want your collectible to be one of a kind
ERC-1155: “Multiple” if you want to sell one collectible multiple times

Blockchain for all

Building applications (crypto, NFT, dApps) on blockchain is becoming more accessable and there are various ways for developers of all skill levels to get started. Feel free to reach out on Dev.To or Twitter if you need any help! 👋

Extra Content

Listen to Patrick Collins, developer advocate at Chainlink explain securing oracles on Decoded Podcast.

A quick look at Slack's Webhook Logic Flow

sydneylai — Wed, 24 Feb 2021 19:02:33 +0000

Slack Webhook logic flow illustrated with OutSystems

Purpose: To show the Slack webhook logic in a dashboard integration
For: Devs familiar with OutSystems's dev platform
Listen: Podcast interview with software eng on how Slack was built
Ask for help: OutSystems Forms (2 Hour Response Time)
Written by @sydneylai

📝 Where do I start?

Step 1: Have an app to integrate with

Can use a template Download OutSystems
Try the incident reporting ticketing dashboard

Step 2: Create a Slack Incoming Webhook

This is the most common integration, where you have your webapp Slack you a message when an action is triggered.

https://api.slack.com/messaging/webhooks

Find your specific token and Hook URL

Step 3: Use a Slack Integration - a Forge Component

Install
https://www.outsystems.com/forge/component-overview/5381/slack-integration

💡 Hint: The way the dev decided to write this component, the token is hard-coded so this means you should create a dynamic token to allow posts in various channels.

Step 4: Logic Flow Explained

See how the Issue Tracker dashboard communicates with Slack's Inbound Webhook

(Zoom In) On the left is the Logic Flow and right is the folder structure of containing the logic in the app, which includes server-side actions, functions, as well as REST and SOAP integrations

At the Start of the logic flow, the user is assigning a ticket status. After the ticket is created, the Server Action or Action that runs logic on the server side, assigns a ticket ID and a ticket is created.

The request is then sent to Slack

Assign a Request

Run a Server Action

Result

BONUS: OutSystems Resources

Features	Tutorials
Chatbot Build	🔗
Join Dev community	🔗
Apply for free developer school	🔗
How To Videos	🔗

Slack Specific

Features	Tutorials
Podcast on how Slack was built	🔗
Blog post on interview with Slack eng	🔗
Video on Slack Logic Flow	🔗