Soulbound Token

For over half a decade I have been warning about blockchain and more specifically, smart-contracts! And here is why (this might be a long article for many, but please read it. Your future depends on it).

Soulbound Token (SBT).

Vitalik Buterin, the inventor of the Ethereum Blockchain and cryptocurrency network has proposed a new token called Soulbound. This is not just some guy proposing a new type of NFT crypto-blockchain token, this is THE guy that INVENTED smart-contracts and NFTs! Just about every single industry and agency in the world uses his smart-contracts network and protocols, including SingularityNET AI and other AI systems.

In fact, the Great Reset, the 4th Industrial Revolution and even the Green New Deal (which is based on carbon credits) is not possible without his invention. Period! Ethereum is second only to Bitcoin in market value and usage! When this guy speaks, in the crypto world, the earth shakes! And he’s about to shake the earth even more with the Soulbound token!

WHAT ARE NFTs?

Before I begin, let me explain in simple terms what NFTs are. NFTs are non-fungible tokens. Meaning they are tokens that give digital content a unique ID that can be traded and not copied. NFTs represent and track the ownership of real-world or virtual assets like land, digital art, and in-game items on the blockchain. It can also be used to do the same with any digital or tangible item on the planet.

WHAT ARE SOULBOUND TOKENS?

SBT works like a real-life achievement badge, reward or bonus similar to what you get in a video game to complete a specific quest or pass an important milestone. But instead, get these badges to bring your character up to max level.

In other words, users holding soulbound tokens will not be able to trade and transfer that Token to others. This token acts as an identifier that asserts ownership and is proof that the holder obtained this Token through a recognized activity, and not by buying “hands-on” from someone else.

Soulbound tokens are a special form of NFT built on top of a blockchain 2nd Layer Protocol (which even Bitcoin has). Normally, NFTs are designed to be transferred between different blockchain wallets (usually on your mobile device). Soulbound tokens are designed to be permanently held by a special type of blockchain address called a Soul.  These soulbound tokens will represent certain information about YOU the OWNER of the Soul account.  For example, a user might have a Soul devoted to holding identity documents (driver’s license, passport, medical records, vaccination records, etc.), another one holding login credentials for professional accounts, social media, banking, Web 3.0, etc., and a third for other information.

By demonstrating ownership of a particular Soul, a user demonstrates that they have certain attributes.  For example, during a job interview, a user may prove their credentials by proving ownership of soulbound tokens that encode diplomas, professional certifications, employment history and other relevant credentials.

One of the primary purposes of soulbound tokens is to provide identification for the person behind a Soul address.  If a user can perform recognized “actions” with a Soul address, then they are presumably the owner of that address, and all of the identifying information associated with that account belongs to them.

A user may be required to prove their identity or demonstrate a “good reputation” in order to gain access to goods and services. According to Vitalik Buterin’s original proposal, this would be accomplished by tying a Soul address to a proof-of-humanity profile, Ethereum Name Service (ENS) name, or other attribute that a user cannot or is unlikely to sell.

The paper defines SBTs as non-transferable tokens “representing commitments, credentials, and affiliations.” Think of a soulbound token as a tokenized version of your “social identity,” ranging from your accomplishments to your financial credit reputation, your carbon footprint, your social credit and more. These are some of the traits that make you who you are as a person. In that sense, SBTs are more complex than NFTs since they represent what makes a person rather than what they own. According to the paper, SBTs will bring social identity to Web3.

HOW DO SOULBOUND TOKENS WORK?

SBTs will initially be publicly visible, and issuers could have the power to revoke them if they so choose. The tokens will be stored in wallets called souls, held by Decentralized Society (DeSoc) participants comprising of individuals, companies, and institutions.

SBTs can be self-certified, similar to how you share your resume/CV with others claiming that you have a list of particular skills and you’ve accomplished several things.

On the other hand, they can be verified by others, meaning that someone issues you with SBTs confirming you’ve achieved something. For instance, a university can issue its graduates with SBTs verifying that they’ve completed a course and acquired a specific GPA. Once a graduate receives these SBTs, they’re non-transferable because they represent unique accomplishments that are specific to one individual. This is different from NFTs, which are transferable from one person to another.

