github.com/smartcontractkit/chainlink-terra@v0.1.4/tests/e2e/deployer.go (about)

     1  package e2e
     2  
     3  import (
     4  	"path/filepath"
     5  
     6  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/actypes"
     7  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/cw20types"
     8  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/flagstypes"
     9  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/ocr2proxytypes"
    10  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/ocr2types"
    11  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/utils"
    12  	"github.com/smartcontractkit/chainlink-terra/tests/e2e/validatortypes"
    13  	"github.com/smartcontractkit/integrations-framework/client"
    14  	"github.com/smartcontractkit/terra.go/msg"
    15  )
    16  
    17  // ContractDeployer provides the implementations for deploying Terra based contracts
    18  type ContractDeployer struct {
    19  	client *TerraLCDClient
    20  }
    21  
    22  func (t *ContractDeployer) DeployOCRv2Validator(threshold uint32, flags string) (*OCRv2Validator, error) {
    23  	contractAddr, err := t.client.Instantiate(
    24  		filepath.Join(utils.ContractsDir, "deviation_flagging_validator.wasm"),
    25  		validatortypes.InstantiateMsg{
    26  			FlaggingThreshold: threshold,
    27  			Flags:             flags,
    28  		},
    29  	)
    30  	if err != nil {
    31  		return nil, err
    32  	}
    33  	ca, err := msg.AccAddressFromBech32(contractAddr)
    34  	if err != nil {
    35  		return nil, err
    36  	}
    37  	return &OCRv2Validator{
    38  		client:  t.client,
    39  		address: ca,
    40  	}, nil
    41  }
    42  
    43  func (t *ContractDeployer) DeployOCRv2Proxy(addr string) (*OCRv2Proxy, error) {
    44  	proxyAddr, err := t.client.Instantiate(
    45  		filepath.Join(utils.ContractsDir, "proxy_ocr2.wasm"),
    46  		ocr2proxytypes.InstantiateMsg{ContractAddress: addr},
    47  	)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	proxAddr, err := msg.AccAddressFromBech32(proxyAddr)
    52  	if err != nil {
    53  		return nil, err
    54  	}
    55  	return &OCRv2Proxy{
    56  		client:  t.client,
    57  		address: proxAddr,
    58  	}, nil
    59  }
    60  
    61  func (t *ContractDeployer) DeployOCRv2Flags(lowAC string, raiseAC string) (*OCRv2Flags, error) {
    62  	contractAddr, err := t.client.Instantiate(
    63  		filepath.Join(utils.ContractsDir, "flags.wasm"),
    64  		flagstypes.InstantiateMsg{
    65  			LoweringAccessController: lowAC,
    66  			RaisingAccessController:  raiseAC,
    67  		},
    68  	)
    69  	if err != nil {
    70  		return nil, err
    71  	}
    72  	ca, err := msg.AccAddressFromBech32(contractAddr)
    73  	if err != nil {
    74  		return nil, err
    75  	}
    76  	return &OCRv2Flags{
    77  		client:  t.client,
    78  		address: ca,
    79  	}, nil
    80  }
    81  
    82  func (t *ContractDeployer) DeployOCRv2ValidatorProxy(addr string) (*OCRv2Proxy, error) {
    83  	proxyAddr, err := t.client.Instantiate(
    84  		filepath.Join(utils.ContractsDir, "proxy_validator.wasm"),
    85  		ocr2proxytypes.InstantiateMsg{ContractAddress: addr},
    86  	)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  	proxAddr, err := msg.AccAddressFromBech32(proxyAddr)
    91  	if err != nil {
    92  		return nil, err
    93  	}
    94  	return &OCRv2Proxy{
    95  		client:  t.client,
    96  		address: proxAddr,
    97  	}, nil
    98  }
    99  
   100  func NewTerraContractDeployer(client client.BlockchainClient) *ContractDeployer {
   101  	return &ContractDeployer{
   102  		client.(*TerraLCDClient),
   103  	}
   104  }
   105  
   106  func (t *ContractDeployer) DeployLinkTokenContract() (*LinkToken, error) {
   107  	linkAddr, err := t.client.Instantiate(
   108  		filepath.Join(utils.CommonContractsDir, "cw20_base.wasm"),
   109  		cw20types.InstantiateMsg{
   110  			Name:     "LinkToken",
   111  			Symbol:   "LINK",
   112  			Decimals: 18,
   113  			InitialBalances: []cw20types.InitialBalanceMsg{
   114  				{
   115  					Address: t.client.DefaultWallet.AccAddress,
   116  					Amount:  "9000000000000000000",
   117  				},
   118  			},
   119  		})
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	addr, err := msg.AccAddressFromBech32(linkAddr)
   124  	if err != nil {
   125  		return nil, err
   126  	}
   127  	return &LinkToken{
   128  		client:  t.client,
   129  		address: addr,
   130  	}, nil
   131  }
   132  
   133  func (t *ContractDeployer) DeployOCRv2(paymentControllerAddr string, requesterControllerAddr string, linkTokenAddr string) (*OCRv2, error) {
   134  	ocr2, err := t.client.Instantiate(
   135  		filepath.Join(utils.ContractsDir, "ocr2.wasm"),
   136  		ocr2types.OCRv2InstantiateMsg{
   137  			BillingAccessController:   paymentControllerAddr,
   138  			RequesterAccessController: requesterControllerAddr,
   139  			LinkToken:                 linkTokenAddr,
   140  			Decimals:                  8,
   141  			Description:               "ETH/USD",
   142  			MinAnswer:                 "1",
   143  			MaxAnswer:                 "10",
   144  		})
   145  	if err != nil {
   146  		return nil, err
   147  	}
   148  	addr, err := msg.AccAddressFromBech32(ocr2)
   149  	if err != nil {
   150  		return nil, err
   151  	}
   152  	return &OCRv2{
   153  		Client: t.client,
   154  		Addr:   addr,
   155  	}, nil
   156  }
   157  
   158  func (t *ContractDeployer) DeployOCRv2AccessController() (*AccessController, error) {
   159  	acAddr, err := t.client.Instantiate(
   160  		filepath.Join(utils.ContractsDir, "access_controller.wasm"),
   161  		actypes.InstantiateMsg{},
   162  	)
   163  	if err != nil {
   164  		return nil, err
   165  	}
   166  	addr, err := msg.AccAddressFromBech32(acAddr)
   167  	if err != nil {
   168  		return nil, err
   169  	}
   170  	return &AccessController{
   171  		client:  t.client,
   172  		address: addr,
   173  	}, nil
   174  }