Mostly Software

  • Tuesday

    • Deployed my candy machine v2 app: https://sol-candy.vercel.app/
    • Art and Sean bought me mahlstedt.sol on bonfida 🙂
    • Still trying to build a simple app with the solana wallet js libs.
      • The module “patch-package” is pretty great; modify node_modules in a persistent way to have control of third-party deps.
        • Patched cipher-base for stream since it’s not polyfilled anymore.
        • Then running into all sorts of adapter issues with socket.io.
      • Always always always remember yarn dlx @yarnpkg/sdks vscode when using typescript + yarn3 + vscode. And commit the resultant .vscode directory, which will then autoprompt other users in vscode when cloning the repo.
      • @toruslabs/base-controllers tried to access @babel/runtime (a peer dependency) but it isn’t provided by its ancestors; this makes the require call ambiguous and unsound. Ancestor breaking the chain: @solana/wallet-adapter-torus@npm:0.11.11
      • Deleted ~/.yarn by accident (not the .yarn in a project dir) so had to wide the node installed, updated to 16.14 in nvm and downgraded yarn to 2. yarn set version X in a package modifies it only for that package (adds to .yarn/releases and points in yarnrc).
      • Wallet adapter started working when I downgraded from yarn 3 to 1. @solana/wallet-adapter-torus has unmet peer dependency @babel.runtime@7.x. This became a warning, not an error.
    • Played a bunch with @solana/wallet-adapter*. Built a test UI. Used tailwind and postcss.
    • Magic Eden raise 27m in a series-A from paradigm, sequoia, solana ventures, greylock, electric, others.
    • Motion for permanent DST.
    • I’ve been think about tokenomics as fungible x<ASSETS> but I guess the proper word established by the community is synthetics.
      • Example: receive SOL in an escrow, give that person sSOL (for synthetic SOL, just an example). They can trade it back 1:1 at any time, but have liquidity in the meanwhile (or, alternatively, you can grow sSOL in VALUE instead of quantity, and make it not 1:1 swappable).
      • This is how yield is achieved in vaults (like synthetify).
    • Went to Solana happy hour, hosted by metaplex/bridgesplit/serum/phantom.

  • Monday

    • Gitlab q4 earnings, expected 70.3m, got 77.8. https://ir.gitlab.com/news-releases/news-release-details/gitlab-reports-fourth-quarter-and-full-year-fiscal-2022.
    • GPDR compliance for websites getting EU traffic.
    • The “Solana dApp Scaffold Next” template repo is pretty good.
      • Wallet integration, state management, notifications, examples.
    • _app and _document to override the default next app and document, of course. Not necessary, can just have a single index home page. But if you want context managers for diff pages, global css, document html tags, etc – customize these.
    • 100000010 = 258 in decimal = Ă in ascii tables (utf-16, of course barely too big for utf-8). 1m inflow and 10% growth, every year.
    • Looked into digital business cards. Some with QR code, some with photo/email/etc. No obvious market leader. Mobilo offers a (paid) card, HiHello and Blinq look to be free apps.
    • Went to Solana Hacker House. Kickoff day. Work section, food/drink, recruiting section, stage, merch store, NFT gallery, standing social section, massage, lounge.
    • Carta’s report of first-funds from 2021: https://carta.com/blog/fund-i-report-2021-year-in-review/.
      • 3.9b on carta total in 2021 for first funds.
      • No clear standout for first-fund size. Pretty spread. Funding comes in all sizes.
      • Most popular location: CA. Miami got a big relative jump in 2021 though.
    • Programmed NFTs.
      • They have triggers. Maybe it’s a trigger from the owner (eg transfer), or a trigger from an event (eg sports outcome).
      • Cardinal (solana) is big for this – can revoke, expire, transfer to beneficiary, many.
      • A prime example: royalties. These are enabled by the programmability of NFTs. You can do anything else possible with contracts/programs.
    • Squads.
      • https://squads.so/.
      • Multisig vaults. Start with the DAO use case. Imagine having 10 individuals with hot wallets who want to start a company together. You don’t want a single person to have control, you don’t want to write infra yourself to manage this. Just create a Squad and it will set up a vault and you can control which addresses have which percentages, what quorum is needed for change. Gives in-platform voting, etc. Lots of integrations for anything you might want to do with a collection of accounts.
      • Gnosis is biggest on eth: https://gnosis.io/.
    • Flipside looks to be a bounty program? https://flipsidecrypto.xyz/.
    • Cogni is a banking app for digital assets: https://getcogni.com/.
      • Not sure the differentiator. Is this just a custodial wallet?
      • Plus a credit line, it looks like.
      • And a streaming enabler, allowing direct deposit into the account.
    • Katana is a solana protocol for yield vaults. https://katana.so/.
      • Passive yield is generated from price action strategies (eg covered calls, put sells, etc), not liquidity mining. The vault runs a strategy actively so you don’t have to.
      • Most projected APYs are ~25%.
    • Rove. Like BAT, but for the entertainment industry. As a consumer, you earn for consuming. As a producer, you collect portions for use.
      • https://rove.live/.
      • Single ROVE token for all, just like basic attention token. Not a specific token, like earning BB for watching breaking bad or something.
      • Then ROVE is used as an economy for music labels, film studios, concert halls, sports arenas, etc. Access for all types of entertainment.
      • Integrated with Moonpay. Single click. Don’t have to be a developer, and don’t have to know crypto.

  • Sunday

    • Coinbase One is in beta; monthly subscription, 0 trading fees.
    • Daylight time started last night, lost 1hr of sleep.
    • Installed a few more vscode extensions: rainbow brackets, error lens, markdown all in one. All great. Easier to identify bracket pairs. Inline error details. Easy md.
    • Upgraded npm to yarn3 globally. yarn set version stable (1.22.17 -> 3.2.0). yarn create next-app –ts (no dash after create).
      • Yarn dlx = temp environment (doesn’t add the package to package.json deps or anything).
      • Add zipfs vscode extension as well; inspect archives.
      • yarn dlx @yarnpkg/sdks vscode <- remember to run this in general for typescript in vscode. Allows you to set the ts version to the workspace version.
      • Next, index.tsx corresponding Home.module.css, reactStrictMode in next.config.js.
    • If you open the vscode command palette (ctrl-shift-p) and search for language, you can find the language specific settings interface, which shows the full list for options like:
      • “[javascript][javascriptreact][typescript][typescriptreact][html][css][json]”: { “editor.tabSize”: 2 }
    • Vertical align text in bigger div or p or whatever, use display:flex and flex-direction:column with justify-content and align-content: center.
    • Played with material-ui themes and styled-components.
    • Can use next.conf.js to load env vars (rather than import dotenv).
    • Wrote solana nft dapp, and general solana dev dive.
      • Remember magic eden is a secondary market (and opensea for eth ofc). My apps allow users to connect their markets and mint directly. Candy machine.
      • On ETH, you’d write your own contract and inherit from ERC721 and deploy then call the mint function you wrote. Metaplax is different. It’s a contract-as-a-service, basically. ~1300 lines: https://github.com/metaplex-foundation/metaplex-program-library/blob/master/candy-machine/program/src/lib.rs. And remember, it’s async, unlike eth.
      • If the user has the phantom browser extension, it will inject the “solana” object into the window just like metamask does for the “ethereum” object. global declaration of window interface extension with solana:any for ts.
      • solana.connect({ onlyIfTrusted: true }) for initial load. This is the same as autoconnect. If they’ve trusted this site before, will autoconnect, else (don’t pass that param) it will prompt.
      • Already have the solana cli from when I made briancoin.
      • Install the metaplex cli. Right now from source: https://docs.metaplex.com/candy-machine-v2/getting-started.
      • Load the raw NFTs into an assets folder. Each NFT has a pair of json and png, the image itself and metadata (similar to the eth nft metadata jsons). You then pass this to metaplex which will handle it.
      • Uploaded to arweave (https://www.arweave.org/) instead of ipfs. Just another decentralized store. Very cheap storage, metaplax currently pays for it (not your wallet). Stores permanently.
      • solana-keygen new, solana config set, solana config set –url devnet, solana balance, solana airdrop 10
      • config.json in root of project to configure candy machine. Price, total, goLiveDate, storage (arweave), etc.
      • Then just call metaplex. Takes your local assets folder, uploads to your storage location, then pushes your NFT configs onchain to metaplex’ contracts (whichever network you’ve chosen).
        • ts-node ~/metaplex/js/packages/cli/src/candy-machine-v2-cli.ts upload -e devnet -k ~/.config/solana/devnet.json -cp config.json ./assets/
        • The “candy machine” is basically your custom contract that extends metaplex. This command will spit out an address for your candy machine. You can look it up on solscan, as expected.
        • If you change the NFTs (png or json), delete the .cache folder before re-uploading.
      • Other candy machine commands: upload, verify_upload, update_candy_machine (config).
      • Here’s an example app to interface with your onchain candy machine: https://github.com/metaplex-foundation/metaplex/tree/master/js/packages/candy-machine-ui. You may extract components from here into your custom ui.
        • All you to connect an off-the-shelf UI component with your deployed candy machine is its ID.
      • The compiled artifact is an IDL, like solidity’s ABI output. you fetch this when your candy machine (onchain contract) changes.
      • “program” = “smart contract” in eth, the object to interact.
      • Remember solana programs are stateless, unlike ethereum.
      • I’ve just seen candy machine copy-pasted from the metaplex repo and altered everywhere. Why isn’t there an extremely thin wrapper npm module yet that just takes a few arguments (network, sender address, etc) and provides a mintNFT method yet??
      • Scrapped my custom UI (cobbled together from a few places) and baselined from candy-machine-ui. It’s ts, but only react not next. I’ll still vercel deploy when done.
      • gatekeeper is for captcha.
      • Ok, found a small wrapper, let’s try that: https://reactjsexample.com/ui-frontend-in-react-for-solana-candy-machine-nfts/. Only 8 stars on github. This one worked though.
      • There are a few other candy machine wrappers on next.js, but none current; seems all were CMv1.
      • Figment, questbook; these platforms offer tutorials comparable to buildspace.
      • Went through The Anchor Book a bit: https://book.anchor-lang.com/. On solana, anchor=hardhat.
      • Great (and entertaining) summary of solana: https://2501babe.github.io/posts/solana101.html. “the basic operational unit on solana is an instruction. an instruction is one call into a program. one or more instructions can be bundled into a message. a message plus an array of signatures constitutes a transaction”
      • A lot of articles echo my sentiment after day 2 solana dev: fantastic cli tools, not so great clientside experience.
      • Soldev, central place for solana development resources: https://soldev.app/. Links to the primaries like solana’s docs, metaplex docs, etc.
      • Primary js libs: web3.js, wallet-adapter-*, spl-token.
      • System owned accounts, and program derived accounts.
      • Few categories of programs: native programs (eg code to run validators), solana program library (SPL, eg creating custom tokens), and standard programs (you can deploy).
      • Solana cookbook: https://solanacookbook.com/. Like the docs, but a bit simpler / highlevel.
      • SPL docs for tokens, memos, name systems, more: https://spl.solana.com/.
      • Full solana docs: https://docs.solana.com/introduction. Developing, running a validator, adding to an exchange, architecture deepdives, more. Everything. Even some economics, and lists of improvement proposals.
      • Metaplex docs: https://docs.metaplex.com/.
        • Gumdrop for cheap bulk airdrops with whitelisted users.
        • Auction House. You can create an auction with your token and allow users to be, all contracted onchain.
        • Storefront is like a UI for candy machine. Allows you to create, mint, auction, show the NFTs, etc.

  • Saturday

    • Verifying an already-deployed contract is not a 60-second operation. Tried recompiling (local hardhat and remix), pulling same bytecode/abi, using https://abi.hashex.org/ so etherscan knows the constructor params, more.
      • Ended up redeploying the contract (after a few small aesthetic fixes) and then verified with the source code.
      • https://rinkeby.etherscan.io/address/0x04bff901e21db5af22025df43808655d07b28485#code
    • Remember engine-strict:true in .npmrc and engines: node: X in package.json to enforce node version.
    • Already had solidity vscode extension, but added solidity+hardhat today to test out the hardhat features.
    • Played with remix a little more.
    • Sirloin is the whole region. Top sirloin is better than bottom sirloin. Then there’s the front of the sirloin, or short sirloin. That’s where strip steak comes from. Strip steak === strip loin === shell steak === new york strip.
    • Dialect, solana onchain messaging: https://www.dialect.to/.
      • Tested it, looks like only onchain messaging supported. Sent a few chats between test accounts.
      • Messages (be they chats, notifications, professional deals, etc) are not at the top of the list to go onchain. Contracts are for deterministic, public, decentralized state machines. Like currency ledgers, transactional agreements, etc. Chats are not deterministic, not public, not decentralized.
      • Devil’s advocate: There’s the notion that your wallet is your identity. The biggest manifestation of that right now is your ability to exchange value with the world (that’s why it’s called a wallet). But ultimately your identity is a ledger of much more than that. Communication is a big piece of this. Being able to communicate with someone, knowing nothing else about them, seems to be a very real future in our current direction.
      • js sdk: @dialectlabs/protocol. createDialect, sendMessage, etc. https://github.com/dialectlabs/protocol.
    • Signed up for miami solana hacker house.
    • Checked out solanapay: https://github.com/solana-labs/solana-pay/tree/master/core. Most of the value in the hardware/integration? Else just transact directly.
    • Web3 social media platforms.
      • Aave has Lens; that’s the only one I really know.
      • Expect this space to have growth.
    • Started more solana dev.
      • Anchor = hardhat.
      • @solana/web3.js = web3.js.
      • Many different libs to interface with wallets. @project-serum/anchor has one, @solana/wallet* has a bunch.
      • solana-dapp-next is a starter framework that extends create-next-app with solana features like wallet integration and such.
    • Remember G Suite is now called Google Workspace (not recent, happened in 2020).
      • Only a few dollars per user per month. https://workspace.google.com/pricing.html.
      • Access to all g applications (gmail, drive, meet, calendar, chat, docs, sheets, slides, keep, etc) with custom, business-domain email. Perks in the apps too (eg you can record google Meet).
    • Some random web revisits. Css flexbox, redux-persist to actually store data instead of just session state, useSelector/useDispatch, more.
    • dYdX: https://dydx.exchange/.
      • DEX for perpetuals.
      • Not avail in united states.
      • Fees (<$1m): 0.02% maker 0.05% taker.
      • L2.
    • Played with heroku. Remember owned by salesforce. Offers many of the expectations of a cloud platform on top of a virtualized and/or containerized infra layer (compare to digital ocean and ec2).
      • Dynos = containers. You provide the start command in your procfile. $25/mo for a basic dyno.
      • Connected to source, gitops with autodeploys from branches mapped to envs.
      • Manages certs. You can provide domains.
      • Configuration (env vars and such) is defined in heroku (not in git source).
      • Shows logs and metrics.
      • Tons of available add-ons; eg managed postgres. https://elements.heroku.com/addons.
    • WalletConnect.
      • https://walletconnect.com/ is down, https://docs.walletconnect.com/ is down, verizon/mcafee reporting malicious.
      • Pops up a QR code that you can scan from another wallet, for easy integration. The dapp can then just support walletconnect. Primary wallets supported: metamask, math wallet, trust wallet. Primarly eth, of course.

  • Friday

    • Stripe supports crypto now.
    • NFT dApp. Lots of finishing touches.
      • Added footer with link to OpenSea collection.
      • Used alertify for cleaner notifications.
      • Rearranged the effect hooks and event listeners.
      • Overflow auto.
      • I didn’t add royalties, but they’re not hard: EIP2981 is the standard https://eips.ethereum.org/EIPS/eip-2981.
      • Used block.difficulty and timestamp for pseudo-rng in the contract, since pure is not possible.
      • Disabled Mint button after click.
      • Transaction and opensea link shown back to user.
      • Added animated loader for Minting.
      • Restructured to make the conditional renders a lot cleaner.
      • Added a footer link to the rinkeby faucet.
      • Wallets are usually pretty good about estimating gas, but about a quarter of my mints were failing. Just pass a custom gasLimit in the dapp call to the contract. It will return whatever is not used to the user, this just sets the ceiling.
        • I set it to { gasLimit: 10000000 } which on Rinkeby right now is 0.015 eth. This limit you define in the app directly corresponds to the “max fee” and such that you see in metamask prompts.
      • Made a and a:visited lighter to jive with dark background.
      • Started migrating from react to next, but left it alone. Third-party dep (alertify) uses document and was breaking ssr, and I didn’t want to mess with it (beyond simple next/dynamic attempt).
      • Migrated from js to ts. Declared the window var any for property ethereum, and changed alertify from import to require (it doesn’t have types).
      • Added eslint. Changed require to a proper declaration alertifyjs.d.ts. Fixed other lint.
      • Deployed with vercel (don’t need next, they support a ton of templates including the basic create-react-app).
      • Didn’t verify the latest contract with hardhat, I don’t have the local bytecode anymore and don’t want to redeploy.
      • https://choppyseas.vercel.app/
    • The demands of the hackers who took nvidia data last week: disable the LHR feature (limiter) on GPUs (various geforce rtx models). It was impacting their eth mining performance. lol https://arstechnica.com/information-technology/2022/03/cybercriminals-who-breached-nvidia-issue-one-of-the-most-unusual-demands-ever.
    • Cookie Remover extension (click the cookie to remove for the current site) and Bypass Paywalls (https://github.com/iamadamdev/bypass-paywalls-chrome) on Brave.
      • Works on Bloomberg, Medium, NYT, and a ton more.

  • Thursday

    • Zkrollup L2s are getting a ton of funding, starkware is at 6b valuation.
    • Remember your Uniswap VP liquidity pool positions generate NFTs instead of fungible LP tokens (bc they’re not generic, you customize the concentration ofc). You can view these on opensea like any other. These are on whatever net you placed the position on.
      • Unstoppable domain NFT is on polygon as well.
      • Buildspace completion NFTs are on polygon as well (opensea.io, not testnets.opensea.io). They show up in your wallet in the “Hidden” tab rather than “Collected”. Or polygonscan, ERC-721TokenTxns tab.
      • What network your browser wallet is on doesn’t change this; the opensea domain does.
      • What account you see is based on what account you searched for. Your profile has a default one, but that’s not necessarily the same as your wallet default.
    • Revisited my old olympus notes and wrote another summary.
      • Sustainable liquidity is critical. Right now, we have liquidity on DEXs, but providers take their liquidity from protocol A to protocol B as soon as the rewards are better. Need a sustainable place for this, a central bank, a federal reserve. That’s olympus.
      • But don’t use fiat. First; the reserves must be crypto. Second; the reserves should be a basket of various tokens, not a single. Need diversity.
      • Ok, well that’s just a big dex. Bunch of liquidity across diversified crypto. How is olympus different? Because the protocol (treasury) owns the liquidity (POL). It can’t hop off.
      • How can liquidity providers add to the treasury? Two options: bonding and staking.
        • Option1: staking. You stake your OHM, delegating it to the treasury and adding liquidity. Then you make a % yield on the trade fees against that liquidity.
          • Well how do you get OHM? Great question. The original method was bonding (although of course, now, ohm is popular enough to swap on most markets).
        • Option 2: bonding. Anyone can buy bonds, using whitelisted (1) direct tokens or (2) liquidity tokens (pairs) – these are the tokens that make up the basket of the treasury. Why would anyone do this? They get OHM in return, at a discount. Which, again, has an APY you desire.
      • OHM moves in relation to the market, and therefore its own treasury which holds OHM, of course. And the treasury is changing in size due to bonding/staking. When the price for OHM gets too high (ie the value of whole treasury divided by number of OHM in circulation, which today is ~440m/13m=$34), the treasury mints more OHM (increasing supply) in a rebase to reduce its demand/price. This OHM is distributed to stakers. When the price gets too low (but never below the floor price, 1DAI), the treasury will buy OHM back (from the stakers, again making them money) and burn it, increasing its demand/price (reducing supply). This is called protocol-controlled-value (PVC). It’s just the ratio of (treasury value / ohm quantity). It’s how much each OHM is backed by.
      • So again, how do I make money? You stake OHM and get an APY, which is paid from liquidity mining as well as (getting newly minted ohm if the price goes up / treasury grows) or (selling ohm back to treasury if price goes down / treasury shrink). You may buy OHM on the market, or buy bonds to get it at a discount.
      • Lastly, (and orthogonal to above): your staked OHM can be sOHM (regular staked ohm) or gOHM (governance, allowing votes + DAO participation). sOHM increases in quantity. gOHM increases in value.
    • And a quick tokemak revisit. Note the APY scheme has two halves.
      • You get an APY (in TOKE) by depositing <ASSET> into that pool (controlled by tokemak, varying %s, higher when assets<toke in pool).
      • You get an APY (in TOKE) by depositing TOKE into that pool (from the liquidity mining of the pool).
    • 8.2% of US homes are valued at >=$1mil.
    • Added SVG extension to vscode; autocomplete, preview, minify, prettify.
    • RSVPed+boughtRegistry for bchan.
    • Holy hell, Intuit. 20 emails in the last 2 months from turbotax telling me to sign in and start my taxes. A reminder every 3 days, many with “early!” and “final!” terminology. Who approves this?
    • GitHub Team (not org, a collection of people and repos) provides codespaces (basically cloud ide), scm settings (protected branches, multiple reviewers, draft MRs, code owners, etc), and more CI/CD minutes beyond the free plan. Enterprise plan goes further in minutes and storage and such, provides SSO, SOC1/2 audits, SCIM users, more.
    • Remember to import the css with alertify.js.
      • import alertify from “alertifyjs”;
      • import ‘alertifyjs/build/css/alertify.css’;
    • Tokemak’s TVL right now is 1.1b (bigger than Olympus’ treasury, almost 3x). 230m of that is TOKE, 877m is assets.
    • Looked a little through npm, pnpm, and yarn. Would like to compare side-by-side with my old sx-setuptools.
      • In addition to package managers, looked a bit through lerna, yarn workspaces, and other monorepo management tools. Played with pnp.
      • Remember yarn comes with node by default starting with 16.10. Run “corepack enable” (and then “yarn set version stable” which is currently 3.2.0).
    • ConventionalComments for comment classification in MRs: https://conventionalcomments.org/.
    • Remember you can pass a second argument of [] to useEffect to make it behave like componentDidMount() but in a functional component, only rendering on first load.
    • Position changes.
      • Aave offers 0.11% APY on BAT deposits, Compound 0.13% (although +0.37% distribution APY in COMP). Both very bad, basically the same as eth and wbtc. Celsius offers 1%, but not decentralized (although they’re working on a defi arm, celsiusX: https://celsiusx.io/). Enabled collateralization, but did not leverage the position. Borrow APR is higher than deposit APY, and no partner sponsorships or anything.
      • Rebonded my DOT above the onchain minimum (160). Nominated different validators, my old selections were oversubscribed/inactive/pending. Submitted for 7 new. Right now there are 21281/22500 nominators (they need to increase max).
      • Remember LUNA on gemini is an ERC-20 token. Withdraw to metamask then bridge to the terra chain to your terra station wallet. Delegated a lot of this after.
      • Swapped DAI for OHM, add to an LP of that pair on sushi, then bonded the LP tokens on olympus (2 day vest then claim sOHM). Remember that with olympus v2, bonds are autostaked during the vesting time.
      • Deposited a large amount of DAI into its tokemak reactor (4% right now, although close to 5 based on current ratio). As TOKE rewards accumulate over the few cycles, I’ll stake it as votes for compounded APY.
    • Interesting article on the state of the median gender pay gap at the end of 2021.
      • https://www.payscale.com/research-and-insights/gender-pay-gap/.
      • All men compared to all women: 82 cents on the dollar.
      • Men compared to women with the same title, years of exp, education, industry, and location: 98 cents on the dollar.
      • My fields (tech and engineering/science) both highest rates of equality – interesting.

  • Wednesday

    • Executive order on crypto. Signed today, leaked last night.
      • (disclaimer: government bumbling along the cold trail of technology, on some congenital quest of habit, is not funny to me; it’s a waste of careers and interests and infrastructure)
      • https://www.cnbc.com/2022/03/09/heres-whats-in-bidens-executive-order-on-crypto.html.
      • Most of the order was research-based; “Here’s what we think is important, here’s what we plan to explore in the future.”
    • Remember NFTs can be used as collateral: https://www.nftfi.com/.
    • Aside from “access card” utilities, you can also boost yield with non fungible tokens. Imagine fungible tokens being staked in tiers; you get 10% if you delegate 1,000 SOL but you get 15% if you delegate 10,000 SOL. This is true in both defi and traditional finance. But you could do the same thing with NFTs. Eg: holders of this NFT get +3% APY on their deposits, holders of this NFT get access to the 90% LTV pools instead of the standard 75%, etc.
    • Bought and minted a domain on unstoppable domains.
      • These manifest as NFTs and mint on polygon.
      • You can add identity information to the metadata like name, avatar, website, whatever.
      • Most convenient feature, as of now: can send erc20 tokens to this convenient domain, instead of the full hex address.
      • Could hundred apps support transactions to domains: https://unstoppabledomains.com/apps.
      • It says it supports non-eth addresses like sol and btc, but I don’t think that works yet.
    • SEC hit Barksdale siblings for Ormeus coin: https://decrypt.co/94617/sec-ormeus-coin-siblings-charges.
    • “The internet has always financialized our lives. Web3 just makes that explicit.” https://www.theatlantic.com/technology/archive/2022/02/future-internet-blockchain-investment-banking/621480/
    • Web3 founders: https://www.youtube.com/watch?v=VlSjgfTcmsY.
      1. They’re systems engineers.
      2. They’re not just leaders; they’re deeply involved in their community.
      3. Embrace democracy; changing things through supporter votes.
      4. Chase larger pie, not larger slice.
      5. Change beliefs quickly. The space is so fast. Need to (be willing to) unlearn and relearn models quickly.
    • Finished the NFT dapp.
      • Process to keep NFT image onchain: define an svg with html, base64 encode into a string, prefix with data:image/svg+xml;base64,<>, add that URI to an NFT metadata JSON, base64 encode that into a string, prefix with data:application/json;base64,<>, then setTokenURI to that.
      • And pass randomness to that with and keccak256(abi.encodePacked(randomInput like counter or something)).
      • Base64 library: https://github.com/Brechtpd/base64/blob/main/base64.sol (from loopring’s Brecht Devos).
      • Didn’t use replit this time; did everything locally.
      • Remember window.ethereum for wallet/metamask interactions (eg connect to account X) and the ethers lib for contract interactions (eg approve this transaction).
        • The ethers lib is what you pass the contract address, the contract abi, and the signer to.
      • Emitted events from the contract to the dapp to pass information in realtime.
      • OpenSea will automatically append V1 V2 V3 etc if you redeploy the same collection name more than once. Looks like it may suffix random hashes as well, can’t just rely on a clean v<>.
      • Added limits on the max NFTs that can be minted (enforced contract-side) with “require” in solidity.
      • Added a check to make sure the user is connected to the correct eth network.
      • IPFS is a distributed datastore you can use to host larger data (like videos) as NFTs, rather than on chain. https://docs.ipfs.io/concepts/what-is-ipfs/.
        • Then fetch with pinata: https://www.pinata.cloud/.
      • Etherscan has the ability to verify contracts, exposing the sourcecode and adding a green checkmark of authenticity and such.
        • You can do this directly through the etherscan ui, but hardhat can do it for us also (more conveniently) with @nomiclabs/hardhat-etherscan. Just generate an api key from your etherscan account and add it to hardhat.config.js.module.exports.
        • Then to your new contract after you deploy it, run “npx hardhat verify <contractAddress> –network <>”. You obviously have to redo this every time your redeploy.
        • Now we can see the full contract: https://rinkeby.etherscan.io/address/0x1b797daacc73821ee6feb1b2e1367f1234db01fe#code, and even call its functions for read/write directly from etherscan.
      • All in all, basically single file smart contract on the backend and a single file react app on the front, each ~100 lines.
    • You can see all the fees you’ve paid (all accounts, all time) on coinbase here: https://pro.coinbase.com/orders/fees.
    • Amazon announced 20:1 stock split today, executing around June 3.
    • Solana Miami event is wynwood April 5-10. Galleries and networking, day and night. There’s also the hacker house at the same time, but I’ll have already done ny.