A technical podcast for web3 developers.
A Superfluid production.
php/* */ ?>
A technical podcast for web3 developers.
A Superfluid production.
Copyright: © 2022 Superfluid
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
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/ProbablyNoam
00: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_Aztec
00: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 analysis
With 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/garden
Chapters:
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 setup
12: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 contract
32: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 crypto
6: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 crypto
6: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 crypto
7: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/
Today’s guest is Sachin from Biconomy. This episode was dedicated to the details of account abstraction and new technologies that aim to improve the overall user experience in web3. In particular, we went into great detail on ERC4337 vs EIP 3074, and talked through what infrastructure is required to actually get ERC 4337 implemented.
Biconomy is working pretty aggressively on this, so we got a first hand perspective here. We also dove into some of the second order effects of ERC 4337 - such as how the user operation pool will work and whether or not this will open up new forms of front running outside of traditional MEV. If you’re a dev that wants to be on the forefront of new developments in account abstraction, then this episode is for you.
If you're looking for a hackathon this month, check out the Superfluid Wave Pool: https://superfluid.finance/wavepool
00:00 Intro
3:45 how Sachin got into crypto
13:44 ERC4337 v EIP 3074
29:58 Infrastructure for ERC 4337
45:29 Idiosyncrasies of the user operation pool with ERC 4337
47:20 Fixed gas transactions
52:10 Supporting smart contract wallets on front end with biconomy
1:03:45 How has Sachin approached improving as a dev?
1:09:30 How does Sachin see the industry evolving?
Sachin on Twitter: https://twitter.com/schin_tomar
ERC 4337: https://eips.ethereum.org/EIPS/eip-4337
Biconomy: https://www.biconomy.io/
Fixed Gas Tx: https://mirror.xyz/0xd96FA162b064553822e765545E3D48a054eC81F6/PgRtcrT3CGN7sc723-2ykpXnAqQEJCMMtiLTL47ZFMQ
Today’s guest is Nader Dabit - the Director of Developer relations at Aave. Nader has had a very positive impact on many, many devs in web3, and in this episode, we tried to get behind the scenes on how Nader approaches creating developer content, building developer communities, and both building & maintaining APIs and developer tooling. If you work in dev real or are building a protocol or product that’s meant to be used by developers, I think you’ll get a lot out of this episode.
If you're a dev listening to this, you should out the Superfluid Wave Pool - a continuous hackathon where you can win prizes and build your portfolio of work: https://superfluid.finance/wavepool
3:55 How Nader got into web3
5:39 Following curiosity
9:04 Avoiding distractions
11:50 How Nader approaches learning a new protocol or technology
16:05 How to decide what to learn in the first place
19:03 What problems in the industry is Nader interested in solving?
23:02 Giving back via education
28:22 Preparing for a dev workshop
31:48 Advice for giving talks
34:27 Building developer communities
39:34 Leveraging bounties and contractors within your dev community
47:39 Building SDKs and APIs
50:34 UX improvements that web3 needs
52:52 What does Nader want people to build?
55:35 What’s on the Lens developer roadmap?
Nader on Twitter: https://twitter.com/dabit3
Building Developer Communities Article: https://nader.substack.com/p/building-high-impact-developer-communities
Lens: https://www.lens.xyz/garden
Miguel Piedrafitaon Twitter: https://twitter.com/m1guelpf
Today’s guest is Bowen Wang, the Head of Protocol Development at Near. This episode will serve as a technical introduction to NEAR from the point of view of an EVM developer. Bowen and I discussed a lot of the inner workings of NEAR: we went into sharding, asynchronicity on NEAR, javascript smart contracts, and NEAR’s analogues to account abstraction. We also discussed how Aurora works, which is an EVM scaling solution built on top of NEAR. If you’re interested in expanding your domain knowledge to other L1s and learning how a great engineer thinks about building a developer career, I think you’ll like this episode.
3:20 Bowen’s Background
8:50 Understanding NEAR mental models for EVM devs
11:51 A token transfer on NEAR under the hood
14:35 Sharding on NEAR
19:33 Asynchronicity
25:32 Token contracts on NEAR
26:51 NEAR account model - all accounts are contracts
29:00 Account access keys
32:00 Human readable names (NEAR’s ENS equivalent)
36:40 Aurora, Rainbow & EVM compatibility
43:45 NEAR meta transactions
48:35 Zero knowledge light clients
51:35 Developer experience on NEAR
56:30 Developer advice
57:31 Long term vision for NEAR
NEAR: https://near.org/
Aurora: https://aurora.dev/
Bowen on Twitter: https://twitter.com/BowenWang18
Push protocol is building a decentralized communication and notification layer for web3, and in this episode, we deep dive the protocol on a technical level. We talk through things like the push smart contracts, PUSH ‘channels’, what exactly the notification itself is under the hood, and more. We also asked Harsh some more general questions about being an engineer in the space, and he gave some very good advice for engineers looking to be founders.
Learn more about the Superfluid Wave Pool and the January PUSH Protocol prize here: https://docs.superfluid.finance/superfluid/resources/superfluid-wave-pool#current-prizes
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
Shownotes:
2:04 Wave Pool PUSH x Superfluid opportunity
5:30 How Harsh got into crypto
10:40 Founding PUSH (EPNS at the time)
16:00 Decentralized internet infrastructure
22:00 PUSH intro - what is PUSH?
28:05 Example: using PUSH with Superfluid
33:05 What are channels?
35:01 Notification payloads
40:05 PUSH delivery nodes
48:06 Progressive decentralization
51:01 The PUSH developer community
55:55 How has Harsh approached getting better as a dev and founder?
1:00:01 What bad advice should devs avoid?
1:04:03 What should devs build on PUSH?
1:06:31 What does Harsh hope the industry looks like in 10 years?
1:10:08 Game theory applied to building in crypto
Links:
Harsh on Twitter: https://twitter.com/harshrajat
PUSH: https://push.org/
Learn Game Theory: https://ncase.me/trust/
Today we’ll be looking beyond the EVM to do a technical deep dive on the Solana ecosystem.
Stream Salaries With Superfluid: https://use.superfluid.finance/payroll
Bartosz is the head of product engineering at Solana. He’ll tell you more about his journey into crypto in the episode, but Bartosz is someone with deep expertise in building software for the world of traditional finance. Before getting into crypto, he built trading systems for years at Citadel and worked as a senior engineer at JP Morgan.
You can consider this episode as a crash course on building on Solana for engineers who have a familiarity with the EVM. We walk through the Solana execution environment, how token contracts work on Solana, and some of the different mental models you’ll need to wrap your mind around to build Solana programs.
We also walk through how Bartosz thinks about building developer communities, and what he’s excited about in the Solana ecosystem.
Whether or not you plan to build on Solana, Bartosz is an excellent engineer and someone we can all learn from.
Solana Chicago Bootcamp in Jan '23: https://twitter.com/baalazamon/status/1605022057129218048?s=20&t=oVOeco1X11gSo2i-aRRxcQ
Shownotes:
4:27 How Bartosz got into crypto
7:10 The Solana ecosystem
9:11 Solana mental models & how they compare to the EVM
13:21 How tokens work on Solana
17:36 Code reuse and inheritance on Solana
19:49 Solana & the separation of compute and state
24:56 Upgradable contracts on Solana
26:23 The Solana account model
28:47 Optimizing for network performance or developer adoption?
33:17 Solana DevX
37:00 Favorite design patterns (Solana NFT composability)
38:03 Requests for tooling for the Solana ecosystem (block explorers)
38:51 Exciting new Solana developments - zkps and tokens
41:31 Long term view of what blockchain looks like
43:35 Solana bootcamps
Bartosz on Twitter: https://twitter.com/baalazamon
Today’s guest is Luis (aka gitpusha), co founder of Gelato network. Luis has a fascinating story. He taught himself to code about 5 years ago and jumped into crypto before finding his way into smart contract automation & ultimately the founding of Gelato Network - a protocol for decentralized smart contract automation. In this episode, we deep dive Gelato’s network architecture, how the Gelato team approaches building developer APIs and tooling, and the specifics of professionally running off chain infrastructure.
Stream Salaries With Superfluid: https://use.superfluid.finance/payroll
00:00 Intro
3:50 How Luis got into crypto
6:30 Teaching himself to code
9:45 The founding of Gelato
13:45 Managing tradeoffs between developer experience and decentralization
19:20 Hardware requirements for Gelato Checkers and Gelato Executors
24:22 Gelato Checker client in depth
30:00 Overcoming technical challenges
33:35 DevOps skills
40:10 Advice for building developer APIs and tooling
45:35 How to use Gelato in your own application
48:50 What does Luis hope crypto looks like in 10 years?
Luis on Twitter: https://twitter.com/gitpusha
Gelato Network: https://www.gelato.network/
Today’s guest is Julien Niset, co-founder of Argent. Argent is a non custodial smart contract wallet that aims to improve UX across the entirety of web3. Julien has also become an expert & thought leader on account abstraction. In this episode, we deep dive account abstraction, how Argent works under the hood, and what app developers need to understand about all of this to build the next generation of web3 products.
Julien is also an ex-quantum physicist, so we got to ask him some fun cryptography questions as well (:
If you’re interested in improving UX for your users or just understanding the current state of account abstraction is at and what it’s all about, this episode is for you.
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
00:00 intro
4:04 How Julien got involved in crypto
6:29 Julien’s background in quantum physics
9:12 Will all of our cryptography get broken soon by strong quantum computers?
10:02 The founding of argent
15:47 Account abstraction EIPs
23:59 EIP 4337
25:13 A fee market for user operations
27:33 Benefits unlocked by account abstraction (multicall, session keys)
33:06 What should app devs know about integrating smart contract wallets?
40:04 Good workflows Julien has seen that have been enabled by smart contract wallets
41:16 Social recovery
49:34 Starknet, zkSync
52:03 EIP wars
59:07 Argent’s focus on security
1:04:42 Julien’s long term focus - real products for real people
Argent: https://www.argent.xyz/
Julien on Twitter: https://twitter.com/jniset
EIP 4337: https://eips.ethereum.org/EIPS/eip-4337
Today’s guest is Patrick Collins. You may know Patrick from his YouTube channel or his work at Chainlink, where he serves as a Lead Developer Advocate.
Patrick is one of the industry’s best educators and devrel pros. His latest 32 hour, full stack web3 development course was viewed over 1.3M times, and lives on as one of the best resources for people who want to go from zero to hero as a web3 dev. In this episode, we talk through how Patrick thinks about developer education, developer tooling, and building communities. We also touched on what he’s most excited about in the space & the Chainlink pipeline.
00:00 Intro
4:10 How did Patrick get into crypto?
5:57 Chainlink & the importance of oracles
7:57 First crypto projects
9:07 Does Patrick still hate Javascript?
10:33 Early challenges of building smart contracts
11:50 How Patrick approaches videos/tutorial content
18:17 Maintaining docs & videos as the tech progresses
21:12 How does Patrick stay on top of endless developer questions?
27:02 Bad advice or bad patterns Patrick sees in devrel
32:53 The smart contract language debate
35:42 How Patrick approaches smart contract security
38:07 What tooling does Patrick wishes someone would build?
40:42 What is Patrick excited about?
Patrick on Youtube: https://www.youtube.com/c/patrickcollins
Patrick on Twitter: https://twitter.com/patrickalphac
Chainlink: https://chain.link/
Today’s guest is with 0xBeans - a smart contract engineer who worked at Coinbase in the early days and now does work across the space as a solidity engineer.
Beans is the creator of the IAmTheOptimizer challenge, which took off earlier this year and saw the industry’s most high profile devs taking a crack at it.
In this episode, we discuss gas optimization, MEV, and building secure smart contracts. Beans is definitely a crypto native, and if you are too, I think you’ll like this episode.
00:00 Intro
4:01 how beans got into crypto
6:30 working at Coinbase & early projects
11:50 NFTs and smart contract security
16:55 how to get started w security/more security thoughts
20:33 IAmTheOptimizer
26:03 MEV
33:19 Designing with MEV in mind
37:22 Blind Vickery Auctions
44:17 What other developments is Beans excited about?
48:06 How Beans gets better as a dev
52:06 What does Beans want to learn next? Huff, Zk, Rust, Sway
58:02 What does Beans hope that the industry looks like in 10 years?
0xBeans on Twitter: https://twitter.com/0x_Beans
Today’s guest is Foobar - a Dev, writer, and auditor who is also a DeFi & NFT founder.
You may know Foobar from Twitter, where he is a grade A memepoaster and prolific commentator on all things crypto.
He’s also the creator of Delegate.cash - an immutable primitive to safely claim airdrops for vaulted NFTs.
In this episode, we deep dive several of Foobar’s projects, including Delegate.cash and a repo he calls ‘Bored and Dangerous.’ We also asked Foobar about how he personally levels up as an engineer, and how he approaches things like smart contract security, making tradeoffs between immutability & mutability, and drafting EIPs.
If you’re crypto native who wants to learn how a thriving anon dev approaches their craft, this episode is for you.
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
00:00 Teaser
2:17 Intro
4:47 How foobar got into crypto
7:05 Crypto math that Foobar loves
10:23 How NFT devs should think about cryptoeconomics
14:07 How does Foobar think about smart contract security?
19:42 Delegate.cash
29:18 Delegate.cash vs other attempts at solving the same problem
32:09 Immutable vs mutable smart contracts
38:09 Advice for building contracts that will be used by lots of people
42:08 Advice for drafting EIPs
48:32 Common mistakes that Foobar sees from junior devs
50:52 Bored and Dangerous
54:42 What does Foobar hope our industry looks like in the next 10 years
Delegate Cash: https://delegate.cash/
Bored And Dangerous Repo: https://github.com/0xfoobar/boredanddangerous
Foobar's Substack: https://0xfoobar.substack.com/
Foobar on Royalties: https://0xfoobar.substack.com/p/on-royalties
Foobar on Twitter: https://twitter.com/0xfoobar
Today’s episode is with Nick Dodson, co-founder of Fuel Labs and one of the minds behind the Sway language. We deep dive the FuelVM, Sway, and how Nick approaches his work as an engineer.
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
00:00 Intro
5:14 How Nick got into crypto
8:36 Why build Fuel?
11:51 Where does Fuel fit in the web3 developer ecosystem, and how does it relate to Ethereum?
14:26 Parallel transaction execution
16:38 Register machine architecture
21:38 Sway
33:45 Scripts, predicates, & how they can improve UX
39:05 Fuel’s native asset model
48:00 Smart contract security with a new language
51:50 What does Nick hope people build on Fuel?
56:10 What should you be prepared for when building on Fuel
1:00:47 How has Nick leveled up as an engineer?
1:04:12 What bad advice should young engineers NOT follow?
1:06:15 What does nick hope our industry looks like?
Fuel Docs: https://fuellabs.github.io/fuel-docs/master/
EIPs implemented in Fuel that are still open for the EVM: https://fuellabs.github.io/fuel-docs/master/vs-evm.html#eips-implemented-in-fuel
Sway: https://fuellabs.github.io/sway/v0.31.1/
Nick on Twitter: https://twitter.com/IAmNickDodson
Our Episode with Cami - Head of DevX at Fuel: https://www.devsdosomething.fm/episodes/cami-ramos-garzon-developer-experience-fuel-bringing-crypto-to-latam
Winter has been prolific on Twitter & in his web3 journey. He’s worked on projects for the Nouns and Loot communities, and produced really interesting projects of his own including ERC1155U, Runes of Ethereum, & Hot Chain SVG.
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
In this episode, we talk about the benefits of building in public, gas optimization, innovating in NFTs, and how to succeed as an honest builder in web3.
Winter is *legit*, and if you’re looking for a podcast episode that takes you away from the mania that’s happened throughout the last week in crypto, this episode will do that for you. Winter will bring you back to what matters: building
So give it a listen, and let us know what you think.
Links:
EVM Course: evmfromscratch.com
Winter on Twitter: https://twitter.com/w1nt3r_eth
Timestamps:
00:00 Intro
5:25 How Winter got involved in crypto
7:27 Winter’s NFT projects
9:57 Coming to crypto from big tech (Meta)
11:47 Deep diving the EVM
15:50 Where to get started with gas golfing - EVM.code, remix, and Winter
17:12 Solidity in the browser?!
23:43 Fighting centralization in the NFT space
30:38 How would Winter approach gas optimization for a new project?
34:37 Smart contract security
41:14 Leveling up as a solidity developer
46:10 Winter’s new EVM course
50:09 How to market your work without feeling like a shill
57:14 Favorite design patterns & optimization (ERC1155U)
1:01:07 What do people in web2 think about crypto?
1:05:23 What do crypto natives misunderstand about tech cycles?
1:08:30 What does Winter hope the industry achieves over the next 10 years?
Igor has a really interesting story. Babylon was a DeFi protocol that ended up shutting down after the Rari capital exploit, but the team gave the project a high integrity effort and it sounds like they learned many things during the journey.
Igor walks us through what it was like launching a new DeFi protocol during the bull market, and also talks us through the lessons he took away from the experience.
We cover subjects like testing smart contracts, preparing for audits, optimizations he’s product of, solutions to the sometimes oppressive contract size limit in solidity, & how he personally levels up as a solidity dev.
This ep is a treasure trove of information for DeFi founders and technical folks.
0:00 Intro
1:30 Who is Igor?
4:12 how Igor got involved in crypto
8:55 Early technical decisions with Babylon [decent soundbite here on audits]
13:44 Advice on testing composable systems
16:05 Advice for people about to launch a defi protocol [cost of solidity soundbite at 15:10 or so..probably winning soundbite]
19:45 Tooling Igor wishes people built for the space [soundbite on what to build] [gives a shoutout to defender around 20 min]
27:33 The perils of the solidity contract size limit (and potential solutions)
37:22 How to approach gas optimizations [decent soundbite there on how to handle this] [39 min a good one]
41:12 Preparing for audits
45:12 Favorite optimizations
50:48 How has Igor approached leveling up as a solidity dev? [really good soundbite here as well]
53:30 What do you hope the crypto DevX looks like in the next 5-10 years?
Igor on Twitter: https://twitter.com/ylv_io
Igor's Devcon Talk on Contract Size Limits: https://www.youtube.com/watch?v=qzlUNSt5pnA
Ethernaut: https://ethernaut.openzeppelin.com/
Damn Vulnerable DeFi: https://www.damnvulnerabledefi.xyz/
Paradigm CTF: https://twitter.com/paradigm_ctf?lang=en
Stream payroll with Superfluid: https://use.superfluid.finance/payroll
Today’s guest is Yorke Rhodes - founding engineer at Hyperlane, a protocol which serves as a platform for building cross chain applications.
Yorke is very knowledgable about building smart contracts. He was previously at Celo and has spent his career going deep on solidity before joining Hyperlane (which was previously known as Abacus), as a founding engineer.
In this episode, Yorke and I talk through the details of Hyperlane’s system for sending and receiving messages cross chain, and talk through cross chain tech more generally. We also talk through things like how Hyperlane thinks through developer experience & building APIs, and Yorke’s thoughts on smart contract security. Finally, we wrap up by asking Yorke what his favorite design patterns and optimizations are - something we always love asking.
If you’re a solidity developer with an interest in cross chain technology, this episode is for you.
Yorke on Twitter: @0xyorke
Hyperlane docs: https://docs.hyperlane.xyz/hyperlane-docs
Today we have Cami Ramos Garzon - aka Camiinthisthang on twitter. Cami is a Colombian-American engineer who began her career as a software engineer at Paypal before ultimately getting involved in web3. She’s a natural communicator who quickly found a fit in developer relations for some of the industry’s largest and fastest moving protocols like the Graph. Today, she works as a DevRel at Fuel Labs, where she’s helping to build out a high quality developer experience for engineers who want to build applications on top of the FuelVM. In addition to this, she’s prolific on twitter and before Devcon had a post go viral on why crypto needs to focus on Latin America if it wants to reach its full potential.
This episode was recorded live during Devcon week.
Stream salaries with Superfluid: https://use.superfluid.finance/payroll
Timestamps:
2:02 Intro
4:44 How Cami got involved in crypto
9:52 The welcoming nature of web3
11:11 A brief introduction to Fuel
12:31 Fuel's focus on developer experience with Sway & a vertically integrated toolchain
16:29 Writing libraries in Sway
17:36 How Cami prepares for developer focused workshops & talks
19:32 What can engineers do to become better at teaching & documentation?
21:35 Crypto & Latin America
23:38 Advice for engineers in LatAm who want to get involved in Web3
26:37 Where does Cami hope our industry accomplishes throughout the next decade?
Cami on Twitter: https://twitter.com/camiinthisthang
Fuel Docs: https://fuellabs.github.io/fuel-docs/master/
Today’s guest is Odysseas.eth, an engineer at Nomad who has provided a lot of value to the space as an engineer and open source contributor to various projects such as Foundry. Odysseas has a passion for decentralization, and in this episode, we discuss the technical details of what he calls the Sovereign Stack - a suite of tools he feels are important for crypto natives seeking to live decentralized lives.
We also dive deep on cross chain messaging, favorite design patterns in the Foundry codebase and Odysseas’ own work (which include a really cool script for tracing contract storage I thought was awesome), and the importance of focus for engineers working in the space. This is a wide ranging conversation that decentralization maxis and protocol engineers alike will enjoy.
This episode of DDS is brought to you by Superfluid. You can learn more about streaming payroll at https://superfluid.finance/payroll
4:00 How Odysseas got involved in crypto
10:00 The Sovereign Stack
14:30 What is urbit?
20:20 Radicle and decentralization around git
24:50 What do devs need to build into the sovereign stack?
27:20 Staying decentralized at the hardware level
30:40 Devcon and what we should be building
37:06 Avoiding getting distracted as a new solidity developer (decent SB)
44:10 Cross chain messaging
48:20 Advice on making open source contributions
51:30 High quality patterns in the Foundry codebase
54:00 Odysseas favorite design pattern: a bash script to print a txt file of your contract’s storage layout
58:15 the importance of focus, and why Odysseas doesn’t focus on gas golfing
1:00:00 Where Odysseas hopes the industry goes within the next 10 years
Odysseas on Twitter: https://twitter.com/odysseas_eth
Odysseas' Blog: https://odyslam.com/
Github: https://github.com/OdysLam/
Today’s guest is Vex, a software engineer, smart contract developer, and major contributor to Huff - a low level assembly language for the Ethereum Virtual machine.
Vex knows a ton about the EVM at the low level, and we go deep into why Huff is a great language to learn for building incredibly gas efficient contracts. Huff is also being used more and more as an educational tool, as it allows you to build programs that are, as Josh says, equivalent to ‘bare metal ethereum.’
If you’re interested in low level smart contract languages, and developing a deeper understanding of how the EVM works, you’ll love this episode.
Huff Links
https://huff.sh/
https://github.com/pentagonxyz/huffmate
https://github.com/huff-language
Writing a SNARK verifier in Huff:
https://github.com/whitenois3/huff-snark-verifier
Timestamps:
00:00 Intro
5:00 getting involved with huff & going low level
8:05 Huff overview
10:12 Writing a SNARK verifier in Huff
13:07 Good Huff use cases
16:20 Is the need to use low level assembly a failure of the higher level language?
19:05 Huff vs Yul - in Huff, you have to manage the stack yourself
22:01 Huff as an educational tool for understanding the low level
26:28 Optimizations and interesting design patterns
30:33 New EIPs for the EVM execution environment
34:16 Long term vision for Huff, and new feature ideas
41:10 Huff’s place in MEV
43:35 CTFs
48:52 Outside of Huff, what is Vex interested in?
52:30 Vex’s long term outlook on the industry
Dawson is the founder of Earnifi, a platform which helps you stay on top of airdrops in web3. He is a serial hacker and has contributed to/created many open source projects to improve his own life & the lives of dapp developers.
In this episode, we talk in detail about building high performance decentralized applications, and step through Dawson's journey becoming an indie hacker. If you're a full stack dev that wants to take a highly performant app to market - this episode is for you.
Links Discussed in the Episode:
Earnifi: https://earni.fi
Dawson's OSS Contributions: https://earni.fi/oss
Bun.js: https://bun.sh/
WASM: https://webassembly.org/
YC Startup School: https://www.startupschool.org/
Indie Hackers: https://www.indiehackers.com/
0:00 Intro
3:17 How Dawson got involved in the space
9:01 Dawson’s first real crypto project: putting election data on chain
11:55 Earnifi’s early beginnings
16:13 What full stack web2 devs should know before building a web3 application
21:18 Re-writing ethers for optimal performance
24:18 "Typescript is mandatory at this point"
26:57 Dawson’s open source contributions
33:50 Approaching entrepreneurship as a developer
39:20 You just won a hackathon, and are considering building a business around your idea. What should you do next?
43:34 Creating space to pursue your own projects as a developer
47:53 Why now is the time to build privacy-preserving applications
52:31 What would Dawson work on if he had 6 months of free time?
55:12 WASM, Bun.js, and the future of web3 front ends
58:41 Why safe, high quality DeFi is important for the world
Today, we have Santiago Palladino, a lead developer at OpenZeppelin who has helped drive the development of OpenZeppelin’s Defender product. He’s also provided value as an educator for the space, and wrote a book on Ethereum for web developers in 2019.
In this episode, we discuss Open Zeppelin’s defender product, and it’s underlying design. We also dive into the role of devops & off chain infrastructure & the future of web3 development, and explore Santiago’s thoughts on the growth of the South American & Latin American crypto ecosystem.
Santiago has a deep understanding of building products at the intersection of web2 & web3, and if you’re interested in understanding how to build products that straddle both tech stacks - this episode is for you.
OZ Defender: https://www.openzeppelin.com/defender
Ethereum For Web Developers: https://link.springer.com/book/10.100...
Santiago on Twitter: https://twitter.com/smpalladino
Timestamps:
00:00 Intro
2:26 How Santiago got involved in crypto
5:58 Getting started in web3 when coming from a traditional software development background
8:34 What tooling does Santiago wish existed?
10:39 Open Zeppelin Defender
13:58 So I’ve just deployed a smart contract to main net. What should I be thinking about next?
17:15 How to manage security & decentralization as your project evolves
22:24 The role of off chain infra in the next iteration of dapps
26:05 Decentralized backend infrastructure
30:24 The Defender architecture & some of Santiago’s favorite design patterns used in its development
35:43 How Santiago approaches API development
41:05 Why multi-chain governance & account abstractions NEED to get solved
46:28 The LatAm crypto ecosystem
52:19 Santiago’s long term vision for the industry
00:00 intro
3:09 How Sam got involved in crypto
5:16 Multi chain maker
9:36 Maker Teleport
12:37 Stepping through a specific tx lifecycle with Maker Teleport, and how that compares to other message passing bridges in the space
16:22 UX considerations of different cross chain message passing designs
19:19 RWA on Maker
21:46 Technical considerations of bringing real world assets on chain
23:51 Learning how to manage *risk* as a developer
28:28 What does the development process look like at Maker?
32:15 What does the Maker Engineering team prioritize when considering tradeoffs?
34:37 Sam’s advice for thinking about smart contract security
37:46 Tradeoffs with upgradable contracts
42:15 How to approach naming conventions in highly visible contracts
44:37 Good design patterns Sam wishes were used more often
49:34 Sam’s interest in MEV
52:22 Sam’s long term hopes for crypto
Links:
https://makerdao.com/
https://twitter.com/SebVentures
https://twitter.com/hexonaut
In this episode, we talk with a vyper contributor and compiler expert who pseudonymously goes by @big_tech_sux on Twitter.
Bts knows a lot about programming languages, and we go deep into vyper in this episode. We discuss things like vyper's evolution, standardized intermediate representations for web3 compilers, and titanoboa - a new contribution to the vyper development toolchain which is dramatically improving UX.
BTS on twitter: https://twitter.com/big_tech_sux
Vyper: https://vyper.readthedocs.io/en/stable/
Titanoboa: https://github.com/vyperlang/titanoboa
Show Notes:
00:00 Intro
2:15 How BTS got into the space
4:13 Vyper's evolution
7:24 Standardized intermediate representations for EVM languages
15:47 How will the web3 language space evolve?
20:10 Vyper’s design decisions over time
37:01 Titanoboa & its features
50:31 Why the name Big Tech Sux?
52:02 BTS' long term vision for the space
Today's guest is Nicolás Venturo, a blockchain engineer at Balancer Labs and former engineer at Open Zeppelin - where he contributed to one of the first audits of the solidity compiler.
Nicolás is very well versed on the ins & outs of solidity, smart contract development, and best practiced for security. Prior to getting involved in crypto, he was an embedded systems engineer, and has spent most of his career thinking through low level systems.
In this episode, we discuss Nicolás' thoughts on how solidity has evolved over the years, Balancer's engineering process, Nicolás' favorite design patterns, and the dangers of gas golfing.
Shownotes:
00:00 How Nicolas got into the space
4:20 Parallels between solidity development & building embedded systems
12:21 Nicolas’ thoughts on assembly languages like Yul & Huff
19:21 Standard Libraries?
27:55 Nicolas’ favorite design patterns, and why *readability* matters!
41:33 The dangers of gas golfing
46:00 Balancer’s custom error’s library: revert strings without hitting byte code size limits
54:27 How Balancer makes use of batching in their codebase
1:00:40 How the Balancer engineering team approaches development cycles
1:08:31 If Nicolás couldn’t work on Balancer for 6 months, what would he work on?
1:15:24 What does Nicolás think the long term destiny of crypto will be
Links
Nicolás on Twitter: https://twitter.com/mrnventuro
Balancer: https://balancer.fi/
Balancer's custom errors library: https://github.com/balancer-labs/balancer-v2-monorepo/blob/weighted-deployment/contracts/lib/helpers/BalancerErrors.sol
Open Zeppelin defender: https://www.openzeppelin.com/defender
Nicolás at ETHLATAM: https://www.youtube.com/watch?v=1Y5IDfJQGVk
Nicolás in a recent talk on smart contract security: https://www.youtube.com/watch?v=-Zzr87YB6TQ
Today’s guest is Chris Maree, a senior engineer at UMA protocol. Chris got into crypto several years ago and is a wealth of knowledge on solidity development, DeFi, & cryptoeconomics. In this episode, we go deep on engineering at UMA, and got to ask Chris a ton of questions about smart contract design patterns. We discuss the cryptoeconomics of UMA’s optimistic oracle, the low level design of UMA’s Across bridge, gas optimization, security, and Chris’ long term vision for the space.
If you’re an engineer interested in smart contract development & DeFi, we think you’re going to love this one.
Timestamps
00:00 Intro
3:10 How Chris got involved in crypto
6:50 UMA’s optimistic oracle
11:39 Examples of long tail data usage in web3
13:45 Walking through technical examples of how the optimistic oracle works
23:00 The use of ‘ancillary data' to turn the optimistic oracle into a ‘Turing complete’ oracle
27:31 Behind the scenes on the Optimistic Oracle design
31:53 What is Across: bridging as a lending problem vs bridging as a swapping problem
34:00 The Across Hub & Spoke Model For Liquidity
38:00 Can you pass call data across chains with Across?
39:30 The use of ‘bundles’ in Across
49:20 Favorite UMA design patterns
52:03 UMA engineering design practices
58:04 Chris’ approach to security and engaging auditors
1:00:06 Trends Chris is excited about (Cross chain MEV, NFT derivatives)
1:02:50 Chris’ long term vision for the future of crypto
Links: https://docs.umaproject.org/
Chris on Github: https://github.com/chrismaree
Today, we have Austin Griffith, dev tooling & dev education extraordinaire. He’s the creator of countless high value dev tools, including ETH.Build, Scaffold-ETH, and Speed Run Ethereum. In this episode, we discuss Austin’s process for building developer tooling, new developments that Austin is excited about at the application layer, and how to level up as a solidity developer.
00:23 How Austin got into Ethereum
2:23 Austin walks through the first dapps he ever built: games
4:28 Austin’s entry into dev tooling
8:15 ETH.Build
13:40 Scaffold-ETH
21:47 Speed Run Ethereum
27:45 Taking a PM approach to building dev tooling
30:36 Austin shouts out other great devrel resources
33:02 Becoming an elite web3 developer
40:40 The state of existing dev tooling
47:49 New developments in the application layer that Austin is excited about
49:30 Nifty Ink - using meta transactions to improve UX
56:03 Austin’s vision for web3 in 10 years: public keys will be as ubiquitous as an email address
Links:
Scaffold ETH: https://docs.scaffoldeth.io/scaffold-eth/
Speed Run Ethereum: https://speedrunethereum.com/
Austin on Twitter: https://twitter.com/austingriffith
Ethereum Resources: https://ethereum.org/en/developers/
On the Devs Do Something podcast, we bring you technical discussions with some of the best and brightest engineers in all of web3. Today, we have Rahul Sethuram - CTO & cofounder of Connext.
Connext is building the first fully trust-minimized Crosschain Communication protocol to make blockchains composable.
Rahul has been in the space for the better part of 5 years - he started his career at tesla and worked in various startups business before getting into crypto. In this episode, you’ll hear more about his journey through the proverbial idea maze as he iterated his way into building Connext, and you’ll also get an inside look into the technical side of building cross chain infrastructure.
In this episode, we hit on a ton of fascinating technical topics: you’ll hear us walk through optimistic bridge design, Connext’s engineering & design process (including how they navigated multiple re-writes), Rahul’s favorite non-EVM tech in the space, & we’ll even walk through the full lifecycle of a cross chain operation on Connext.
If you’re a web3 engineer or work alongside engineers, we think you’ll get a lot of value from this one.
00:00 Intro
3:13 How Rahul got into Web3
6:18 Connext origin story
9:00 The interoperability trilemma
10:29 Optimistic bridges
14:40 Walking through the lifecycle of a cross chain transaction using Connext
22:42 Cross chain callbacks and “asynchronous” solidity
27:14 Design patterns that Rahul is proud of (including a cool custom errors implementation)
29:46 Behind the scenes insight on how Connext iterated from their initial state channels implementation to their current model
34:49 How Connext handles development cycles
36:10 The Connext approach to managing security and protocol maintenance
39:12 Upgradable contracts vs full immutability
40:43 Beyond the EVM
45:28 Issues with validity proofs in cross chain infrastructure
48:53 Web3 tech that Rahul is excited about
50:41 Cross chain MEV and arbitrage opportunities
52:43 Rahul’s long term vision for the industry
Links
Connext: https://www.connext.network/
Rahul: https://twitter.com/rhlsthrm
The Interoperability Trilemma: https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17
Optimistic Bridges: https://blog.connext.network/optimistic-bridges-fb800dc7b0e0
Problems with Validity Proofs When Used in Bridging: https://blog.connext.network/validity-proofs-are-not-effective-for-bridging-blockchains-85b5e3b22a35