smart-contracts | Smart Contracts for Identity.com | Cryptocurrency library

But what about contract rewards and other funds belonging to the contract account? How would the original owner get access to that if keys are deleted?

The contract should be implemented in such a way that would allow certain operations.

Let's take a lockup contract as an example. This contract has a single owner, and the funds are locked for a certain amount of time, and the contract only provides certain methods to be called and guarded with the specific logic:

• As an owner, I can delegate (stake) my tokens to staking pools while I still cannot arbitrary transfer the tokens
• As an owner, I can withdraw the rewards from the staking pool through the lockup contract, and transfer those to an arbitrary account
• Once the lockup time is over, as an owner, I can call add_full_access_key function, and thus gain full access over the account, and even delete it after that (transferring all the tokens to some other account).

All that is explicitly implemented on the contract level, and easy to review, and given there is no other AccessKey on the lockup contract, we can be sure that there is no other way to interfere with the contract logic.

Here is rough guide

1. Get ABI for Uniswap contract

2. Create a web3.py contract object

3. You can use web3.eth.getLogs() to query events over past block range

4. You cannot query all events once, because there are so many events and Infura would time out. Instead you need to query events carefully over a block range slices.

Here is some old code which may or may not work with the latest web3.py versions

https://github.com/TokenMarketNet/sto/blob/master/sto/ethereum/scanner.py#L153

If you want a real time scanner you can listed to events over a WebSocket connection as they happen:

https://web3py.readthedocs.io/en/stable/filters.html#asynchronous-filter-polling

This is a contract created by another contract. So there's no chance for the developer to set an ABI.

You should refer to the creator contract's code.

The only way to catch an exception is to have a callback on the promise that generated the exception.

In the explained scenario, the contractA.callback() shouldn't crash. You need to construct the contract carefully enough to avoid failing on the callback. Most of the time it's possible to do, since you control the input to the callback and the amount gas attached. If the callback fails, it's similar to having an exception within an exception handling code.

Also note, that you can make sure the callback is scheduled properly with the enough gas attached in contractA.run(). If it's not the case and for example you don't have enough gas attached to run, the scheduling of callback and other promise will fail and the entire state from run changes is rolled back. But once run completes, the state changes from run are committed and callback has to be carefully processed.

We have a few places in lockup contract where the callback is allowed to fail: https://github.com/near/core-contracts/blob/6fb13584d5c9eb1b372cfd80cd18f4a4ba8d15b6/lockup/src/owner_callbacks.rs#L7-L24

And also most of the places where the callback doesn't fail: https://github.com/near/core-contracts/blob/6fb13584d5c9eb1b372cfd80cd18f4a4ba8d15b6/lockup/src/owner_callbacks.rs#L28-L61

To point out there are some situation where the contract doesn't want to rely on the stability of other contracts, e.g. when the flow is A --> B --> A --> B. In this case B can't attach the callback to the resource given to A. For these scenarios we were discussing a possibility of adding a specific construct that is an atomic and has a resolving callback once it's dropped. We called it Safe: https://github.com/nearprotocol/NEPs/pull/26

What if contractB.run fails and I will like to update the state in contractA to rollback changes from contractA.run?

In this case contractA.callback() is still called, but it has PromiseResult::Failed for its dependency contractB.run.

So callback() can modify the state of contractA to revert changes.

For example, a callback from the lockup contract implementation to handle withdrawal from the staking pool contract: https://github.com/near/core-contracts/blob/6fb13584d5c9eb1b372cfd80cd18f4a4ba8d15b6/lockup/src/foundation_callbacks.rs#L143-L185

If we adapt names to match the example:

The lockup contract (contractA) tries to withdraws funds (run()) from the staking pool (contractB), but the funds might still be locked due to recent unstaking, so the withdrawal fails (contractB.run() fails). The callback is called (contractA.callback()) and it checks the success of the promise (of contractB.run). Since withdrawal failed, callback reverts the state back to the original (reverts the status).

Actually, it's slightly more complicated because the actual sequence is A.withdraw_all -> B.get_amount -> A.on_amount_for_withdraw -> B.withdraw(amount) -> A.on_withdraw

If you try to compile your code you'll see an error like below

The purpose of a registry contract is to store a mutable reference to the latest versions of your smart contract modules. It serves as a first point of access for your decentralized application.

So there are two options if you want to upgrade a registry contract:

• have another (fixed) registry contract pointing to your (dynamic) registry contract
• update the reference to your registry contract in all places that use it (i.e. the frontend application)

I hope this answers your question.

I had the same error with my contract. Check your solc compiler version with truffle version and check solidity version of your contract. In my case, compiler was Solidity v0.5.0 (solc-js), but the contract had pragma solidity ^0.4.11; I simply changed it to pragma solidity ^0.5.0 and reformatted code to its version requirements, contract compiled fine after. Another way to solve the problem is to edit truffle config by adding:

I hope you have found a solution to your question half a year down but if you have not then..

Yes, you are correct in your observation that the {from: thesponsor, value: 10000000, gas: 3000000} is interpreted as a transactionObject. This is because any transaction on Ethereum that causes a state change (meaning you create, update or delete data) requires a transactionObject such as the one seen above to allow your code to be executed on the blockchain.

In the snippet below, you can see that the pledge function causes a state change on lines 4 and 5. That alone requires that you provide gas for the transaction. In addition, the pledge makes use of msg.value which is the value of the Ethereum amount that you are sending in the pledge, denoted by the value.

They are in magical variable msg. The function pledge uses this variable in the following line: