Episodes
-
Today’s episode is a special episode with David Furlong, founder of frames.js.
We discuss everything frames and farcaster. Don't miss out on it !Participate in the Superfluid Frontier Guild program: https://www.notion.so/superfluidhq/Superfluid-Frontier-Guild-ca56b52629f446989a66fb69b158cd74
FramesJs: https://framesjs.org/
Superfluid: https://www.superfluid.finance/ -
Today's episode features Vitto Rivabella on the modern web3 stack.
Vitto on Twitter: https://twitter.com/VittoStack
Create Web3 Dapp: https://www.alchemy.com/create-web3-dapp -
Missing episodes?
-
Today's episode is with Emily from the Consensys team on all things Linea - Consenys' new zkEVM.
Linea: https://linea.build/
Linea Docs: https://docs.linea.build/
On ZK Hardware: https://hackmd.io/@Cysic/BJQcpVbXn -
Today's episode features Lukas & Emil of the Planet IX core team.
You can learn more about Planet IX (and play the game!) here: https://planetix.com/
-
Today's guest is Noam Hurwitz, an engineer at Alchemy who is playing a key role in building Alchemy's new account abstraction infrastructure.
Alchemy on AA: www.alchemy.com/account-abstraction
Alchemy: https://www.alchemy.com
Alchemy University: https://university.alchemy.com
Follow Noam on Twitter: https://twitter.com/ProbablyNoam00:00 Intro
3:51 How Noam got into crypto
6:00 Noam’s take on the current Account Abstraction discourse
8:32 AA infrastructure overview
11:32 Walking through Alchemy’s bundler architecture
13:15 MEV and user operations
15:05 The ‘intent based architecture’ and the userOp mempool
18:05 The entry point contract
22:50 Paymaster contracts
25:24 What should application developers know about AA?
29:40 What do smart contract accounts enable?
32:41 Lessons from drafting an EIP and EIP 6900
37:16 Avoiding centralization around AA infrastructure
42:46 New security issues presented by AA
45:01 Noam’s advice on building APIs & developer products
49:15 Noam’s favorite technical implementations in the industry
50:54 Advice for those early in their career
52:48 How Noam hopes the industry evolves over the next decade
-
Today's episode is with Remi & Sung - core contributors at Alluo Finance. We went deep into Alluo's smart contract architecture & philosophy on building great DeFi user experiences.
Learn more about Alluo: https://linktr.ee/alluo
Build on Superfluid: https://www.superfluid.finance/wave-pool
00:00 Intro
5:11 How Remi got into the industry/Alluo's founding
8:11 How Sung got into the space
9:58 What is Alluo?
16:18 Auto Invest - streaming DCA
18:33 An overview of the Alluo contract architecture
23:59 - Bridging architecture
25:15 - Simplicity in protocol design
31:52 - How Alluo liquidity direction voting works at the smart contract level
34:58 - Boosted pools
39:57 - Using the 4626 design for the boosted pool
42:05 - stIBAlluo for money streaming
47:26 - Building out a high quality mobile experience for DeFi
56:59 - Advice for early stage DeFi teams -
Today's episode features a deep dive on The Graph with engineer Pranav Maheshwari.
Check out the Superfluid Wave Pool here: https://superfluid.finance/wavepool
-
This week's guest is Zac Williamson, founder & CEO at Aztec.
Check out the Superfluid Wave Pool! https://www.superfluid.finance/wavepool
Aztec: https://twitter.com/aztecnetwork
Noir Docs: https://noir-lang.org/
Zac on Twitter: https://twitter.com/Zac_Aztec00:00 Intro
3:45 How Zac got into Web3
6:45 The creation of Aztec
14:30 why did he build huff?
19:05 Weirstrudel & Optimizations in Huff
21:33 Inspirations for Huff Language designs
23:15 Why did Huff take off?
27:27 The future of the Huff community?
31:08 Mental models needed for devs that want to build privacy preserving apps
37:05 Hello world in Noir
38:50 Private functions and private contracts on Aztec
46:22 The Aztec sequencer
50:15 Noir & smart contract security
51255 What should people build on Noir?
56:52 Advice for early career devs
-
This week's episode features an interview between Patrick Collins and a Web3 Security Engineer at Trail of Bits. They cover:
- testing methodologies
- fuzzing
- static analysisWith Trail of Bits Security Engineer, Troy!
Timestamps
3:10 - Exploring Smart Contract Testing Methodologies with Trail of Bits
5:37 - Testing Strategies for Smart Contracts
8:10 - Fuzz Testing and Invariant-Based Testing Explained
10:56 - Coverage Guided Fuzzing Explained
13:50 - The Benefits of Coverage Guided Fuzzing and the Differences between Echidna, Foundry, & Others
16:27 - Using Coverage Guided Fuzzing with Optic and Echidna
19:12 - Symbolic execution and coverage-guided fuzzing in Echidna
21:57 - Testing Philosophies: Dynamic vs. Static Testing
24:24 - Dynamic vs Static Analysis and the trade-offs of each approach
27:10 - The Importance of Efficient Testing and Using a Variety of Testing Methods
29:57 - The Role of Security Firms and Testing Philosophies
32:33 - Balancing Cost and Efficiency in Security Audits
35:15 - The Importance of Code Reuse in Building Tools and Languages
38:04 - The pitfalls of focusing on language intricacies in programming and the benefits of prioritizing language design and philosophy
40:41 - The Need for More Open Source Tools and Communication in the Ethereum Community
43:22 - Advice for becoming more security-minded in smart contract coding
45:51 - Discussion with Alpha Rush on Testing Compilers and Security Focus Journeys -
Today's guest is the pseudonymous developer Rage of Size.Market.
Rage on Twitter: https://twitter.com/rage_pit
-
Today's guest is Albert Hu - Founding Product Engineer at DeForm & former Developer Advocate at Alchemy.
-
Today's episode is a technical deep dive into how Lens Protocol works under the hood.
Build with Superfluid: https://www.superfluid.finance/wavepool
Build on Lens: https://www.lens.xyz/gardenChapters:
00:00:00 - Intro
00:02:45 - Hackathons and the Superfluid Wave Pool
00:05:35 - Understanding Lens: A Developer's Perspective
00:08:11 - Lens Infrastructure: What's Happening Under the Hood?
00:11:02 - Build a Following That Stays with You Forever
00:13:33 - The Challenges of Storing and Retrieving Data in Blockchain Applications
00:16:13 - Building the Lens API
00:21:30 - Lens Modules
00:29:31 - Social Media Monetization and the Scalability of Lens compared to Twitter
00:32:05 - Scalability and the Challenges of Building at Twitter Scale and Beyond
00:34:52 - A Modular Infrastructure for Increased Transaction Speeds
00:37:21 - Building on top of the Lens API: Required Skill Sets
00:39:46 - Progressive Decentralization
00:44:53 - Building Recommendation Algorithms with AI and Machine Learning Techniques
00:49:47 - Exciting Opportunities for Developers on Lens Platform
00:52:11 - Building with Lens and Calls to Action for Developers -
00:00 Intro & Opening Conversation
7:58 Tincho's audit setup12:35 VSCodium
14:08 Foundry v hardhat
22:00 First audit steps
25:00 Tincho's process for commenting within the code itself
30:00 Processing a codebase with lots of inheritance & moving parts: there’s a kind of art here to flowing back and forth between the big picture architecture/business logic and the low level understanding of contract32:42 Be careful of going down adjacent rabbit holes that don’t have to do with the thing you’re auditing
36:52 When Tincho finds a bug… what does he do?
41:15 Communicating with clients
44:12 Waling through tests with Tincho
47:40 To best understand a protocol, make the codebase your own: run things locally
51:00 Time bounding your review process
52:00 Intuition vs checklists
56:05 Learning by reading past reports
59:04 Reviewing fixes
1:00:18 Handling hacks & the purpose of audits
-
Today’s guest is Richard Meissner, co founder & CTO at Safe. Richard is an expert on all things smart contract wallets, and we used this episode to go deep into account abstraction. In particular, we discussed the Safe contract architecture and how things like Safe modules & smart contract wallets work under the hood. The Safe team has rolled out a ton of new libraries & tech that make supporting smart contract wallets and AA a breeze, and we discussed them as well.
00:00 Intro
3:55 How Richard got into the industry
8:31 The Safe contract architecture
14:13 Safe modules
17:11 Misconceptions and account abstraction
20:45 ERC 4337 Infrastructure
23:11 How app developers can make proper use of smart contract wallets
25:45 What does the ecosystem need to do to enable better UX?
29:50 Solving the YOLO signing problem
36:37 The Safe Core Suite
42:30 Frictionless onboarding
50:08 How Richard & the Safe team approach smart contract security
56:00 Advice for early career devs
59:45 What does Richard hope our industry looks like in 10 years?
Safe Core: https://twitter.com/safe/status/1630946737220141062
Richard on Twitter: https://twitter.com/rimeissner -
Today’s guest is with Devtooligan - a pseudonymous smart contract engineer and auditor.
Devtooligan is a mainstay in the Huff community and just recently landed a job as a security engineer at Trail of Bits. In this episode we went deep into Huff & why so many Huffoors have had lots of success. We also discussed Devtooligan’s career path and his journey leveling up with smart contract security.
00:00 Intro
3:33 How devtooligan got into crypto
6:48 Working at Yield Protocol, Ethernaut, Getting into Huff,
12:30 Why learn Huff?
16:35 What has Solidity done well?
20:02 What should the Huff community work on?
23:00 Why have Huffors had success?
27:40 Getting better with smart contract security
37:55 What does Devtooligan’s audit process look like?
43:53 What can smart contract devs be better at? (Documentation)
48:31 AI tooling & auditing
51:45 Tinkering is what drives innovation
Useful Links:
-Devtooligan on Twitter: https://twitter.com/devtooligan
-Security reference, exercises, and tips: http://secure-contracts.com-Huff main site: www.huff.sh
-Statecharts and state machines: https://stately.ai/docs/state-machines-and-statecharts
-ToB Youtube channel: https://www.youtube.com/@trailofbits
-Fuzzing workshop: https://www.youtube.com/watch?v=QofNQxW_K08&list=PLciHOL_J7Iwqdja9UH4ZzE8dP1IxtsBXI
-How to prepare for an audit: https://blog.trailofbits.com/2018/04/06/how-to-prepare-for-a-security-audit/
-
Today's guest is Jordi Baylina, who leads the technical team building the Polygon zkEVM. The polygon zkEVM launches in late march, and this episode will serve as your technical introduction to how the zkEVM works.
We got deep into how Jordi & the team pulled this off - we talked through how the prover & sequencer works, stepped through a sample transaction step by step, and got into just how his team was able to pull off opcode parity w Ethereum L1 (and some of the tradeoffs with supporting full EVM compatibility).
If you’re interested in deploying atop the zkEVM or just understanding how it works from a technical point of view, I think you’ll enjoy this episode!
00:00 Intro
3:22 How Jordi got into crypto6:33 What is Polygon’s zkEVM?
9:34 Enabling opcode parity with Etheruem on a ZK rollup
16:10 Pricing opcodes
19:33 Walking through a transaction on the zkEVM under the hood
25:38 Bottlenecks with data availability & the sequencer
30:50 Progressively decentralizing the sequencer
34:39 LX <> LY bridge design
39:48 Tradeoffs of being fully EVM compatible
49:46 Retaining parity with the EVM as the EVM introduces changes
52:23 What should people build on the zkEVM?
Learn about the Polygon zkEVM here: https://wiki.polygon.technology/docs/zkEVM/develop/
Jordi on Twitter: https://twitter.com/jbaylina -
Today’s guest is DC Builder - a pseudonymous dev who works as an engineer at Worldcoin and maintains DevPill.me - a guide to becoming a web3 engineer.
DC Builder has contributed quite a bit of open source content & research to the space as well. He’s written things like deep dive guides on L2s and he also created the zero knowledge machine learning community.
In this episode, we got deep into the weeds on ZK ML (a fascinating topic I knew nothing about before this convo), becoming a web3 dev, and how to decide which communities and ecosystems to invest time into.This is a great episode for engineers looking to level up in the industry, and for anyone curious about ZK ML.
00:00 Intro
3:20 How DC builder got into crypto
7:31 Bottom up vs top down learning
9:17 From research to development
13:45 devpill.me breakdown
16:41 Advice for early web3 engineers
118:48 How to evaluate new developer ecosystems?
23:09 Leveling up as a developer
27:39 ZK
32: 28 ZK ML - a wild topic
42:29 Using ZK for *interactions* with ML models
47:44 Working at Worldcoin (ZK ML experiments and Worldcoin ID state bridge)
56:33 Moving data from Polygon to Ethereum L1
1:03:43 Learning about how the EIP/ERC process works
1:06:44 Building social capital in the industry
1:12:54 Other things that DC builder is interested in
1:15:53 What does DC Builder hope that our industry accomplishes?Learning how to learn: https://barbaraoakley.com/books/learning-how-to-learn/
Blockchain Dev Guide: https://www.devpill.me/
Awesome ZKML: https://github.com/worldcoin/awesome-zkml
DCBuilder on Twitter: https://twitter.com/DCbuild3r -
Today’s guest is Henri from StarkWare. Henri is a dev advocate who is deeply plugged into the StarkNet ecosystem and also hosts the StarkNet team’s podcast. This episode is meant to be a great introduction into building on StarkNet for existing web3 devs.
We went very deep into all things StarkNet and Cairo.
We discussed things like the StarkNet account model & runtime environment, the evolution of Cairo & Cairo 1.0, and the future of applications that might use StarkNet for privacy preserving applications (rather than using the ZK rollup for scalability alone).
We also made sure to talk through the mental models that devs coming from the EVM need to understand in order to build on starknet, and why the team built their own separate language in the first place.
Shownotes:
00:00 intro
3:15 How Henri got into crypto6:05 What is StarkNet?
10:41 STARKS v SNARKS
15:54 Walking through a StarkNet transaction
19:05 Decentralization
19:58 StarkNet account model
23:22 Mental models EVM devs should understand to build on StarkNet
29:34 What will people build on StarkNet?
33:30 Building a privacy preserving application on StarkNet
37:12 Cairo
41:28 Evolution of Cairo and Cairo 1.0
44:52 Building secure products in Cairo
49:15 Validity rollups & data availability
56:20 What *should* people build on StarkNet?
58:58 Henri’s long term view on the industry
StarkWare Base Camp: https://twitter.com/StarkWareLtd/status/1605519238038294529
Henri: https://twitter.com/henrlihenrli
StarkNet: https://starkware.co/starknet/ -
Today’s guest is DeGatchi, an anon web3 dev who has gone from teaching himself to code on the bus, to building some of the most cutting edge open source tooling in the space. In this episode, Degatchi walks us through his journey into crypto, and his work as a dev to date. We discussed his early learning process, and his journey doing things like launching a DEX, getting into MEV, and ultimately building cutting edge tooling like bytecode & calldata decoders. If you’re interested in some nuanced takes on MEV, understanding the EVM under the hood, and how you can dramatically increase your own rate of learning in the industry, this episode is for you.
Shownotes:
2:53 How DeGatchi got into crypto7:06 Importance of working with other good engineers
8:50 Languages: learning solidity, rust
10:15 The role of MEV for the industry
13:55 Getting into MEV
15:55 MEV terminology: long tail, short tail, generalized front-running
21:11 Rust v Go for MEV
23:20 Reverse engineering
24:30 Building a call data decoder
25:40 Bytecode decoder
33:05 anon crypto dev culture
35:55 People who have helped DeGatchi (0xBuns, Huff community, Flashbots discord, “cult” on fantom, etc)
38:02 Zk interests
39:32 Yield farming automation
43:01 Other interests
44:31 What other tooling does DeGatchi want to build?
48:55 Advice for other early career devs
51:10 What does DeGatchi hope the industry looks like in 10 years?
DeGatchi on Twitter: https://twitter.com/DeGatchi
DeGatchi's Blog: https://degatchi.com/ - Show more