According to the paper, Soulbound tokens will make it easy to verify the authenticity of a piece of work that an artist has created or more generally, any piece of work that has been created by its creator. The SBTs would enable an “interested party” to trace the social provenance (origin) of the soul that issued the art. As a result, they can discover the social identity of the soul, namely their credentials, memberships, and affiliations.

WHY IS THIS DANGEROUS?

In a new world, living under the guise of climate change, everyone will be required to have their carbon footprint monitored and reduced. Everyone will be given personal carbon-credit allowances that will ration their energy and carbon consumption, unless they are able to buy carbon-credit offsets.

In order for this to be achieved, everyone will have to have a global ID on the blockchain. You’ll be highly connected to the global matrix via surveillance devices and biometric sensors. Each person will have to be identified and authenticated.

Once your carbon-credit is exhausted, you’ll have to either buy more credit or perform social activities that reward you credit, in a circular reward-based economy.

Your wallet, which resides (for now) on your phone, will be the interface that hooks you into society. If you want to interact with anything in society, including access to goods and services, you will have to authenticate yourself. The new Web3 will be the network which will identify you, via your soul token.

In the code I’ve added below (which I found as a sample proposal), you can easily be blacklisted or denied transactions if you do not meet certain criteria. For example, if you are not up to date on your vaccinations, you may become blacklisted and instantly, be cutoff from all goods and services globally! If your social credit is below a predetermined threshold, you can be denied services or goods (from a supply chain tied to blockchain), until you are able to show, via performance metrics, validated by your soul contract, that you have conformed and regain access to goods and services. And keep in mind that this would all be done autonomously by the network algorithms, AI and not need human monitoring!

So, for example, say you failed to pay your rent, mortgage or car payment. You will be blacklisted and not be allowed to buy anymore goods or services until you make your payment. Did you buy some marijuana? Good luck trying to buy some bread at the food mart. Did you voice your opposition on some social media site? Well good luck being allowed on public transportation for 30 days. Did you fail to get your booster shot? Goodluck trying to walk around town without having the electronic billboards shaming you publicly and pedestrian’s phones sounding an alarm. You will be publicly shamed into compliance, as is done in China. The punishments (lack of rewards) are unlimited in this beast AI system. Are you beginning to see my drift?

Your smartwatches, pedometers and monitors for heart rate, wearing sensors, your Amazon Doorbell Ring, your Alexa, your Echo devices, your phone cameras, public cameras, your bluetooth and Amazon Sidewalk, your smart meters, your pet robots, your smart tools and appliances, your autonomous vehicles, drones, satellites and so much more will be watching you and scoring your behaviors. All of your actions, will be assessed and scored and added to your soul profile. Basically said, there would be nothing that you or your child will do that will not be detected, evaluated and tabulated onto the global blockchain for the world to measure you by! Your soul will be on full display, for rewards and punishments.

All in the name of saving our earth and building back better. Complete social re-engineering! But we know this will not be the case for the wealthy class who will be exempt from these measures, simply because they can buy their way out by accumulating or buying carbon-credits since they’ve bought all of the land and resources.

And after most physical assets have been removed from us (for the sake of perserving mother earth) we will be launched into the metaverse, where there is not a single action that does not get recorded into a blockchain-database.

You’ll be working there, gathering socially and conversing there, performing finances, buying and trading goods and services, taking vacations there, watching movies and playing online games, taking educational courses, and much more! Every bit of your actions will be recorded and scored and placed in a profile for the world to see, and thusly reward or punish you.

Your privacy will be completely lost and you basically will be living in digital serfdom. Our new world will literally become the new dark-ages, only this time with peasants carrying mobile phones and hi-tech smart gadgets, living on rationed goods, eating bugs, fake meat and GMO products using state sponsored good-behavior credits.

This is the danger of universal basic income, universal ID, universal central bank digital currencies and unviersal soul (data) snatching.

Is this the future you want? If we do not start voicing out loud about these dangers, we will find ourselves locked into a system that would be crushing to freedom and liberty, for ages!

---

Sample code proposal and demonstration
Solidity-SBT-Soul-Bound-Token (using Ethereum Blockchain):

const { expect } = require('chai');
const { ethers } = require('hardhat');

