Skip to content

Commit

Permalink
update dep tree
Browse files Browse the repository at this point in the history
  • Loading branch information
@jwasinger
jwasinger committed Dec 16, 2024
1 parent a009c60 commit a30ccd5
Show file tree
Hide file tree
Showing 2 changed files with 39 additions and 52 deletions.
8 changes: 3 additions & 5 deletions accounts/abi/bind/bind.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -70,10 +70,6 @@ func isKeyWord(arg string) bool {
return true
}

func add(val1, val2 int) int {
return val1 + val2
}

// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant
// to be used as is in client code, but rather as an intermediate struct which
// enforces compile time type safety and naming convention as opposed to having to
Expand Down Expand Up @@ -179,7 +175,9 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin
"bindtopictype": bindTopicType,
"capitalise": capitalise,
"decapitalise": decapitalise,
"add": add,
"add": func(val1, val2 int) int {
return val1 + val2
},
}
tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2))
if err := tmpl.Execute(buffer, data); err != nil {
Expand Down
83 changes: 36 additions & 47 deletions accounts/abi/bind/dep_tree.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,35 +7,30 @@ import (
"strings"
)

// ContractDeployParams represents state needed to deploy a contract:
// the metdata and constructor input (which can be nil if no input is specified).
type ContractDeployParams struct {
Meta *MetaData
// Input is the ABI-encoded constructor input for the contract deployment.
Input []byte
}

// DeploymentParams represents parameters needed to deploy a
// set of contracts, their dependency libraries. It takes an optional override
// list to specify libraries that have already been deployed on-chain.
// set of contracts. It takes an optional override
// list to specify contracts/libraries that have already been deployed on-chain.
type DeploymentParams struct {
Contracts []*MetaData
Inputs map[string][]byte
// map of solidity library pattern to constructor input.
Inputs map[string][]byte
// Overrides is an optional map of pattern to deployment address.
// Contracts/libraries that refer to dependencies in the override
// set are linked to the provided address (an already-deployed contract).
Overrides map[string]common.Address
}

// DeploymentResult contains the relevant information from the deployment of
// multiple contracts: their deployment txs and addresses.
// DeploymentResult encapsulates information about the result of the deployment
// of a set of contracts: the pending deployment transactions, and the addresses
// where the contracts will be deployed at.
type DeploymentResult struct {
// map of contract library pattern -> deploy transaction
Txs map[string]*types.Transaction
// map of contract library pattern -> deployed address
Addrs map[string]common.Address
}

// Accumulate merges two DeploymentResult objects together.
func (d *DeploymentResult) Accumulate(other *DeploymentResult) {
for pattern, tx := range other.Txs {
d.Txs[pattern] = tx
Expand All @@ -45,8 +40,8 @@ func (d *DeploymentResult) Accumulate(other *DeploymentResult) {
}
}

// depTreeBuilder turns a set of unlinked contracts and their dependent libraries into a collection of trees
// representing the relation of their dependencies.
// depTreeBuilder turns a set of unlinked contracts libraries into a set of one
// or more dependency trees.
type depTreeBuilder struct {
overrides map[string]common.Address
// map of pattern to unlinked contract bytecode (for libraries or contracts)
Expand All @@ -67,8 +62,7 @@ type depTreeNode struct {
overrideAddr *common.Address
}

// returns the subtree as a map of pattern -> unlinked contract bytecode. it excludes the code of the top-level
// node.
// Flatten returns the subtree into a map of pattern -> unlinked contract bytecode.
func (n *depTreeNode) Flatten() (res map[string]string) {
res = map[string]string{n.pattern: n.unlinkedCode}
for _, child := range n.children {
Expand All @@ -81,6 +75,7 @@ func (n *depTreeNode) Flatten() (res map[string]string) {
return res
}

// buildDepTrees is the internal version of BuildDepTrees that recursively calls itself.
func (d *depTreeBuilder) buildDepTrees(pattern, contract string) {
// if the node is in the subtree set already, it has already been fully recursed/built so we can bail out.
if _, ok := d.subtrees[pattern]; ok {
Expand All @@ -93,7 +88,7 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) {
if addr, ok := d.overrides[pattern]; ok {
node.overrideAddr = &addr
}
// iterate each referenced library in the unlinked code, recurse and built its subtree.
// iterate each referenced library in the unlinked code, recurse and build its subtree.
reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`)
if err != nil {
panic(err)
Expand All @@ -111,14 +106,12 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) {

// BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree
// corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are
// its library dependencies.
// its library dependencies. It returns nodes that are roots of a dependency tree and nodes that aren't.
func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode, nonRoots []*depTreeNode) {
// before the trees of dependencies are known, consider that any provided contract could be a root.
for pattern, _ := range d.contracts {
d.roots[pattern] = struct{}{}
}

// recursively build each part of the dependency subtree by starting at
for pattern, contract := range d.contracts {
d.buildDepTrees(pattern, contract)
}
Expand All @@ -141,34 +134,32 @@ func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string
}
}

type deployFn func(input, deployer []byte) (common.Address, *types.Transaction, error)
// DeployFn deploys a contract given a deployer and optional input. It returns
// the address and a pending transaction, or an error if the deployment failed.
type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, error)

// depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper
// order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result.
type depTreeDeployer struct {
deployedAddrs map[string]common.Address
deployerTxs map[string]*types.Transaction
input map[string][]byte // map of the root contract pattern to the constructor input (if there is any)
deploy deployFn
err error
deploy DeployFn
}

// linkAndDeploy recursively deploys a contract/library: starting by linking/deploying its dependencies.
// linkAndDeploy recursively deploys a contract and its dependencies: starting by linking/deploying its dependencies.
// The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object.
func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) {
// short-circuit further deployment of contracts if a previous deployment encountered an error.
if d.err != nil {
return
}

func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) error {
// don't deploy contracts specified as overrides. don't deploy their dependencies.
if node.overrideAddr != nil {
return
return nil
}

// if this contract/library depends on other libraries deploy them (and their dependencies) first
for _, childNode := range node.children {
d.linkAndDeploy(childNode)
if err := d.linkAndDeploy(childNode); err != nil {
return err
}
}
// if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce
// a deployer bytecode for this contract.
Expand All @@ -186,25 +177,23 @@ func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) {
// Finally, deploy the contract.
addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode))
if err != nil {
d.err = err
} else {
d.deployedAddrs[node.pattern] = addr
d.deployerTxs[node.pattern] = tx
return err
}

d.deployedAddrs[node.pattern] = addr
d.deployerTxs[node.pattern] = tx
return nil
}

// result returns a result for this deployment, or an error if it failed.
func (d *depTreeDeployer) result() (*DeploymentResult, error) {
if d.err != nil {
return nil, d.err
}
func (d *depTreeDeployer) result() *DeploymentResult {
return &DeploymentResult{
Txs: d.deployerTxs,
Addrs: d.deployedAddrs,
}, nil
}
}

func newDepTreeDeployer(deploy deployFn) *depTreeDeployer {
func newDepTreeDeployer(deploy DeployFn) *depTreeDeployer {
return &depTreeDeployer{
deploy: deploy,
deployedAddrs: make(map[string]common.Address),
Expand All @@ -214,7 +203,7 @@ func newDepTreeDeployer(deploy deployFn) *depTreeDeployer {
// LinkAndDeploy deploys a specified set of contracts and their dependent
// libraries. If an error occurs, only contracts which were successfully
// deployed are returned in the result.
func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *DeploymentResult, err error) {
func LinkAndDeploy(deployParams DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) {
unlinkedContracts := make(map[string]string)
accumRes := &DeploymentResult{
Txs: make(map[string]*types.Transaction),
Expand All @@ -231,12 +220,12 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *Deploym
if deployParams.Inputs != nil {
deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]}
}
deployer.linkAndDeploy(tr)
res, err := deployer.result()
err := deployer.linkAndDeploy(tr)
res := deployer.result()
accumRes.Accumulate(res)
if err != nil {
return accumRes, err
}
accumRes.Accumulate(res)
}
return accumRes, nil
}

0 comments on commit a30ccd5

Please sign in to comment.