A (Erc20) token contract is should typically be quite straightforward and you wouldn't need to consider how it is used as the functionality is mostly standardized.
A dapp doesn't require a token in any way, most dapps don't use any specific token but may be mostly used for interacting with any token.
You are correct that once a token contract is deployed it can't be modified or deleted.

Thank you

I'm curious to know how tokens have use cases. I get you can exchange them for other tokens but what other uses do they have.

That's a rather wide topic :)
Google would probably give you a lot more ideas but here's some:
- virtual asset which may or may not represent a real-world asset. For example a stablecoin (pegged to some fiat) or a token which singifies real-life share or security or a physical asset such as a car
- a governance token: anyone who has 1 token can vote on changes on the token's platform (or the more more tokens you have the more votes you have)
- a token signifying something, for example identification (if you have this token you are this person) or memorabilia (if you have this token you participated in thing X in the past)
- a scam or a vehicle of pure speculation

An important difference is the difference between fungible and non-fungible tokens - I used them both in the above examples. Check google for the meaning

I just was sorry about that. i have one more question if it's ok. The root of why I've been asking the question about the contracts is because I've been under the impression that when you open a smart contract or create a token you are creating an IEO.

It seams that when they are tied to an underlying asset they would be considered a derivative but they do have other uses so not all tokens would be derivatives

well that's more about legislation (under which legislation is a decentralized asset?) and a whole different, complicated topic. I doubt you would have legislative issues just by deploying a contract, I'd imagine it's more about how it's used

Thanks do you happen to know of a token that has assets in it. I'd like to take a look at one to see how they work.

I'll probably try deploying one tomorrow on the test network

for fun

I'm not sure what you mean. Tokens don't "have" things inside them - they represent something

You’d probably want to understand what smart contracts are as well as what the evm is, as a solid foundation for undertaking learning about how these programs issue stores of value between different users. For instance, a token is exactly a single smart contract which only stores the balances of various addresses on the blockchain.

So basically they're separate from the dapp

Got it will do thanks

oh yeah thats right

estimateJoinRound(account, amount) {
return new Promise(async (resolve, reject) => {
_web3.eth.getGasPrice((error, gp) => {
const gasPrice = Number(gp);
const BN = _web3.utils.BN;
const deposit = new BN(amount);
Whackd.methods.approveAndCall(whackersAddress, deposit, utilities.toUTF8Array("Play Whackers!")).estimateGas(
{from: account, gasPrice: gasPrice})
.then((g) => {
const gas = Number(g);
const calc = gas * gasPrice;
const BN = _web3.utils.BN;
const price = new BN(calc);
resolve({gas: gas, gasPrice: gasPrice, totalWei: calc, totalEth: _web3.utils.fromWei(price)})
})
.catch((error) => {
// gas required exceeds allowance (8000029) or always failing transaction
reject(error);
})
})
});
}

Thats what I've been doing

In Python, how do you deal with asynchronous calls?

definitely a lot of ornery conversion tidbits in that function. I am sure there are a hundred ways to do it better...

can you be a bit more specific?

like, say you wanted to await some block confirmations after you sent a transaction

in web3js, you just subscribe to a callback function

in brownie, you add required_confs=n in the transactions kwargs, and the action is blocking until you get the requested number of confirmations

or you mean you want to be waiting on the confs and also doing other things? then you'd have to use threading.

import threading

t = threading.Thread(accounts[0].transfer, args=(...))
t.start()

...

t.join()

Web.py dosent have a callback function. That really sucks, we may have to spin our own thread

I never delved into python but it seems like brownie might be where it's at https://eth-brownie.readthedocs.io/

https://eth-brownie.readthedocs.io/en/stable/core-accounts.html#broadcasting-multiple-transactions

I will look into brownie. Thanks

if you set required_confs=0 it's nonblocking. you get back a transaction object immediately while it's still unconfirmed. you can then later call tx.wait() if you need to wait for it to confirm

required_confs=10 will block until it gets 10 confirmations.. etc

is it me or is that server dead slow

🙏

So am I gathering it right that brownie is basically some sort of truffle sort of thing?

but actually works on a production environment

production or a local dev environment

it uses ganache for dev environment, same as truffle

so yeah, this is accurate

I dont really care much for truffle, a necessary evil

neither did i.. it's why i built brownie :)))

cant get it to run on > Node 10

tho my distaste is more for JS in general

yeah i agree, if i were to do it again id learn rust

I'm just an entrepreneur looking for various businesses to start so Javascript is really hacky, it kind of matches my personality

I did a bunch of iPhone apps before, it was nice being strongly typed

Well yes, one can often exist without the other. Dapp just may utilize some token(s)

Are any of you all building on Layer 2?

You created brownie?