describe('SBT', function () {

  before(async () => {
    [owner,user1,user2,user3] = await ethers.getSigners();
    const SBTContract = await ethers.getContractFactory('SBT');
    sbt = await SBTContract.deploy('Test SBT Token', 'SBT');
  });

  it('Should return the name and ticker', async function () {
    expect(await sbt.name()).to.equal('Test SBT Token');
    expect(await sbt.ticker()).to.equal('SBT');
  });

  it('hasSoul should return false for new query', async function () {
    expect(await sbt.hasSoul(user1.address)).to.equal(false);
  });

  it('Should mint a new soul', async function () {
    const soul = ['James Bachini', 'https://jamesbachini.com', 99, new Date().getTime()];
    await sbt.mint(user1.address,soul);
  });

  it('hasSoul should return true', async function () {
    expect(await sbt.hasSoul(user1.address)).to.equal(true);
  });

  it('getSoul should return the correct identifier', async function () {
    const soul = await sbt.getSoul(user1.address);
    //console.log(soul);
    expect(soul[0]).to.equal('James Bachini');
  });

  it('Operator should be able to update soul', async function () {
    const soul = ['James Bachini', 'https://jamesbachini.com', 80, new Date().getTime()];
    await sbt.update(user1.address,soul);
  });

  it('getSoul should return the updated value', async function () {
    const soul = await sbt.getSoul(user1.address);
    //console.log(soul);
    expect(soul[2]).to.equal(80);
  });

  it('User should be able to delete their data', async function () {
    await sbt.connect(user1).burn(user1.address);
  });

  it('hasSoul should return false after delete', async function () {
    expect(await sbt.hasSoul(user1.address)).to.equal(false);
  });

  it('hasProfile should return false', async function () {
    expect(await sbt.hasProfile(user1.address,user2.address)).to.equal(false);
  });

  it('Should mint another soul for user2', async function () {
    const soul = ['Alice Smith', 'https://github.com', 42, new Date().getTime()];
    await sbt.mint(user2.address,soul);
  });

  it('3rd party should be able to create a profile', async function () {
    const soul = ['Alice', 'https://google.com', 92, new Date().getTime()];
    await sbt.connect(user1).setProfile(user2.address,soul);
  });

  it('getProfile should return profile', async function () {
    const soul = await sbt.getProfile(user1.address,user2.address);
    expect(soul[2]).to.equal(92);
  });

  it('hasProfile should return true', async function () {
    expect(await sbt.hasProfile(user1.address,user2.address)).to.equal(true);
  });

  it('listProfiles should return profile addresses', async function () {
    const profiles = await sbt.listProfiles(user2.address);
    expect(profiles[0]).to.equal(user1.address);
  });

  it('User should be able to delete their profiles data', async function () {
    await sbt.connect(user2).removeProfile(user1.address,user2.address);
  });

  it('hasProfile should return false after removal', async function () {
    expect(await sbt.hasProfile(user1.address,user2.address)).to.equal(false);
  });

  it('burn should remove all profiles too', async function () {
    const soul = ['Bob Smith', 'https://ethereum.org', 37, new Date().getTime()];
    await sbt.mint(user3.address,soul);
    await sbt.connect(user1).setProfile(user3.address,soul);
    expect(await sbt.hasProfile(user1.address,user3.address)).to.equal(true);
    await sbt.connect(user3).burn(user3.address);
    expect(await sbt.hasProfile(user1.address,user3.address)).to.equal(false);
  });

});

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

/**
 * An experiment in Soul Bound Tokens (SBT's) following Vitalik's
 * co-authored whitepaper at:
 * https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4105763
 */

