DEV Community: Antoni Pawlak

Starknet permissioned addresses

Antoni Pawlak — Tue, 12 Jul 2022 11:23:58 +0000

Starknet core

Who can upgrade implementation?

onlyGovernance - EOA

Who can `setProgramHash`, `setConfigHash`, `setMessageCancellationDelay`

onlyGovernance - EOA

Who can `updateState`

onlyOperator - EOA

Who can `registerOperator` and `unregisterOperator`

onlyGovernance - EOA

Who manages governors

onlyGovernance - EOA

ETH Bridge

Who can upgrage implementation

onlyGovernance - EOA

Who manages governors

onlyGovernance - EOA

Who can `setL2TokenBridge`, `setMaxDeposit`,

onlyGovernance - EOA

L1DaiBridge

Who can `setCeiling`, `setMaxDeposit` and manage auth

auth - MakerDAO

L1Escrow

Who can `approve` token transfers

auth - MakerDAO

ImmutableX permissioned addresses

Antoni Pawlak — Mon, 11 Jul 2022 11:08:03 +0000

Bridge

Who can upgrade implementation

onlyGovernace - EOA

Who can `updateState()`

onlyOperator - EOA

Who manages operators and verifiers

onlyGovernace - EOA

DAC Committee

Who can upgrade implementation

on one, contract is not a proxy

Who can `verifyAvailabilityProof()`

anyone, but it needs to be signed by at least 5 DAC members

DAC members addresses
0x1ffbdb8061b586a6d29fb608d025e5d8744f58d1
0x24eeffc269bb8e540f5b2c8f45750489abf8d54b
0x48af849535ddfa560a0eb0fbdef436688169b949
0x51abde72a4542500a7b1cb32b18b13fbe1f9ff2e
0xafc4589af46c72cbf550f2eeae38c97aede15d17
0xb71fc111d7ba82d5955baddd7717f3467184ff61
0xff506616e8c53ee5e513b906ac00b5d76664c537

STARK Verifier

Who can upgrade implementation

onlyGovernance - EOA

Who can `verifyProofAndRegister()`

anyone, but the smartcontracts are guiding correctness

dYdX permissioned addresses

Antoni Pawlak — Mon, 11 Jul 2022 10:33:23 +0000

Bridge

Who can upgrade the implementation?

onlyGovernance - Governance Contract

What are the implications?

code can be substituted with arbitrary code which in the worst case scenario means your funds can be stolen

Who can update state?

onlyOperator - EOA designated by governance

Who manages verifiers and operators

onlyGovernance - Governance Contract

GPS Statement Verifier

Who can upgrade the implementation?

onlyGovernance - EOA in this case it is EOA, I wonder why they haven't used governance mechanism here also

What are the implications?

implementation can be upgraded so the method verifyProofAndRegsiter() can return true every time which means that the fraudulent state can be commited to the rollup

Memory Page Fact Registry

Who can upgrade implementation?

no one, contract is not upgradable

Who can `registerContinuousMemoryPage()`

anyone, method is public

FRI Statement

Who can upgrade implementation?

no one, contract is not upgradable

Who can `verifyFRI()`

anyone, method is public

Merkle Statement

Who can upgrade implementation?

no one, contract is not upgradable

Who can `verifyMerkle()`

anyone, method is public

We can clearly see that current dYdX implementation is far from being decentralised

dYdX Governance Mechanism

Antoni Pawlak — Tue, 05 Jul 2022 15:08:09 +0000

Who controls dYdX bridge ?

Ownership

dYdX Bridge is a Proxy 0xd54f... can be upgraded via upgradeTo(...) onlyGovernance method
Current governor is StarkExRemoverGovernorV2 0xfcaa...
Admin of StarkExRemoverGovernorV2 is PriorityExecutor 0xa306...
Admin of PriorityExecutor is DydxGovernor 0x7e9b...
Current governance strategy is GovernanceStrategy 0x90df

Logic

voting power is held by dydx token owners

the proposal goes through stages Pending => Active => Succeeded => Queued => Executed

Proposal creation

DydxGovernor.create(...)

Requirements for creation

PriorityExecutor.validateCreatorOfProposal()

What is being checked

GovernanceStrategy.getPropositionPowerAt() >= getMinimumPropositionPowerNeeded()

getMinimumPropositionPowerNeeded()

GovernanceStrategy.getTotalPropositionSupplyAt(blockNumber)
        .mul(PROPOSITION_THRESHOLD)
        .div(ONE_HUNDRED_WITH_PRECISION)
//PROPOSITION_THRESHOLD = 50
//ONE_HUNDRED_WITH_PRECISION = 10000

current proposal threshold is 0.5%

so anyone with at least 0.5% of total supply of dydx token can create a proposal

Voting result

voting succeeds when

