Mostly Software

  • 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.

  • Tuesday

    • SPDX = Software Package Data Exchange. https://spdx.org/licenses/.
    • Started a free one month trial for linkedin premium to check out the features. So far, nothing substantially useful to me. “Who viewed your profile” is interesting, but also a bit of a privacy overstep in my opinion.
    • Solana NY hacker house next week: https://lu.ma/ny-hacker-house. 700 registrants right now.
    • ctrl-shift-i -> ctrl-shift-p -> disable javascript. Explore various sites to see what content they render clientside.
    • Will probably use gray-matter (https://github.com/jonschlinkert/gray-matter) for Title and Date front matter in my yaml/md for custom blog creation.
    • Vscode ext regex previewer not working for me. Side by side not highlighting, with either “test regex” button or ctrl-alt-m. Uninstalled and reinstalled. Still not working. Remote wsl:ubuntu and javascript regex.
    • Husky for git hooks: https://typicode.github.io/husky.
    • Little more blogwork with next+vercel.
      • Converted to typescript.
      • Added eslint.
      • Played with the CD tool a bit more.
      • https://nextjs-blog-bmahlstedt.vercel.app/.
      • Also added playwright tests with checkly.
    • More SEO: meta tags, 308s better than 301s for redirects, xml sitemaps.
      • Devtools Lighthouse to generate reports. Run in incognito without extensions. Desktop|mobile.
        • Wp blog: 100|92 perf, 98|100 accessibility, 92|92 best practices, 91|92 seo.
        • SBSC: 84|40 perf, 96|96 accessibility, 92|83 best practices, 90|92 seo.
    • Using an ear endoscope is surreal.
    • Two web3 auditors you can have report your protocol: trail of bits and omniscia.
    • Sapphire Reserve rewards. https://account.chase.com/sapphire/reserve/benefits. Like others, the ratio is 100pts = $1. And therefore “3x points” means the same thing as “3% cashback” but the former is better because you can redeem points on ultimate rewards with additional multipliers.
      • $300/yr statement credit that can be used for travel (these don’t give pts though).
      • If you book travel through ultimate rewards: flights get you 5x points and hotels/cars get you 10x points. (3x if you pay for travel anywhere else).
      • If you redeem travel through ultimate rewards: points are worth 50% more for flights/hotels/cars.
      • Trip cancellation insurance.
      • No foreign exchange fees (usually 3%).
      • If you book dining through ultimate rewards: 10x points (3x if you pay for dining anywhere else).
      • Everything else is 1 point per 1 dollar purchase.
      • Lounge access (priority pass) +2 guests.
      • Global Entry + TSA precheck, $100 reimbursement every 4 years.
      • Can transfer any ultimate rewards points 1:1 to another airline loyalty program.
      • (signup bonus: 50k pts ($500) if you spend $4k in the first 3 months).
      • Overall:
        • If you’re going to travel, book through ultimate rewards. You get 5-10x points.
        • If you’re going to a restaurant/pickout/takeout, book through ultimate rewards. You get 10x points.
        • Don’t redeem points for cashback, if you’re going to travel. You get 1.5x more dollars by redeeming travel through ultimate rewards.
        • Dining and travel are still 3x if booked not through ultimate rewards, which is probably better than other cards.
    • Did a bunch of card comparisons in spreadsheets for future use. Two use cases: (1) churning and (2) “which card do I have that gives the best return on this type of purchase?”
    • Settled and claimed feb BAT rewards for Brave usage across all devices (laptop and desktop, still no mobile rewards support).
    • Using 0.8.12 solidity: https://github.com/ethereum/solidity/releases.
    • Started the NFT dapp.
      • Remember 721 is the NFT standard https://eips.ethereum.org/EIPS/eip-721.
      • Use this to inherit: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol.
      • OpenSea metadata standards: https://docs.opensea.io/docs/metadata-standards.
        • Name, description, image, attributes, more.
      • Used https://jsonkeeper.com/ to host the metadata json.
      • Deployed to Rinkeby.
      • https://testnets.opensea.io/assets/0xbd4fe8eb46d12bac35b0c59aa83cba7649f0aa9b/1
    • Remember; while many NFTs have metadata that point to a link, and a centralized service hosts that link, that doesn’t have to be the case. You can store the NFTs onchain. Raw data would be too large, sure, but you can store SVGs which are generated by code (example https://www.svgviewer.dev/). In this manner, the NFT can never change and never go down.

  • Monday

    • Marinade’s postmortem for the bug last week, unstaking lots of sol for a few epochs and reducing the total APY by a small bit: https://docs.marinade.finance/changelog#02-03-2022.
    • Andre Cronje (yearn/fantom) quit: https://blockworks.co/defi-star-developer-andre-cronje-calls-it-quits/.
    • Finished an example nextjs app (blog), deployed with vercel.
      • Very easy; firstclass support for static and serverside content (deployed as serverless functions), all on their edge network.
      • Posts links to preview apps on a branch in gitlab.
    • robots.txt to tell search engine crawlers how to navigate your site: https://developers.google.com/search/docs/advanced/robots/intro.
    • Remember the core web vitals (fundamentally important for site UX, which is analyzed to affect actual things like SEO).
      • Largest Contentful Paint (LCP). Load. <2.5s.
      • First Input Delay (FID). First user click/type/etc -> event handlers. <100ms.
      • Cumulative Layout Shift (CLS). <0.1. This is measured by size*distance.
    • Tailwind clean css https://tailwindcss.com/.
    • Configured vscode with tabsize=2 for js/css/html: https://gitlab.com/bmahlstedt/config/-/commit/f6690edfa6d6be602b6761a110bf589693bbf62a.
    • Played with getStaticProps() and getServerSideProps and SWR (https://swr.vercel.app/) a bit, general strategic comparisons between ssg vs ssr vs clientside.
    • “remark” and “remark-html” to process markdown into html. date-fns for formatting dates.