contract SBT {
    struct Soul {
        string identity;
        // add issuer specific fields below
        string url;
        uint256 score;
        uint256 timestamp;
    }

    mapping (address => Soul) private souls;
    mapping (address => mapping (address => Soul)) soulProfiles;
    mapping (address => address[]) private profiles;

    string public name;
    string public ticker;
    address public operator;
    bytes32 private zeroHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
    event Mint(address _soul);
    event Burn(address _soul);
    event Update(address _soul);
    event SetProfile(address _profiler, address _soul);
    event RemoveProfile(address _profiler, address _soul);

    constructor(string memory _name, string memory _ticker) {
      name = _name;
      ticker = _ticker;
      operator = msg.sender;
    }

    function mint(address _soul, Soul memory _soulData) external {
        require(keccak256(bytes(souls[_soul].identity)) == zeroHash, "Soul already exists");
        require(msg.sender == operator, "Only operator can mint new souls");
        souls[_soul] = _soulData;
        emit Mint(_soul);
    }

    function burn(address _soul) external {
        require(msg.sender == _soul, "Only users have rights to delete their data");
        delete souls[_soul];
        for (uint i=0; i<profiles[_soul].length; i++) {
            address profiler = profiles[_soul][i];
            delete soulProfiles[profiler][_soul];
        }
        emit Burn(_soul);
    }

    function update(address _soul, Soul memory _soulData) external {
        require(msg.sender == operator, "Only operator can update soul data");
        souls[_soul] = _soulData;
        emit Update(_soul);
    }

    function hasSoul(address _soul) external view returns (bool) {
        if (keccak256(bytes(souls[_soul].identity)) == zeroHash) {
            return false;
        } else {
            return true;
        }
    }

    function getSoul(address _soul) external view returns (Soul memory) {
        return souls[_soul];
    }

    /**
     * Profiles are used by 3rd parties and individual users to store data.
     * Data is stored in a nested mapping relative to msg.sender
     * By default they can only store data on addresses that have been minted
     */
    function setProfile(address _soul, Soul memory _soulData) external {
        require(keccak256(bytes(souls[_soul].identity)) != zeroHash, "Cannot create a profile for a soul that has not been minted");
        soulProfiles[msg.sender][_soul] = _soulData;
        profiles[_soul].push(msg.sender);
        emit SetProfile(msg.sender, _soul);
    }

    function getProfile(address _profiler, address _soul) external view returns (Soul memory) {
        return soulProfiles[_profiler][_soul];
    }

    function listProfiles(address _soul) external view returns (address[] memory) {
        return profiles[_soul];
    }

    function hasProfile(address _profiler, address _soul) external view returns (bool) {
        if (keccak256(bytes(soulProfiles[_profiler][_soul].identity)) == zeroHash) {
            return false;
        } else {
            return true;
        }
    }

    function removeProfile(address _profiler, address _soul) external {
        require(msg.sender == _soul, "Only users have rights to delete their profile data");
        delete soulProfiles[_profiler][msg.sender];
        emit RemoveProfile(_profiler, _soul);
    }
}

Functions:

function mint(address _soul, Soul memory _soulData) external;
Function called by the operator (contract owner by default) of the contract to mint a new token. The new token associates the Soul data structure with a users wallet address

function burn(address _soul) external;
Allows a user to destroy any data stored about their wallet. Effectively burning their soul, which doesn’t sound great admittedly.

function update(address _soul, Soul memory _soulData) external;
Operator can update the data at any point but does need to provide a complete data set and can’t currently increment a single integer within it for example without additional code.

function hasSoul(address _soul) external view returns (bool);
Checks if a sole has been minted and exists for a specific wallet address. Returns false prior to mint and true after.

function getSoul(address _soul) external view returns (Soul memory);
Public view function to receive all the Soul data for a specific address. No privacy here at all on a public blockchain.

function setProfile(address _soul, Soul memory _soulData) external;
A profile is a 3rd party data structure which is mapped to msg.sender and an address provided. This allows anyone to store data in the same data structure including the individual user.

function getProfile(address _profiler, address _soul) external view returns (Soul memory);
Public view function which returns the soul data for a set user relative to the profiler which is the address that called setProfile.

function listProfiles(address _soul) external view returns (address[] memory);
We store the profiles set up for each address in an array so they can be burnt later. listProfiles provides this list of data profiles for a user. This would also be useful for things like course levels where a separate profile certificate could be minted for each completed stage of the course.

function hasProfile(address _profiler, address _soul) external view returns (bool);
Returns true or false if a profile exists for a specific address and profiler address.

function removeProfile(address _profiler, address _soul) external;

User has the right to remove any profiles attached to their account.

So under the threat of “climate disaster”, you will be feeding your “soul” to the AI “beast” system, literally!

If this does not scare you, then you need to read this post again!