PriorityExecutor.isProposalPassed() && executionTime = 0`

it means the proposal was voted for by a majority and was not yet executed, now it can be enqueued for execution

What is being checked

isQuorumValid(governance, proposalId) && isVoteDifferentialValid(governance, proposalId)

isQuorumValid

proposal.forVotes >= getMinimumVotingPowerNeeded(votingSupply)

getMinimumVotingPowerNeeded()

votingSupply.mul(MINIMUM_QUORUM).div(ONE_HUNDRED_WITH_PRECISION)
//MINIMUM_QUORUM=200

current minimum quorum is 2%

isVoteDifferentialValid

proposal.forVotes.mul(ONE_HUNDRED_WITH_PRECISION).div(votingSupply) > proposal.againstVotes.mul(ONE_HUNDRED_WITH_PRECISION).div(votingSupply).add(VOTE_DIFFERENTIAL)
//VOTE_DIFFERENTIAL=50

current VOTE_DIFFERENTIAL is 0.5%

Execution

when the vote succeeds it can be executed by executor

dydx token

The token contract is at 0x92d5

Current total supply is 1,000,000,000
Minimum amount to create proposal is 5,000,000
Minimum quorum is 20,000,000

there are:

21 addresses who can create a proposal
8 addresses that can singlehandedly push proposal (if no other address votes)

fallback() | Ethernaut #01:

Antoni Pawlak — Thu, 30 Jun 2022 13:30:29 +0000

What happens when you call the function that does not exist, or send ether to a contract via send() or transfer() ?

`fallback() external [payable] {...}`

executes when:

function does not exist in contract
ether transfer with non-empty call data
ether transfer when there is no receive() function

`receive() external payable {...}`

executes when:

ether transfer with empty calldata

Code example

contract TestPayable {
    uint x;
    uint y;

    fallback() external payable { x = 1; y = msg.value; }

    receive() external payable { x = 2; y = msg.value; }
}

address(contract).transfer(AMOUNT) => x=2
address(contract).call{value:1}(abi.encodePacked("SOME")) => x=1

Real-world usage: Proxy

Let's look at the code of Proxy.sol

proxy.foo(...)
foo(...) does not exist in proxy's source code
fallback is triggered
make delegatecall(...) on implementation
return result

Thanks to fallback function arbitrary function can be called on a proxy. Without it we would have to create more complicated mechanism.

Why `receive()` was introduced?

To make explicit check if msg.data is empty. Without it, it was up to the programmer to check whether calldata is empty.
Better UX for plain ETH transfers, so the user who didn't put calldata could be handled independetly. receive() function enforced on programmers thinking about such cases.

Ethernaut 01: Fallback

There was a fallback method which granted you ownership if you contributed before and supplied some ether. This way your contribution could be less than owner but still you can gain ownership.

Interact with contract using web3.js
Send ether when interacting with an ABI
- contract.contribute({value: AMOUNT_IN_WEI})
Send ether outside of the ABI docs
- contract.sendTransaction({value: AMOUNT_IN_WEI})

Level completed at tx

sources:
forum answer

medium blog post

solidity docs

stackexchange

Get hourly data from Coingecko API

Antoni Pawlak — Wed, 09 Feb 2022 21:17:27 +0000

📋 Task

Get hourly price data on an arbitrary time period from Coingecko API

🤯 Problem

Hourly granularity is available only in 1-90 days span

💡 Solution

Cut bigger time frames on multiple 90-day calls

❓ How

await Promise.all() decent blog post about it

DEV Community: Antoni Pawlak

Starknet permissioned addresses

Who can upgrade implementation?

Who can setProgramHash, setConfigHash, setMessageCancellationDelay

Who can updateState

Who can registerOperator and unregisterOperator

Who manages governors

Who can upgrage implementation

Who manages governors

Who can setL2TokenBridge, setMaxDeposit,

Who can setCeiling, setMaxDeposit and manage auth

Who can approve token transfers

ImmutableX permissioned addresses

Who can upgrade implementation

Who can updateState()

Who manages operators and verifiers

Who can upgrade implementation

Who can verifyAvailabilityProof()

Who can upgrade implementation

Who can verifyProofAndRegister()

dYdX permissioned addresses

Who can upgrade the implementation?

Who can update state?

Who manages verifiers and operators

Who can upgrade the implementation?

Who can upgrade implementation?

Who can registerContinuousMemoryPage()

Who can upgrade implementation?

Who can verifyFRI()

Who can upgrade implementation?

Who can verifyMerkle()

dYdX Governance Mechanism

Ownership

Logic

Proposal creation

Requirements for creation

What is being checked

getMinimumPropositionPowerNeeded()

Voting result

What is being checked

isQuorumValid

getMinimumVotingPowerNeeded()

isVoteDifferentialValid

Execution

dydx token

fallback() | Ethernaut #01:

fallback() external [payable] {...}

receive() external payable {...}

Code example

Real-world usage: Proxy

Why receive() was introduced?

Ethernaut 01: Fallback

Get hourly data from Coingecko API

📋 Task

🤯 Problem

💡 Solution

❓ How

Create a method to call an API | docs

Generate suitable time ranges

Make multiple calls to an API

Have a nice day! 🤓

Who can `setProgramHash`, `setConfigHash`, `setMessageCancellationDelay`

Who can `updateState`

Who can `registerOperator` and `unregisterOperator`

Who can `setL2TokenBridge`, `setMaxDeposit`,

Who can `setCeiling`, `setMaxDeposit` and manage auth

Who can `approve` token transfers

Who can `updateState()`

Who can `verifyAvailabilityProof()`

Who can `verifyProofAndRegister()`

Who can `registerContinuousMemoryPage()`

Who can `verifyFRI()`

Who can `verifyMerkle()`

`fallback() external [payable] {...}`

`receive() external payable {...}`

Why `receive()` was introduced?