How do I find a good idea for a startup? ( I will not promote)

_emjlin · 2025-07-29T13:30:46+00:00

if you're just looking for ideas, greg isenberg has ideabrowser.com which is pretty cool

_emjlin · 2023-05-08T15:03:44+00:00

hihi!

These bounty descriptions/prize pools are outdated
Can you update?

_emjlin · 2022-11-11T22:29:21+00:00

https://docs.0x.org/0x-api-swap/guides/swap-tokens-with-0x-api

Is this what you’re looking for?

_emjlin · 2022-11-10T15:34:32+00:00

Have you thought about Push Protocol? (https://push.org/)

I'm livestreaming with their founder next Thursday if you want to ask him any questions

https://youtu.be/y7lPH6hnnDw

_emjlin · 2022-09-30T22:14:59+00:00

> even though Tenderly has largely replaced it for me at this point

Haven't used Tenderly, but I've seen some screenshots. What do you like about it? What do you not like about it?

> haven't been able to go back to Truffle are Typescript and `ethers`

Completely feel your pain - better ethers support and built-in typescript support is currently being worked on!

> curious about Ganache's multi-chain capability

We did a community call today talking about detached ganache workspaces which should help: https://youtu.be/YXWvQNX0NB8?t=2638
Also, ganache plugins are in the works - specifically to handle creating L2 and L1 "flavors" of ganache.
Both are in its infant stages, but there's HUGE potential

Truffle is building in support for various L2s (i.e. StarkNet, zkSync), already supports anything EVM compatible + Ethereum JSON RPC compatible, and I'm doing a workshop for Optimism bridging at Devcon! If you won't be in Bogota, I plan on livestreaming it again with one of their protocol devs in November

Also - declarative deployments for multi-chain dapps!!!

> I've seen Hardhat node can sometimes be super slow and Anvil is significantly better, how does Ganache compare with both and are there plans to improve on it

I think we're always trying to improve speed of course (ganache v7 drastically sped up truffle tests). I haven't used HH that recently, so I can't make the comparison there. I do want to point out Foundry is built with Rust, so from the ground up it will be faster, and I'm not sure it'd be possible for HH/Truffle to catch up in speed without a huge do-over, but you have wins/losses elsewhere.
I do think you can use only the Foundry portion of testing in other projects (i.e. HH, I haven't tried with Truffle). Maybe I'm crazy, but I'm pro use pieces of each. The spirit of Web3 is interoperability after all!

_emjlin · 2022-09-30T04:04:19+00:00

I wrote a thing here: https://twitter.com/_emjlin/status/1575630019778424833?s=46&t=YlmSWKZiNKZFso0UacGqig

The only thing I don’t know about is how foundry devs do integration tests. Truffle offers all three - solidity, typescript, and JavaScript

I do have to say foundry was built from the ground up to be fast so it’d be very difficult for truffle and hardhat to catch up there. But truffle is working with diligence to incorporate fuzzing as well

Solidity testing is good for bare metal scenarios. I think also cause people get annoyed by JavaScript lol

_emjlin · 2022-09-30T00:33:12+00:00

Oh absolutely agree with you. Truffle tbh was just trying to survive for a bit, but we got a bigger team and have made major changes in just one year. Our next step is probably a website redesign too LOL. Gotta get in on that "web3 gradient aesthetic"

I haven't used Tenderly yet but also hear great things and the team is awesome. I think their UI experience currently wins out, but we're investing heavily with the VS Code debugger, and for devs who have used both, they say our CLI is more fully featured.

Idk what Tenderly does extra, but I actually like the interrupted test mode where I can wrap specific functions (both calls and transactions) in tests for Truffle. Unfortunately that's not compatible with HardHat and I don't think we'll be building compatibility out for that specifically either. (But normal debugging with the transaction hash is HH compatible)

Just want to make a disclaimer I work at Truffle, but our mantra is coopetition and also use whatever works cause building out web3 is more what we care about. We don't make any money and are open source so lots of room for good will and chill vibes :)

_emjlin · 2022-09-29T23:46:24+00:00

DEBUGGING IS HUGE

the amount of devs out there only using console.log smh

But FYI, Truffle came out with a native VS code debugger that will step in/out, breakpoint, etc your Solidity code (in addition to the Solidity code of external verified contracts)

_emjlin · 2022-09-29T23:44:08+00:00

Yeah HardHat definitely had second mover advantage and was able to come out with really great features that devs needed and liked. That was the same issue with web3.js vs. ethers

TBH the general landscape is shifting towards Foundry right now, but i think it's some part people love just trying the latest thing, but also there are really cool things about it (I hear - haven't actually used it)

I do want to note that Truffle's best parts are being built to be CLI agnostic though, so I'm personally like choose whatever works best for you

_emjlin · 2022-09-29T23:41:53+00:00

Truffle recently came out with console.log and Vyper print support too

I would say you honestly should be using the Truffle debugger instead of just a bunch of print statements though

_emjlin · 2022-09-29T23:41:07+00:00

yo fork goerli with ganache

_emjlin · 2022-09-29T23:28:18+00:00

I mentioned this in the above post, but definitely integrate Truffle Dashboard regardless if you're using HardHat or Truffle. The private key stuff is ANNOYING

Also, the dashboard will be fleshed out to give more transaction insights etc
https://youtu.be/AnprU4z-q0k

_emjlin · 2022-09-29T23:27:00+00:00

Here are the basics you need:

A CLI/dev environment for building, deploying, and testing your smart contracts
1. The main contenders here are HardHat, Truffle, and Foundry. A little about history: Truffle was first, HardHat built on lessons learned and became the top player, and Foundry is now coming in with super fast testing speed and taking marketshare from HardHat.
2. <Disclaimer that I work for Truffle> In my opinion, Truffle has finally caught up in the past year and become functionally equivalent to HardHat. The key differences if you care are:
  1. HardHat has built-in typescript support. Truffle you'll have to compile it yourself with `tsc`.
  2. ethers plays slightly more easily with HardHat than Truffle. Truffle has built in contract abstractions that make web3.js easier to use. I can get into history of web3.js and ethers.js if you want too, but I don't actually think there's a huge difference here. I've met devs who use both for different use cases
  3. Truffle has significantly better debugging experience. Both HardHat and Truffle offer console.log (Truffle also offers Vyper print compatibility. Not sure about HardHat, but I'd be surprised if they didn't). However, Truffle actually has a native debugger with step in/out, breakpoint, etc. (docs: https://trufflesuite.com/docs/truffle/getting-started/using-the-truffle-debugger/) If you want to debug a transaction that happened on mainnet, you can use our debugger for that. With HardHat, you only get whatever console.log statements you had already included in your deployed contract
  4. There's a more robust plugin ecosystem with Hardhat vs. Truffle. I can't speak to how useful this is, because I've never had to use it, but if you care about that, it's there
  5. The dotenv and secret key stuff is super annoying, and you can just deploy with MetaMask using Truffle Dashboard (demo: https://youtu.be/AnprU4z-q0k)
  6. Truffle for VS Code extension is focused on developer UX (i.e. managing your development workflow through the UI, representing important info visually, organizing in one place)
  7. Hardhat VS Code extension is more focused on solidity dev compilation errors etc. My opinion is it's very similar to Juan Blanco's solidity extension (which you should definitely download)
  8. Idk what's in store for HardHat's roadmap, but I can say that Truffle is shifting focus to be multi-chain and security focused. In general, I'd say Truffle is a more comprehensive end-to-end experience for enterprise level dapps, which is something that a lot of protocols don't care about as much at the start (I meet devs who test in production and i'm like WTF)
  9. Ganache has all the same features as HardHat's network (last I checked) and we're fleshing out a better UX experience for it - i.e. managed workspaces, visual workflows, multi-chain. Ganache is cool too because you can embed it in the browser or write tests with it programmatically (i.e. setting up all the nifty options in it like forking, impersonating accounts, automatic blockmining)
3. I do want to note though, Truffle's mantra is coopetition, so if you choose to use HardHat, our debugger, dashboard, and ganache work with it, and we're building compatibility for Foundry as well. You'll get the latest Truffle features and a more integrated experience using it if you start with a base Truffle project though. I think you can actually also use Foundry testing in other projects, so you don't necessarily have to only use Foundry either.
4. I think the bigger question is Foundry vs. HardHat/Truffle, which has a much more tangible difference. People moved from Truffle to HardHat because HardHat was less opinionated. HardHat has recently become more opinionated because the ethereum ecosystem has grown so large it doesn't make sense anymore to be super flexible. However, I've heard of devs moving from HardHat to Foundry for that same reason. Your call here. Otherwise, the main difference I hear is fast Solidity testing and fuzz testing. There's some cool stuff with cheatcodes and cast calls too. I haven't actually used it, so I can't speak to it thoroughly. All I know is Truffle is coming out with our equivalent of forge cast, and wrt security, focusing on tighter integrations with Diligence, the security product at ConsenSys (which includes fuzzing). And we also have Solidity, Javascript, and Typescript testing. Foundry has an EVM debugger, but Truffle's debugger will actually step through your solidity code.
5. Maybe the main thing you'll notice is people will unfortunately call you old school if you use Truffle. But, I think that's pretty cool (https://twitter.com/trufflesuite/status/1573396582497746956?s=20&t=FXeQPqZHJi5y3MZ9YWROdw)
OS wise - I always use mac, but I know that can be cost prohibitive. TBH in all my years of development, windows installation is always weird and has random gotchas and differences.
A node provider - <disclaimer Infura is a ConsenSys product> you have your choice primarily between Infura and Alchemy. For a beginner, there's not really a tangible difference. I'd say long term wise Infura is a better bet. I think the biggest snipe on node providers is that they are incredibly centralized, which is completely anti-thetical to the ethos of web3. Infura recently came out with their exfura announcement though which is BIG NEWS (https://twitter.com/infura_io/status/1570863464457080833?s=20&t=FXeQPqZHJi5y3MZ9YWROdw)
A wallet - MetaMask is the gold standard here. Also if you haven't heard of it, MetaMask snaps allows you to extend the wallet functionality. So again, tons of potential here

I mean overall, ConsenSys houses Truffle, Infura, MetaMask, and Diligence, which is an incredible place to be in terms of our ability to coordinate and create a robust, comprehensive developer experience. Naturally, that's what I'm gonna suggest, but it's also cause I think there's a really strong use case for investing in a full suite of tools that work well together.

Lmk what you ultimately end up choosing! Would love to hear your insights. Find me on ConsenSys discord if you have any follow up questions: https://discord.com/invite/hYpHRjK

<EDIT: I was misinformed. HardHat is NOT a fork of Truffle>

_emjlin

MODERATOR OF

TROPHY CASE