Mostly Software

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

  • Sunday

    • Crunchbase for info about companies, even private. Funding, acquisitions, people, etc. https://www.crunchbase.com/.
    • Blind for anonymous internal chat about companies: https://www.teamblind.com/.
    • Streaming protocols.
      • Definitions.
        • Stream = pay on periodic schedule.
        • Vest = pay on periodic schedule, but with an end date, and allowing batches on certain dates (cliffs).
        • Escrow = transfer to third-party smart contract instead of directly to recipient. It will hold until certain conditions are met, then finish the transfer. This allows cancellation during the holding period, obviously (“I put in the wrong address”).
      • Venko for token streaming on Solana: https://github.com/VenkoApp/venko. Issue over a schedule, revocably or irrevocably. Escrow as well; hold over cancellation period.
      • Streamflow is another on solana: https://github.com/streamflow-finance. Vest, pay, all the expectations. Connect your wallet to the dapp, specify a schedule/recipient, go.
        • https://streamflow.finance/ and https://docs.streamflow.finance/.
        • Their fees for vesting are 0.25%. https://docs.streamflow.finance/help/fees.
        • Played around with it. Very simply to use: https://app.streamflow.finance/.
      • Superfluid is another, but on ethereum: https://app.superfluid.finance/dashboard.
        • Only streaming; doesn’t support vesting yet. Also looks like it’s just on L2s, not mainnet. Also you need to wrap your tokens before creating a stream.
    • Fireblocks. A wallet on steroids, full-featured for corporate use. Basically a treasury, finance department, payroll, etc. A full platform to run a digital asset business. Can connect to exchanges, multiple wallets, lenders, etc.
    • Justworks: https://justworks.com/. Really helpful platform for startups. Manages benefits, HR, compliance, payroll. They provide both software and consultants to help.
    • ENS = Ethereum Name Service/System. DNS but for eth wallets, eth dapp websites, etc. https://ens.domains/. Identity provider; so we don’t have to deal with addresses.
      • Fractal is an ID system as well: https://protocol.fractal.id/.
    • Remember all eth addresses are hex numbers. 0x prefix just denotes hex.
    • Party rounds = when multiple investors participate in an early funding round.
    • Mirrortable = just a captable but mirrored onchain. https://balajis.com/mirrortable/. Smart contracts manage equity/tokens onchain, sure, but need to be synced with an offchain captable for all the standard auditing/compliance procedures.
    • Solana Server Program: discounted access to cloud data centers where you can lease validators month-to-month. They do this to encourage decentralization.
      • https://solana.foundation/server-program.
      • There’s a similar Delegation Program, where you can essentially lease stake. You borrow sol (well, get sol delegated) from the Solana Foundation.
    • Coinbase Cloud. APIs/infra for payments, data access, staking, more. https://docs.cloud.coinbase.com/.
      • Bison Trails had a Query & Transact service (nodes as a service, allowing you to read and write onchain). This is now part of coinbase cloud. They also had a validator service that moved as well.
    • Played with figma a little more. Collaborative design, history, wireframes, comments, all in browser. Can see it all live, UX and devs, clients and users, across the globe, changing in realtime.
      • Can generate code from design. I’ve never seen a successful tool for this, usually the produced pseudocode is unusable; but I personally haven’t tried this feature on figma.
    • IDO = initial DEX offering. It means you’re launching a token for the first time, and you’re doing it on a DEX.
    • SolRazr. They call it a “developer ecosystem” – basically a solana incubator.
      • https://solrazr.com/.
      • They facilitate IDOs, offer developer tools and KYC integrations, help with fundraising, stuff that startups and new dapps might benefit from.
    • I cannot tell you the last web3 project I’ve seen that DIDN’T use GitBook for docs. https://www.gitbook.com/.
    • Alchemy provides HTTP APIs to fetch onchain info (for eth). Transactions, NFTs, token information, more.
      • https://docs.alchemy.com/alchemy/enhanced-apis/transfers-api.
    • AWS console. Played with a few different things on my account today.
      • Amplify. Similar to GitHub/GitLab Pages. Connected it to GitLab, autoimported build/deploy configuration, hosted static site. Easy experience.
        • Deployed https://bmahlstedt.gitlab.io/tic-tac-toe/ to https://main.d3jlirayiw5un4.amplifyapp.com/.
        • In the free tier, you get (1000 build minutes / 5GB stored / 15GB served) per month.
      • Launched an EC2 instance and played around.
        • Amazon Linux AMI. t2.micro. 1 vCPU, 1GB mem, 8GiB SSD storage (EBS).
      • Set up billing alerts.
    • Remember “bips” phonetically = bps = basis points = hundredth of a percent.
    • Coming back to tokemak: holding TOKE is like holding liquidity itself, in an abstract sense.
      • Read a few more of their medium articles.
      • Still think it’s weird how try to alias everything with cute names. Reactors, tokemechs, pilots…
    • Did a little bit more churning research.
    • Looked a little through the full web3.js lib: https://web3js.readthedocs.io/en/v1.7.0/.
    • Refresher on redux. Rather than hoisting react state to the highest common component then flowing down (as props as necessary), you can store global state in redux; available to all components. Also isolates state modifiers as reducers, making them easier to test/understand/replay.
      • Added redux devtools to brave.
    • Remember (imperative = how) and (declarative = what). Give it steps to go from the current state to the final state, or give it the final state and let it resolve how to get there from the current state.
    • Played with next.js and vercel.

  • Saturday

    • Biggest tokens on solana: https://solscan.io/tokens. Wrapped Sol, AvocadoCoin, Serum, MAPS, USDC, Oxygen, 1SAFU, USDT, Bonfida, Raydium,
      Wrapped Eth, Litecoin.
    • MM is formally used as the metric for millions, because M is thousands in roman numerals. Silly, it’s 2022. Use M. Your English-speaking audience is larger than your ancient Roman audience.
    • Are there public and private companies still in web3? DAOs are certainly public. But a company that provides a blockchain/crypto/defi/web3 service can certainly remain private. Gemini is private, coinbase is public. These companies can run equity programs, or token programs, or both. Look at facebook; it would have had META shares on NYSE and DIEM shares on uniswap.
    • Set up vscode on laptop.
    • Uniswap’s 24hr vol rn is 1b.
    • Electric Capital is another big web3 VC: https://www.electriccapital.com/.
    • 37% of the initial Sol supply went to investors.

  • Friday

    • DeFi 2.0.
      • First: why?
        • Look at incentive. Most protocols offer high incentives of their native token for people to provide liquidity to their protocol. This is risky though; all these providers will hop to the next shiny protocol when the incentive offer is better. Often someone forks the protocol, increases the incentive by 1%, then motivates everyone to hop over to their new token (all within a day).
        • Vesting will slow this down, but does not avoid the issue.
        • You can also build brand (uniswap).
        • Need a more sustainable way to keep liquidity providers together longterm. Enter defi 2.0. Basically crypto reserves for the whole market.
      • OlympusDAO (OHM) was the first, announced on medium in feb 2021. It’s been 1 year. Wonderland (TIME) is another (on avalance), as well as KlimaDAO (KLIMA).
      • Tokemak (TOKE) too. I’ll start with the generalized theory, using Olympus as the example (it was the first) and then discuss the others.
      • OHM and TOKE are called the protocol tokens (obviously).
      • A difference: other stablecoins (usdc, dai, tether) are pegged to the dollar. If USD has inflation, all these pegged stablecoins have the same inflation. These defi2 projects are backed by a treasury (eg OHM tokens), so they aren’t married to fiat.
        • And technically, backed means that it can rise in value to above the asset basket that backs it. It just can’t go below. OHM >= 1 USD.
      • This treasury has a wide variety of reserves (a “basket”), but is diversified across various crypto products. It will follow the market.
      • This treasury is just like the fed, just like a central bank, but is decentralized bc it’s controlled by a DAO (eg holders of the OHM token for Olympus).
      • This treasury is a gigantic liquidity pool.
        • When the treasury token (OHM) trades above the value of its reserves (backed assets), the protocol dilutes by minting and selling more of the token (OHM), dropping the price to stabilize (increase supply, reduce demand).
        • When the token trades below its reserves, the treasury buys it (OHM) back and burns it, reducing supply and increasing price.
      • This is call PCV, protocol-controlled value.
      • Both considered, the floor price is then 1 DAI (what it was originally backed by). Right now, OHM is $36.
      • Then to grow and expand the protocol, the treasury offers bonds. Send crypto, receive the treasury token (OHM) at a discount. You must hold for a certain period of time (5 days for olympus); this is what provides liquidity to the treasury.
        • Bonders make a profit then if OHM increases in value.
      • Just think of a gigantic melting pot of precious metals. A federal reserve will take your gold and silver and diamonds and oil and give you corresponding dollars in return. But instead of physical assets, we used digital assets with crypto. The melting pot is the treasury, the dollar is OHM. Just a big database where people own backed value. But unlike a dex, where the users own the liquidity of the reserve and can take it anywhere else; defi2 is protocol-owned liquidity (POL), where it can sustainably remain.
      • This treasury makes profit. Remember, it’s a gigantic liquidity pool, while serving as reserves. This LP collects fees, just like any LP.
      • You can then stake OHM back. You’ll earn yield (OHM) from the liquidity mining fees mentioned just above.
        • Staked ohm is sOHM. You used to have to wrap this in order to participate in the governance, where you’d wrap sOHM to wsOHM. This extra transaction cost gas/time, so now in v2 you can stake directly to governance ohm, and they changed the name accordingly from wsOHM to gOHM (you can still wrap/unwrap to sOHM as desired).
        • gOHM quantity doesn’t change, but its value increases. This is unlike sOHM, which changes in quantity (not value) upon rebase (or every epoch, not sure). https://docs.olympusdao.finance/main/basics/migration#will-my-gohm-still-earn-rebase-rewards.
      • Note that staking here doesn’t mean delegation of funds to a validator for PoS block confirmation. It’s just the generalized word for a passive yield strategy that generates APY based on delegating your funds for some purpose. In this case, it’s providing liquidity and/or treasury backing.
      • For Olympus, what you can buy bonds with? https://docs.olympusdao.finance/main/using-the-website/bonds.
        • Direct assets: DAI, FRAX, and wETH.
        • You may also buy bonds directly with LP tokens. OHM-DAI and OHM-FRAX.
        • When I checked just now, the only way to bond was with UST direct (2.42% discount) or OHM-DAI LP (4.38% discount). Each 2 days.
      • In this way, the DAO owns all the liquidity. This is what is more sustainable/stable than standard DEX liquidity pools. Liquidity miners just take their liquidity and hop to the next protocol with better incentives. Can’t do that in defi2, because the protocol itself owns the liquidity. Right now, OlympusDAO owns 99.67% of all OHM-X liquidity for exactly this reason.
      • Putting it all together:
        • If there are 1 million OHM in circulation, and 10m of crypto (in equivalent USD) in the treasury, then each OHM is backed by 10 USD, and the protocol will mint 9 million OHM to restore 1:1. This action is called a rebase. These minted OHM tokens are given to the stakers. That’s what allows crazy high APYs.
        • Well, how does the treasury grow? Again, back to bonding. People provide their stablecoins or liquidity tokens and get OHM in return.
      • Best case: everyone stakes OHM longterm. Worst case: everyone sells. this is the (3,3) you see sometimes. Go back to game theory.
          • Staking takes ohm off the market. Best case, since the actor benefits (yield) and the protocol benefits (ohm price increase).
          • Bonding is in the middle. The actor gets some reward (discount), and the protocol gets some benefit (liquidity). No price move.
          • Selling is the worst. Good for the actor (profit) but bad for the protocol (ohm price decrease).
      • Ultimately, the goal would be for OHM to become the global digital currency.
      • To get OHM initially: bond it from the treasury, or buy it on the open market.
        • UPDATE: Now Zapper (via https://zapper.fi/) allows you to swap directly into a staked OHM position. Convert your eth/bat/wbtc/whatever directly into gohm.
        • They plan to offer zap-bond soon, so you can do the full bond process in a single click as well (swap half to dai, swap half to ohm, add pair to lp, bond lp token).
      • OlympusDAO offers Olympus Pro; basically its bonding mechanism but as a service. Your protocol can offer a token as an incentive, but sell it as a bond to bring liquidity back to the protocol itself. Stabler growth, better longterm.
      • Olympus V2 improved a few things; primarily allowing bonded OHM to be staked during the vesting time.
      • OlympusDAO’s treasury only needs 4 of 7 multisigs? Could be bad.
      • I think Olympus only works on eth mainnet. Checked today, https://app.olympusdao.finance/ does not allow bonding/staking on polygon/optimism/arbitrum.
      • It currently has 444.7m (market value) of treasury assets.
      • Right now, 80.8% of all OHM is staked.
      • APY is currently 905.7% for staking.
      • Be careful on exchanges; use ohm v2 rather than ohm v1 (although the dapp can migrate for you, extra gas fee).
    • Tokemak.
      • Oversimplified: tokemak is a wrapper around DEXs and has a native token (TOKE) for holders to vote on which market (DEX) the liquidity of each asset goes to.
      • Ignore the new words they try to introduce: reactors=pools, democratization=decentralization, liquidity directors=voters/stakers. Complexity from unfamiliarity doesn’t automatically ooze intelligence.
      • Can also replace “liquidity” in all the descriptions with “bandwidth” from the internet era. Having bandwidth caused an explosion of products/sites/games/whatever. Same here. But talking about value flow instead of data flow.
      • Carson Cook, launched summer 2021.
      • A tokamak is a fusion power device that holds plasma with magnetic fields. Fuses atoms, produces sustainable energy. Tokemak gathers tokens and produces liquidity. (…….)
      • In the same way, each asset has its own pool (called a reactor). Liquidity providers (not calling them LPs because it’s ambiguous with liquidity pools) put an asset into a reactor. Liquidity directors use TOKE to decide where the liquidity should go. If you hold TOKE, you can participate in this.
      • As you might expect, liquidity providers get yield in TOKE, not the asset they deposited nor an LP token. While TOKE is general, liquidity directors will stake (delegate) it back into a specific reactor (pool) to give themselves voting rights to direct the liquidity of that pool (not all pools).
      • Note than in this model, impermanent loss is now a risk of the voters=TOKEholders=DAO (liquidity directors), not the liquidity providers (like in current defi1 DEXs).
      • tAssets are held in smart contracts (and burned on withdrawal) as claim receipts of the actual deposit, just like cAssets on compound and aAssets on aave. If I provide BAT, I get tBAT back, and can exchange it 1:1 for my original BAT at any time (removing the liquidity I provided).
      • Balancing.
        • If a reactor/pool has a lot of assets, but only a few voters staking their TOKE to direct it, their APY is higher (because the voters who directed the liquidity of that pool get the fees earned from that liquidity, divided by fewer people). So more people will be attracted to stake toke in that pool, and balance is organic.
        • Same in the opposite direction. If there’s a small amount of assets in a pool but a lot of liquidity directors, they earn a smaller cut and are incentivized to direct/stake another pool/reactor.
        • Same applies for the liquidity providers. More stakers than assets? Add assets and you get better TOKE returns. More assets than stakers? People who want to add additional assets as liquidity will have diminishing returns.
      • Early phase roadmap (cycle zero).
        • DeGenesis Event. Just eth and stablecoin reactors.
        • Collateralization of Reactors Event (CORE). Whitelisted/curated pools/reactors compete.
        • Genesis Pools. Users can use the pools that won.
      • Again, just eth mainnet (for now).
      • https://www.youtube.com/watch?v=vum5l-acbm0.
      • Nice side perk – tokemak allows liquidity providers to deposit single assets; don’t need pairs.
      • Built (originally) for new daos/protocols/tokens. I can create a reactor/pool for my new token and incentivize people to bring liquidity to it. If a bunch of toke holders come stake there, naturally liquidity providers will flow to bring a balance (see APY balancing section above). So if originally have a small seed of users on uniswap, let’s say, I can use tokemak to basically “encourage” (force via incentivization) users to add to THAT liquidity, rather than a separate pool on sushiswap. Or, distribute it evenly if that fits your model better. Tokemak will show you the distribution across exchanges right alongside the trading volume on each, so you can measure success.
      • You can also kinda think of tokemak like gofundme for defi. New projects can attempt to launch, and if people support it, they can invest and the project grows. Except instead of USD to bring people up, the whole tokemak dao has TOKE tokens instead. They can “invest” (stake) that in any project (pool/reactor of a new token) and funds will organically flow to their project and provide liquidity (reserves, funds, many use cases). The whole tokemak community then becomes this giant liquidity machine with TOKE being used as a fungible router.
      • This is also the incentive to participate in a system like this. If you provide liquidity, you get a vote in this community via TOKE, and TOKE also becomes your effective “share” of the gigantic pool of liquidity (can collect fees, withdraw, all the usuals). It’s backed by this reserve. Sustainable longterm, because it’s a protocol wrapper around exchanges, and uses its liquidity pool as a gigantic reserve, rather than a dex protocol that can be 1up-ed with a shinier incentive tomorrow.
      • They also act like a vc arm (loosely) in the beginning, if desired/necessary. “Hey new protocol, here’s some TOKE in your pool/reactor to bootstrap your ability to direct liquidity, give us some tokens.”
      • Eventually can spread across chains, down to L2s, more. Can even route liquidity to other protocols OTHER than DEXs, like voting to send a bunch of reserves to yearn or something and generating direct APY for the holders.
      • Overall benefit as a liquidity provider, compared to just directly adding to the dex pool of your choice: avoid impermanent loss, provide as low as a single asset, compound yield from lp AND ld.
      • Ultimately, if tokemak black holes everything (good), you have a gigantic liquidity pool that can be directed anywhere in realtime. This means 0 slippage and best rates across the board.
    • LUNA directly into terra station wallet via transak.
      • They require KYC, so you have to provide a bunch of ID once.
      • Limits per day/week/month/year: 500/1000/5000/60000.
    • https://haveibeenpwned.com/.
    • Google Meet is pretty seamless. Free, all in browser, connected to gmail and gcalendar, share screen/window/tab capability, whiteboard (and saved into gdrive), quick share link, host controls for mute/video/etc, backgrounds (including blur), chat. Surprise feature: captions, live transcribing of all speakers.
    • Searched for a way to allow multiple rows of bookmarks in chromium. No native way, and no current extensions. There used to be one called Roomy Bookmarks but cancelled, and there are a few others that don’t look safe. I’ll probably write one myself. I strongly prefer multiple rows, all icons, no text, no folders.
    • KMS = key management system / HSM = hardware security module. Cryptography/security solutions.
    • Connected airpods and sony headphones to win11 via bluetooth dongle, can now use wireless audio with video.
    • Staked some OHM into gOHM today. Will bond OHM-DAI lp tokens shortly for more ohm to stake.
    • Excellent overview of Carta.
      • From tribe capital: https://tribecap.co/1-trillion-in-equity-how-carta-is-set-to-unlock-the-private-markets/.
      • Focused on the atomic unit of equity.
      • “N of 1” – companies/products that are capable of becoming much larger than what people expect early on. They explode. Think of the opposite: “1 of N” – a bunch of companies with decent ideas, among which any could take off, largely determined by atmosphere/luck/etc.
      • Often the key lies in the potential scale of the market.
      • Strategy: find a generational “atomic unit of value” – think oil of the resource generation, or bandwidth of the internet generation, or user mobile phone convenience of the uber era, or friend graph / social interaction of the facebook era. Then capture it and turn it into a utility or a service you provide.
      • Now carta. First an easy management system for your equity. Cap table mgmt. As well as managing 409As and private valuations. But then growing into full equity management and defining the atomic unit of equity.
      • Equity is more popular nowadays than it used to be; RSUs, ISOs, these are common for most employees. Incentivizes good teams, trickling ownership down. It’s not just founders anymore; employees are owners.
      • Equity also helps attract and retain high-skill talent.
      • Equity is also the fuel for entrepreneurship.
      • Remember; there’s also less incentive to go public nowadays than there used to be. Staying private is better in many cases.
      • But private equity is much less liquid. Bringing liquidity to private equity would be a very lucrative opportunity.
      • Then your network grows as you build nodes on the graph. Employees, companies, and investors. See this image and what you could do with it.
      • This makes onboarding easier. Effectively a schema for all 3 types of nodes. Imagine a startup comes to an investor and already has a carta cap table in their terms, and one of the founders already worked at a company that used carta. The investor was already familiar with carta. That process became 5x faster to add the new company node to the graph.
      • It’s a disadvantage to not manage your fund with carta. Soon that pool will shrink until basically all US companies manage their equity with this system (the goal).
      • The article is from 2020, and they claim that carta has the ownership graph (equity records) for 35% of all companies backed by US VCs. This is over $1T of equity managed on their platform. They managed equity for over 15k companies and 1M stakeholders. Not sure what today’s numbers are.
      • And then remember CartaX, the private equity market that offers ever-so-needed liquidity. If the companies allow, you can basically link the entire buy side (any accredited investor) and the entire sell side (any shareholder in a private company).
      • Right now, CartaX only allows institutional investors. Accredited individual investors will be allowed on the platform in the future.
      • Carta used to be called eShares.

  • Thursday

    • Spent a ton of time revisiting AMMs and DEX protocols. Understanding deeply how the arbitrage opportunities work. This made impermanent loss much more clear. Swapping on a DEX is just like buy/sell on a CEX. Buying with fiat, receiving crypto, Buying with crypto, receiving crypto. These buy/sells set the overall market. Each individual market (eg your LP on uniswap, or the order books on coinbase, or a stranger’s LP on sushiswap, or the order books on binance) will follow the general trend but will move at different rates. That’s how impermanent loss is born. Your market (your LP) moved an asset different than the overall market. That’s it. People who take advantage of arbitrage opportunities do help, but any imbalanced market can cause losses for market makers and liquidity providers.
    • “Snowflake plunges almost 30% on slowing revenue growth.” https://www.cnbc.com/2022/03/02/snowflake-snow-earnings-q4-2022.html.
    • CFTC commodity futures trading commission. Kalshi has a CFTC license.
    • 1inch added p2p swaps, directly between individual addresses.-
    • Can never remember, but just “git init && git remote add origin git@gitlab.com:bmahlstedt:<>.git” to push an existing local dir to remote vcs. Will type this annually until memorized.
    • Played with jupyter and lab, integrated with the vscode extension. Easy, powerful.
    • Datadog dropped 10% today – because OKTA earnings missed?
    • Also – liquidity pools that allow more than 2 tokens are effectively crypto index funds. You select your assets and collect fees. The traders using your liquidity will arbitrage the pool to current prices.
    • AirPods can connect to windows (surprisingly) although I did not add bluetooth when I built my computer. Been using bluetooth usb adapter dongles.
    • Cool video on solving a handful of Advent of Code problems using only pandas: https://www.youtube.com/watch?v=6aH4RMrhbVc.
      • header=None, squeeze=True, sep=X, diff, rolling, groupby, where (ternary for np arrays), mode, set_index, mask, axis, level, query.
    • Generating NFTs / image permutations with python: https://www.youtube.com/watch?v=o0qNS_pOVqw.
      • Base pixel images with GIMP or photoshop or whatever. Multiple layers, one for each nft attribute.
      • These do not need to be large. Cryptopunks are 24×24 pixels.
      • Very simple overall. Just rng (based on your specified rarities) to pick each layer from filepaths to the raw images, then use PIL (python image library) to stack (Image.alpha_composite).
    • One of my kalshi markets settled. Decent experience. Emailed, showed profit, automatically closed and deposited profit back into tradable balance.
      • I own 1/7th the total (alltime, as of right now) volume on my remaining market.
    • Remember Mirror (protocol on the terra blockchain) that allows you to trade mAssets, mirror non-crypto instruments like public equites. Eg. mTSLA with an oracle syncing price in UST to TSLA in USD.
    • Harmony One. Another fast blockchain. Sharded. Finality 2s. EPoS, effective proof of stake.
    • Remember the difference between stablecoins being backed by something or pegged to something.
      • Pegged = Tether and USD. You can trade 1 tether for 1 usd, or 1 usd for 1 tether.
      • Backed = A treasury holds assets which actually back the front asset.
    • Flash loans. Borrow as much of the reserves as you want, as long as it’s returned in the same block. Since the transaction is guaranteed, you don’t need to provide any collateral for this. Borrow instantaneously, as much as you want.
      • Instructions (for devs): https://docs.aave.com/developers/guides/flash-loans.
    • Balancer’s liquidity bootstrapping pools; starting at eg 90:10 and moving toward 50:50 over time so the market corrects properly.
      • Great way to launch a new token and keep prices fair.
    • calendly: https://calendly.com/bmahlstedt. Integrates cleanly with gmail, google calendar, and google meet.
    • Full code for an example uniswap v3 liquidity pool (WBTC/ETH in this case) with concentrated liquidity: https://etherscan.io/address/0xcbcdf9626bc03e24f779434178a73a0b4bad62ed#code. A few thousand lines.
    • Uniswap markets: https://arxiv.org/pdf/1911.03380.pdf. From 2019.
      • A constant-product market deviates from true market price proportionally with fee size.
      • The cost of manipulating a constant-product market scales linearly with the reserve amounts.
      • Generalizing: Constant-mean markets (eg Balancer) ensure that the weighted mean of the reserves remains constant (doesn’t have to just be 2 tokens in the LP). Even more generalization: constant-function markets. CFMMs.
      • The authors ran a bunch of simulations to determine the behavior of these markets. Three types of sim agents: artbitrageours, liquidity providers, traders.
    • Played a little bit more with 1inch. Great tool. The aggregation for price/slippage/gas comparison is great.
    • To add an LP token to metamask, check the protocol (usually a link to a block explorer) for the contract address, then import the token manually.
    • Paradigm.
      • Has invested in BlockFi, Chainalysis, Citadel Securities, Coinbase, Cosmos, Diem, Flashbots, FTX, MoonPay, OpenSea, Optimism, Uniswap. https://www.paradigm.xyz/portfolio.
      • To stay up: https://www.paradigm.xyz/writing.

  • Wednesday

    • Marinade: “we have identified an issue with the latest update to validators delegation formula scoring, that caused about 6M SOL in total to be automatically set to unstake” – They restaked in the next epoch but this will cause ~0.1% drop in overall msol APY.
    • Metastreet (on NFTfi) gave an 8m loan to someone using their cryptopunk NFTs as collateral..
    • Still looking for the perfect earnings calendar. Filters by market cap, past performance, current estimates, links to calls/reports, more. May just build one.
    • Rewrote the (index <-> row/col) logic to properly use remainder and modulo, rather than hardcoded. Much cleaner.
    • Set up gitlab-ci to build, and then a deploy stage to push to gitlab pages: https://bmahlstedt.gitlab.io/tic-tac-toe/.
    • https://formik.org/.
    • Changed my wave dapp to display the user’s public address (conditionally on wallet connection).