diff --git a/CONDUCT.md b/CODE_OF_CONDUCT.md similarity index 100% rename from CONDUCT.md rename to CODE_OF_CONDUCT.md diff --git a/anchors/anchor_test.go b/anchors/anchor_test.go index 7b5170d80..9c0253453 100644 --- a/anchors/anchor_test.go +++ b/anchors/anchor_test.go @@ -3,12 +3,25 @@ package anchors import ( + "os" "testing" + "github.com/centrifuge/go-centrifuge/bootstrap" + "github.com/centrifuge/go-centrifuge/config" "github.com/centrifuge/go-centrifuge/utils" "github.com/stretchr/testify/assert" ) +func TestMain(m *testing.M) { + ibootstappers := []bootstrap.TestBootstrapper{ + &config.Bootstrapper{}, + } + bootstrap.RunTestBootstrappers(ibootstappers, nil) + result := m.Run() + bootstrap.RunTestTeardown(ibootstappers) + os.Exit(result) +} + func TestNewAnchorId(t *testing.T) { tests := []struct { name string diff --git a/anchors/ethereum_anchor_repository.go b/anchors/ethereum_anchor_repository.go index 022c63c7f..c126ca798 100644 --- a/anchors/ethereum_anchor_repository.go +++ b/anchors/ethereum_anchor_repository.go @@ -48,7 +48,9 @@ func NewEthereumAnchorRepository(config Config, anchorRepositoryContract AnchorR // Commits takes an anchorID and returns the corresponding documentRoot from the chain func (ethRepository *EthereumAnchorRepository) GetDocumentRootOf(anchorID AnchorID) (docRoot DocRoot, err error) { - return ethRepository.anchorRepositoryContract.Commits(ethereum.GetGethCallOpts(), anchorID.BigInt()) + // Ignoring cancelFunc as code will block until response or timeout is triggered + opts, _ := ethereum.GetGethCallOpts() + return ethRepository.anchorRepositoryContract.Commits(opts, anchorID.BigInt()) } //PreCommitAnchor will call the transaction PreCommit on the smart contract diff --git a/anchors/ethereum_anchor_repository_test.go b/anchors/ethereum_anchor_repository_test.go index 2b49334e5..78e40ece5 100644 --- a/anchors/ethereum_anchor_repository_test.go +++ b/anchors/ethereum_anchor_repository_test.go @@ -1,12 +1,11 @@ // +build unit -package anchors_test +package anchors import ( "math/big" "testing" - "github.com/centrifuge/go-centrifuge/anchors" "github.com/centrifuge/go-centrifuge/config" "github.com/centrifuge/go-centrifuge/identity" "github.com/centrifuge/go-centrifuge/keytools/secp256k1" @@ -19,7 +18,7 @@ import ( type mockAnchorRepo struct { mock.Mock - anchors.AnchorRepositoryContract + AnchorRepositoryContract } func (m *mockAnchorRepo) Commits(opts *bind.CallOpts, anchorID *big.Int) (docRoot [32]byte, err error) { @@ -36,10 +35,10 @@ func TestCorrectCommitSignatureGen(t *testing.T) { correctCommitToSign := "0x15f9cb57608a7ef31428fd6b1cb7ea2002ab032211d882b920c1474334004d6b" correctCommitSignature := "0xb4051d6d03c3bf39f4ec4ba949a91a358b0cacb4804b82ed2ba978d338f5e747770c00b63c8e50c1a7aa5ba629870b54c2068a56f8b43460aa47891c6635d36d01" testPrivateKey, _ := hexutil.Decode("0x17e063fa17dd8274b09c14b253697d9a20afff74ace3c04fdb1b9c814ce0ada5") - anchorIDTyped, _ := anchors.NewAnchorID(anchorID) + anchorIDTyped, _ := NewAnchorID(anchorID) centIdTyped, _ := identity.ToCentID(centrifugeId) - docRootTyped, _ := anchors.NewDocRoot(documentRoot) - messageToSign := anchors.GenerateCommitHash(anchorIDTyped, centIdTyped, docRootTyped) + docRootTyped, _ := NewDocRoot(documentRoot) + messageToSign := GenerateCommitHash(anchorIDTyped, centIdTyped, docRootTyped) assert.Equal(t, correctCommitToSign, hexutil.Encode(messageToSign), "messageToSign not calculated correctly") signature, _ := secp256k1.SignEthereum(messageToSign, testPrivateKey) assert.Equal(t, correctCommitSignature, hexutil.Encode(signature), "signature not correct") @@ -55,16 +54,16 @@ func TestGenerateAnchor(t *testing.T) { var documentProofs [][32]byte documentProofs = append(documentProofs, documentProof) centIdTyped, _ := identity.ToCentID(centrifugeId) - messageToSign := anchors.GenerateCommitHash(currentAnchorID, centIdTyped, currentDocumentRoot) + messageToSign := GenerateCommitHash(currentAnchorID, centIdTyped, currentDocumentRoot) signature, _ := secp256k1.SignEthereum(messageToSign, testPrivateKey) var documentRoot32Bytes [32]byte copy(documentRoot32Bytes[:], currentDocumentRoot[:32]) - commitData := anchors.NewCommitData(0, currentAnchorID, documentRoot32Bytes, centIdTyped, documentProofs, signature) + commitData := NewCommitData(0, currentAnchorID, documentRoot32Bytes, centIdTyped, documentProofs, signature) - anchorID, _ := anchors.NewAnchorID(currentAnchorID[:]) - docRoot, _ := anchors.NewDocRoot(documentRoot32Bytes[:]) + anchorID, _ := NewAnchorID(currentAnchorID[:]) + docRoot, _ := NewDocRoot(documentRoot32Bytes[:]) assert.Equal(t, commitData.AnchorID, anchorID, "Anchor should have the passed ID") assert.Equal(t, commitData.DocumentRoot, docRoot, "Anchor should have the passed document root") @@ -75,10 +74,10 @@ func TestGenerateAnchor(t *testing.T) { func TestGetDocumentRootOf(t *testing.T) { repo := &mockAnchorRepo{} - anchorID, err := anchors.NewAnchorID(utils.RandomSlice(32)) + anchorID, err := NewAnchorID(utils.RandomSlice(32)) assert.Nil(t, err) - ethRepo := anchors.NewEthereumAnchorRepository(config.Config, repo) + ethRepo := NewEthereumAnchorRepository(config.Config, repo) docRoot := utils.RandomByte32() repo.On("Commits", mock.Anything, mock.Anything).Return(docRoot, nil) gotRoot, err := ethRepo.GetDocumentRootOf(anchorID) diff --git a/build/configs/default_config.yaml b/build/configs/default_config.yaml index c383d04b8..85518be7d 100644 --- a/build/configs/default_config.yaml +++ b/build/configs/default_config.yaml @@ -32,6 +32,11 @@ networks: anchorRepository: "0x7f854dfa98012d7fa55c803bba2260bcdee4b5ed" paymentObligation: "" +# Peer-to-peer configurations +p2p: + # Timeout when opening connections to peers + connectTimeout: "30s" + # Queue configurations for asynchronous processing queue: # Defines the number of workers/consumers that will be allocated at startup @@ -51,6 +56,8 @@ ethereum: gasLimit: 4712388 # Timeout to wait for an ethereum transaction to be added to a block and events triggered contextWaitTimeout: "600s" + # Timeout to wait for read only operations against ethereum + contextReadWaitTimeout: "15s" # Node transaction pool max retries to send a transaction over maxRetries: 200 # Node transaction pool interval retry when a concurrent transaction has been detected diff --git a/config/configuration.go b/config/configuration.go index bbd110c86..952312d23 100644 --- a/config/configuration.go +++ b/config/configuration.go @@ -44,21 +44,26 @@ type IdentityConfig struct { PrivateKey []byte } -// Storage backend +// GetStoragePath returns the data storage backend func (c *Configuration) GetStoragePath() string { return c.V.GetString("storage.Path") } -// P2P Port +// GetP2PPort returns P2P Port func (c *Configuration) GetP2PPort() int { return c.V.GetInt("p2p.port") } -// P2P External IP +// GetP2PExternalIP returns P2P External IP func (c *Configuration) GetP2PExternalIP() string { return c.V.GetString("p2p.externalIP") } +// GetP2PConnectionTimeout returns P2P Connect Timeout +func (c *Configuration) GetP2PConnectionTimeout() time.Duration { + return c.V.GetDuration("p2p.connectTimeout") +} + //////////////////////////////////////////////////////////////////////////////// // Notifications //////////////////////////////////////////////////////////////////////////////// @@ -97,6 +102,10 @@ func (c *Configuration) GetEthereumNodeURL() string { return c.V.GetString("ethereum.nodeURL") } +func (c *Configuration) GetEthereumContextReadWaitTimeout() time.Duration { + return c.V.GetDuration("ethereum.contextReadWaitTimeout") +} + func (c *Configuration) GetEthereumContextWaitTimeout() time.Duration { return c.V.GetDuration("ethereum.contextWaitTimeout") } diff --git a/ethereum/geth_client.go b/ethereum/geth_client.go index ab60bd97a..b20c8f5a8 100644 --- a/ethereum/geth_client.go +++ b/ethereum/geth_client.go @@ -27,11 +27,23 @@ var log = logging.Logger("geth-client") var gc EthereumClient var gcInit sync.Once -// GetDefaultContextTimeout retrieves the default duration before an Ethereum call context should time out +// GetDefaultContextTimeout retrieves the default duration before an Ethereum write call context should time out func GetDefaultContextTimeout() time.Duration { return config.Config.GetEthereumContextWaitTimeout() } +// GetDefaultReadContextTimeout retrieves the default duration before an Ethereum read call context should time out +func GetDefaultReadContextTimeout() time.Duration { + return config.Config.GetEthereumContextReadWaitTimeout() +} + +// DefaultWaitForReadContext returns context with timeout for read operations +func DefaultWaitForReadContext() (ctx context.Context, cancelFunc context.CancelFunc) { + toBeDone := time.Now().Add(GetDefaultReadContextTimeout()) + return context.WithDeadline(context.Background(), toBeDone) +} + +// DefaultWaitForTransactionMiningContext returns context with timeout for write operations func DefaultWaitForTransactionMiningContext() (ctx context.Context, cancelFunc context.CancelFunc) { toBeDone := time.Now().Add(GetDefaultContextTimeout()) return context.WithDeadline(context.TODO(), toBeDone) @@ -254,8 +266,10 @@ func CalculateIncrement(chainNonce uint64, res map[string]map[string]map[string] } } -func GetGethCallOpts() (auth *bind.CallOpts) { +func GetGethCallOpts() (*bind.CallOpts, context.CancelFunc) { // Assuring that pending transactions are taken into account by go-ethereum when asking for things like // specific transactions and client's nonce - return &bind.CallOpts{Pending: true} + // with timeout context, in case eth node is not in sync + ctx, cancelFunc := DefaultWaitForReadContext() + return &bind.CallOpts{Pending: true, Context: ctx}, cancelFunc } diff --git a/identity/ethereum_identity.go b/identity/ethereum_identity.go index 559cfc06c..2cb32235f 100644 --- a/identity/ethereum_identity.go +++ b/identity/ethereum_identity.go @@ -101,7 +101,8 @@ func (id *EthereumIdentity) FetchKey(key []byte) (Key, error) { if err != nil { return nil, err } - opts := ethereum.GetGethCallOpts() + // Ignoring cancelFunc as code will block until response or timeout is triggered + opts, _ := ethereum.GetGethCallOpts() key32, _ := utils.SliceToByte32(key) keyInstance, err := contract.GetKey(opts, key32) if err != nil { @@ -135,7 +136,8 @@ func (id *EthereumIdentity) findContract() (exists bool, err error) { return true, nil } - opts := ethereum.GetGethCallOpts() + // Ignoring cancelFunc as code will block until response or timeout is triggered + opts, _ := ethereum.GetGethCallOpts() idAddress, err := id.RegistryContract.GetIdentityByCentrifugeId(opts, id.CentrifugeId.BigInt()) if err != nil { return false, err @@ -219,7 +221,8 @@ func (id *EthereumIdentity) fetchKeysByPurpose(keyPurpose int) ([]EthereumIdenti if err != nil { return nil, err } - opts := ethereum.GetGethCallOpts() + // Ignoring cancelFunc as code will block until response or timeout is triggered + opts, _ := ethereum.GetGethCallOpts() bigInt := big.NewInt(int64(keyPurpose)) keys, err := contract.GetKeysByPurpose(opts, bigInt) if err != nil { @@ -372,7 +375,8 @@ func (ids *EthereumIdentityService) CreateIdentity(centrifugeID CentID) (id Iden // GetIdentityAddress gets the address of the ethereum identity contract for the given CentID func (ids *EthereumIdentityService) GetIdentityAddress(centID CentID) (common.Address, error) { - opts := ethereum.GetGethCallOpts() + // Ignoring cancelFunc as code will block until response or timeout is triggered + opts, _ := ethereum.GetGethCallOpts() address, err := ids.registryContract.GetIdentityByCentrifugeId(opts, centID.BigInt()) if err != nil { return common.Address{}, err @@ -389,7 +393,7 @@ func (ids *EthereumIdentityService) LookupIdentityForID(centrifugeID CentID) (Id id := NewEthereumIdentity(centrifugeID, ids.registryContract, ids.config) exists, err := id.CheckIdentityExists() if !exists { - return id, fmt.Errorf("identity [%s] does not exist", id.CentrifugeId) + return id, fmt.Errorf("identity [%s] does not exist with err [%v]", id.CentrifugeId, err) } if err != nil { diff --git a/p2p/client.go b/p2p/client.go index 6aab6dd67..ab8e9fcc4 100644 --- a/p2p/client.go +++ b/p2p/client.go @@ -17,7 +17,6 @@ import ( pstore "github.com/libp2p/go-libp2p-peerstore" ma "github.com/multiformats/go-multiaddr" "google.golang.org/grpc" - "google.golang.org/grpc/connectivity" ) type Client interface { @@ -62,17 +61,14 @@ func (d *defaultClient) OpenClient(target string) (p2ppb.P2PServiceClient, error // so LibP2P knows how to contact it hostInstance.Peerstore().AddAddr(peerID, targetAddr, pstore.PermanentAddrTTL) - // make a new stream from host B to host A - g, err := grpcProtoInstance.Dial(context.Background(), peerID, grpc.WithInsecure()) + // make a new stream from host B to host A with timeout + // Retrial is handled internally, connection request will be cancelled by the connection timeout context + ctx, _ := context.WithTimeout(context.Background(), config.Config.GetP2PConnectionTimeout()) + g, err := grpcProtoInstance.Dial(ctx, peerID, grpc.WithInsecure(), grpc.WithBlock()) if err != nil { - return nil, err + return nil, fmt.Errorf("failed to dial peer [%s]: %v", peerID.Pretty(), err) } - for { - if g.GetState() == connectivity.Ready { - break - } - } return p2ppb.NewP2PServiceClient(g), nil } diff --git a/p2p/server.go b/p2p/server.go index 151638f22..9663d911b 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -203,7 +203,8 @@ func (c *CentP2PServer) makeBasicHost(listenPort int) (host.Host, error) { addressFactory := func(addrs []ma.Multiaddr) []ma.Multiaddr { if extMultiAddr != nil { - addrs = append(addrs, extMultiAddr) + // We currently support a single protocol and transport, if we add more to support then we will need to adapt this code + addrs = []ma.Multiaddr{extMultiAddr} } return addrs } diff --git a/p2p/server_test.go b/p2p/server_test.go index ff29c39eb..0d32d67e4 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -73,6 +73,7 @@ func TestCentP2PServer_makeBasicHostWithExternalIP(t *testing.T) { assert.NotNil(t, h) addr, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", externalIP, listenPort)) assert.Nil(t, err) + assert.Equal(t, 1, len(h.Addrs())) assert.Contains(t, h.Addrs(), addr) } diff --git a/resources/data.go b/resources/data.go index 800044e5d..80111fde7 100644 --- a/resources/data.go +++ b/resources/data.go @@ -69,7 +69,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _goCentrifugeBuildConfigsDefault_configYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x56\x49\x77\xdb\x3a\x0f\xdd\xeb\x57\xe0\x38\x9b\xef\x5b\xd4\xd6\x60\xc9\xb6\x76\x19\x3b\x39\x79\xb6\xe3\x36\x4d\x76\x14\x09\x49\xac\x25\x52\x21\x29\xcb\xee\xaf\x7f\x87\x1a\xd2\x0c\x1d\x5e\x56\x3a\x01\x70\x09\x5c\x5c\x00\x3e\x81\x0b\x4c\x49\x5d\x18\x60\xb8\xc7\x42\x56\x25\x0a\x03\x06\xb5\x11\x68\x80\x64\x84\x0b\x6d\x40\x71\xb1\xc3\xe4\xe8\x50\x14\x46\xf1\xb4\xce\xf0\x06\x4d\x23\xd5\x2e\x06\x55\x6b\xcd\x89\xc8\x79\x51\x38\x2d\x18\x17\x08\x26\x47\x60\x3d\xae\xe8\x3c\x35\x98\x9c\x18\x38\x7f\x42\x80\x92\x70\x61\x2c\xbe\x33\xb8\xc4\x0e\xc0\x09\x2c\x25\x25\x45\x9b\x02\x17\x19\x50\x29\x8c\x22\xd4\x00\x61\x4c\xa1\xd6\xa8\x41\x20\x32\x30\x12\x12\x04\x8d\x06\x1a\x6e\x72\x40\xb1\x87\x3d\x51\x9c\x24\x05\xea\xb1\x03\x43\xbc\x85\x04\xe0\x2c\x86\x20\x08\xda\x6f\x34\x39\x2a\xac\xcb\xbe\x82\x8f\x2c\x86\x79\x30\xef\x6c\x89\x94\x46\x1b\x45\xaa\x15\xa2\xd2\x5d\x2c\xc0\x3b\x18\x4d\x78\x35\x9d\x78\xfe\x6c\xec\x8e\xdd\xb1\x37\x31\xb4\x9a\x04\x73\xdf\xf5\x27\xbc\x4a\xf5\x64\x5d\x6e\xd7\x87\xa4\xd9\xd5\x0f\xf7\xf7\x17\x69\xfd\x63\x9b\x1c\x2e\x4f\x37\xb8\xbd\x39\x5f\xca\x1f\xc7\x63\x18\xce\xf7\x6b\x91\x7d\xdd\xaf\xae\xbf\x2f\xef\x77\xa3\xbf\xc2\x06\x03\xec\xd7\x34\xba\xbc\x89\xca\xdd\xe3\x1d\x7e\xbf\xfb\x7c\xe7\x3f\xae\x6a\x2f\xfa\x56\xb1\xf7\xc1\xee\x93\xf4\xb6\x41\x99\x93\x7c\x75\x16\xde\x62\x28\xbc\x0e\x76\xa0\xeb\x74\x60\x6b\x28\x82\x33\x14\x86\x9b\xe3\x15\xa1\x46\xaa\x63\x0c\xa3\xd1\x2b\xcb\x06\x33\xae\xcd\x0b\x13\x11\x34\x97\x6a\x83\x95\xd4\xfc\x55\x54\x45\x8e\x56\x2a\xff\x24\x05\xcf\x88\xe1\x52\xb4\xb6\xb6\x81\xd7\x84\x8b\x5f\xca\xa9\xef\xb3\x03\xcf\x55\xd3\x25\x78\x02\x37\x75\x89\x8a\x53\xf8\x78\x01\x32\x6d\x15\xf4\x4c\x2b\x3f\x23\xbb\x66\x86\x5e\x1f\x75\x36\x74\x0c\x0a\xae\x8d\x8d\x14\x92\xe1\x5b\xb1\x55\x4a\xee\x79\x6b\x90\x2d\xf6\xb3\x04\x86\xf4\xfe\x83\x02\x82\x70\xec\xfb\xe1\xd8\x77\xdd\xf1\xd4\x7f\xad\x02\xcf\xbf\x08\x3e\x4b\x79\xb7\xe4\x9c\xae\xbf\x36\xdb\x7c\x7b\x76\x1f\x1d\x3e\xd3\x95\x5c\xa6\xd1\x66\x7d\xff\xe9\xaa\x6a\x52\x4f\xcd\xc2\x66\x79\xf0\x1f\x36\x41\x75\xce\xbc\xd7\x5a\xe8\x1f\x98\x47\x63\xdf\x73\x7f\xf7\xc0\xfa\xe1\xfa\x74\xfe\x7e\xf5\x41\xed\x2f\x1f\xce\x16\x0d\xdb\xc9\x2f\xf4\xf4\xb4\x3c\x7f\xf8\x50\x2d\xf0\x78\x7c\x98\xde\x5e\xce\xb3\x2b\x15\xe4\xdb\x9b\x6f\xa3\x9e\xa7\xcb\x5e\xf5\x03\x93\x96\xe6\x77\xb0\xe9\xe7\xfa\x37\x73\x31\xed\x83\x97\xc4\x52\x04\x0c\xab\x42\x1e\x91\xc1\x6d\x49\x94\x81\xf3\x5e\x6a\x1a\x52\xa9\x5a\x52\x33\xbe\x47\xf1\x82\xce\xb7\x72\x84\xdf\xea\xd1\x3d\x2c\x5c\xe6\x2f\xa6\xe1\xcc\xc3\x59\x30\x9f\xfa\xd1\x62\x46\xa2\x28\x99\x91\xc5\x82\xb8\x0b\xc6\x22\x3a\x0b\x58\x10\x46\xec\x0f\xca\x75\x0f\x8b\x28\x72\xa9\x1b\x2c\x58\xe0\x79\xd3\x30\x20\xa9\xcb\xc2\x39\x0d\xa3\x28\x9a\xf9\x01\x5b\x50\x3f\x25\x33\x16\x21\xfd\x83\xc6\xdd\xc3\x2c\x9d\x87\x53\x96\x92\xc5\xdc\xf5\x7c\x36\x4b\x49\x18\xd2\xb9\x1b\x24\x09\xf1\xfd\xc8\x4d\x28\x43\x9c\x26\x21\xb2\xbf\x4c\xc3\x09\xac\x6b\xac\xd1\xd2\x90\xf2\xac\x56\xad\xa9\xe3\x8b\xe8\xa3\xa0\xb9\x92\x42\xd6\xda\xaa\x93\xa2\xd6\x5c\x64\xce\xa3\x0d\xe8\x16\x61\xb7\x4c\x75\x4b\xad\xa8\xcb\x04\x95\xd5\xb7\x6d\x0e\x2a\x3d\xa1\x52\x68\x3b\x32\xbd\xd6\x1b\xab\xe4\x04\x81\x14\x85\xa4\xc4\x20\x03\x62\x40\x1b\xa2\x4c\x5d\x39\x60\xe3\xef\xba\xc0\x18\xfc\x16\xfd\x4a\x21\x6a\xa8\x2b\x38\x5f\x7d\x01\x7a\xa4\x05\x6a\x68\x72\x14\xfd\x03\xc0\x35\x34\x84\xb7\x3b\xd8\xe6\x8b\x7b\x14\x46\x3b\xd0\x9b\xef\x08\x37\x5b\x5e\xe2\xf5\x6d\x0c\x9e\x2d\xf4\x49\x60\xba\x42\xca\x53\x4e\x5f\x16\xed\x0c\xf2\xea\x4a\xbb\xc5\x02\xad\x72\x9a\x9c\xd3\xfc\x49\x7a\x40\x28\x95\xb5\x5d\x18\x12\x6a\x8d\xc3\x1e\x90\x96\x84\x7e\x80\x19\x70\xd1\xfe\x93\xd6\xda\xc8\xb2\x7f\x04\x52\x5e\xa0\x03\xc3\xcd\x39\xed\x60\x6e\x48\x89\x31\x8c\xec\x9d\x19\x3d\x5d\x16\x9b\xcc\x00\xfc\xf4\x2e\x2d\xb8\xdd\x53\x76\x75\xc0\xff\x1a\x04\x85\x8f\x35\x57\x08\x8d\x06\xa9\x80\x57\xb4\x3f\x37\xf6\xba\xd8\x4f\x4a\x8c\x4d\xbb\xa5\xe4\xff\x96\x5d\xc9\xf0\xcb\x66\x19\x43\xa3\xe3\xc9\xc4\x36\xa0\xc8\xa5\x36\xf1\x22\x9c\x46\x43\x2b\xdb\x63\x98\x11\x5b\x09\xa7\x36\xd9\x8c\xe8\x95\xfd\x8c\xc1\x73\x87\xbf\x37\xce\x05\x2f\xb9\xe9\x9c\x97\xf6\x33\x86\xe9\xcc\xf3\x83\xf9\xbc\xf5\xb4\x1d\x90\x75\xcb\x97\xed\x55\x27\x2c\xf1\xb3\x2e\xa3\x88\xd0\x84\xb6\x35\xf7\x15\x30\xd6\x1d\x4f\x02\x49\x21\xe9\x0e\x88\x60\x7d\x21\x60\x14\xcf\x32\x54\xc8\x9c\x6e\x70\xf1\x60\x86\x36\xcb\xda\xc4\x30\x8a\x5c\x57\x77\x4c\xde\x58\xa6\x9e\xa3\x57\x52\x16\x50\x92\x03\x28\x34\x8a\x77\x7b\x56\xa3\x60\x40\x5e\xb8\xc9\x3d\x2a\x07\xac\xe3\xa6\xf3\x8b\xc1\xef\xab\xfe\x35\x24\x17\x06\xd5\x9e\x14\x2d\xee\xb1\x13\x28\xb1\xd9\xd1\x5a\xa9\xf6\xb6\x3c\x8b\xc8\x89\x86\x04\xd1\x1e\x1f\x83\xd4\xb4\x85\x0c\x00\xf6\x3d\x3b\xdb\x7e\x5f\xc1\x05\xd7\x6d\x37\x5b\x44\x2d\xcb\x37\x6a\xd0\xc0\x24\x08\x69\x40\xd7\x55\x25\x95\x01\x73\x68\x33\x22\x15\xb7\x3f\x2f\x0e\x2b\x29\x8b\x53\x6a\xc7\xf6\x52\x58\x24\x16\x83\x51\x35\x3a\xce\xbf\x01\x00\x00\xff\xff\x75\xa8\x4f\xcf\x53\x09\x00\x00") +var _goCentrifugeBuildConfigsDefault_configYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x56\xc9\x76\xdb\x3a\x0f\xde\xeb\x29\x70\x9c\xcd\xff\x2f\x62\x6b\xb0\x64\x5b\xbb\x8c\x9d\x9c\x5c\xc7\x71\x9b\x26\x3b\x8a\x84\x2c\xd6\x12\xa9\x90\x94\x87\x3e\xfd\x3d\xa4\xa4\x34\x43\xd3\x5e\xaf\x78\x0c\xe0\xc3\xf4\x01\xd0\x11\x9c\x63\x4e\x9a\xd2\x00\xc3\x2d\x96\xb2\xae\x50\x18\x30\xa8\x8d\x40\x03\x64\x4d\xb8\xd0\x06\x14\x17\x1b\xcc\x0e\x1e\x45\x61\x14\xcf\x9b\x35\x5e\xa3\xd9\x49\xb5\x49\x41\x35\x5a\x73\x22\x0a\x5e\x96\x9e\x03\xe3\x02\xc1\x14\x08\xac\xc3\x15\xad\xa6\x06\x53\x10\x03\x67\x4f\x08\x50\x11\x2e\x8c\xc5\xf7\x7a\x95\xd4\x03\x38\x82\xb9\xa4\xa4\x74\x21\x70\xb1\x06\x2a\x85\x51\x84\x1a\x20\x8c\x29\xd4\x1a\x35\x08\x44\x06\x46\x42\x86\xa0\xd1\xc0\x8e\x9b\x02\x50\x6c\x61\x4b\x14\x27\x59\x89\x7a\xe8\x41\x6f\x6f\x21\x01\x38\x4b\x21\x8a\x22\xf7\x46\x53\xa0\xc2\xa6\xea\x32\xf8\xc4\x52\x98\x46\xd3\x56\x96\x49\x69\xb4\x51\xa4\x5e\x20\x2a\xdd\xda\x02\x1c\xc3\x60\xc4\xeb\xf1\x28\x08\x27\x43\x7f\xe8\x0f\x83\x91\xa1\xf5\x28\x9a\x86\x7e\x38\xe2\x75\xae\x47\x37\xd5\xea\x66\x9f\xed\x36\xcd\xc3\xfd\xfd\x79\xde\xfc\x5c\x65\xfb\x8b\x93\x25\xae\xae\xcf\xe6\xf2\xe7\xe1\x10\xc7\xd3\xed\x8d\x58\x7f\xdb\x2e\xae\x7e\xcc\xef\x37\x83\xbf\xc2\x46\x3d\xec\xb7\x3c\xb9\xb8\x4e\xaa\xcd\xe3\x1d\xfe\xb8\xfb\x72\x17\x3e\x2e\x9a\x20\xf9\x5e\xb3\x0f\xd1\xe6\xb3\x0c\x56\x51\x55\x90\x62\x71\x1a\xdf\x62\x2c\x82\x16\xb6\x2f\xd7\x49\x5f\xad\x3e\x09\xce\x50\x18\x6e\x0e\x97\x84\x1a\xa9\x0e\x29\x0c\x06\xaf\x24\x4b\x5c\x73\x6d\x5e\x88\x88\xa0\x85\x54\x4b\xac\xa5\xe6\xaf\xac\x6a\x72\xb0\x54\xf9\x27\x2b\xf9\x9a\x18\x2e\x85\x93\xb9\x06\x5e\x11\x2e\x7e\x4b\xa7\xae\xcf\x1e\x3c\x67\x4d\x1b\xe0\x11\x5c\x37\x15\x2a\x4e\xe1\xd3\x39\xc8\xdc\x31\xe8\x19\x57\x7e\x59\xb6\xcd\x8c\x83\xce\xea\xb4\xef\x18\x94\x5c\x1b\x6b\x29\x24\xc3\xb7\x64\xab\x95\xdc\x72\x27\x90\x0e\xfb\x59\x00\x7d\x78\xff\x81\x01\x51\x3c\x0c\xc3\x78\x18\xfa\xfe\x70\x1c\xbe\x66\x41\x10\x9e\x47\x5f\xa4\xbc\x9b\x73\x4e\x6f\xbe\xed\x56\xc5\xea\xf4\x3e\xd9\x7f\xa1\x0b\x39\xcf\x93\xe5\xcd\xfd\xe7\xcb\x7a\x97\x07\x6a\x12\xef\xe6\xfb\xf0\x61\x19\xd5\x67\x2c\x78\xcd\x85\xce\xc1\x34\x19\x86\x81\xff\x9e\x83\x9b\x87\xab\x93\xe9\x87\xc5\x47\xb5\xbd\x78\x38\x9d\xed\xd8\x46\x7e\xa5\x27\x27\xd5\xd9\xc3\xc7\x7a\x86\x87\xc3\xc3\xf8\xf6\x62\xba\xbe\x54\x51\xb1\xba\xfe\x3e\xe8\xea\x74\xd1\xb1\xbe\xaf\xa4\x2d\xf3\x31\x2c\xbb\xb9\x7e\x67\x2e\xc6\x9d\xf1\x9c\xd8\x12\x01\xc3\xba\x94\x07\x64\x70\x5b\x11\x65\xe0\xac\xa3\x9a\x86\x5c\x2a\x57\xd4\x35\xdf\xa2\x78\x51\xce\xb7\x74\x84\x77\xf9\xe8\xef\x67\x3e\x0b\x67\xe3\x78\x12\xe0\x24\x9a\x8e\xc3\x64\x36\x21\x49\x92\x4d\xc8\x6c\x46\xfc\x19\x63\x09\x9d\x44\x2c\x8a\x13\xf6\x07\xe6\xfa\xfb\x59\x92\xf8\xd4\x8f\x66\x2c\x0a\x82\x71\x1c\x91\xdc\x67\xf1\x94\xc6\x49\x92\x4c\xc2\x88\xcd\x68\x98\x93\x09\x4b\x90\xfe\x81\xe3\xfe\x7e\x92\x4f\xe3\x31\xcb\xc9\x6c\xea\x07\x21\x9b\xe4\x24\x8e\xe9\xd4\x8f\xb2\x8c\x84\x61\xe2\x67\x94\x21\x8e\xb3\x18\xd9\x5f\xa6\xe1\x08\x2c\x8d\x8e\x8d\x3c\xae\x11\x95\xad\x46\xce\xd7\x8d\x72\x1a\xda\xab\xc3\xba\xdd\x78\x2b\x5e\xa1\x6c\x0c\xec\x0a\x14\x20\x6b\x14\xdd\xe2\x13\x48\x9d\xa6\x25\xad\x05\xd0\x1e\xf4\x7f\x77\x26\x29\x0c\x22\x5f\x3b\x4f\x37\x0d\x36\xf8\xca\x85\xeb\x0c\xd1\x07\x41\x0b\x25\x85\x6c\xb4\x9d\x03\x8a\x5a\x73\xb1\xf6\x1e\xad\x41\x1b\x40\xbb\xb6\xb5\x6b\xa2\x68\xaa\x0c\x95\x9d\x24\x4b\x03\x54\x7a\x44\xa5\xd0\x76\x38\xbb\xa9\xda\xd9\x99\xc9\x10\x48\x59\x4a\x4a\x0c\x32\x20\x06\xb4\x21\xca\x34\xb5\x07\xd6\xfe\xae\x35\x4c\x21\x74\xe8\x97\x0a\x51\x43\x53\xc3\xd9\xe2\x2b\xd0\x03\x2d\x51\xb7\xa9\xb6\x0e\x80\x6b\xd8\x11\xee\xb6\xbd\x8d\x17\xb7\x28\x8c\x4d\xb5\x15\xdf\x11\xee\xb2\xbd\xba\x4d\x21\xb0\x89\x3e\x51\x59\xd7\x48\x79\xce\xe9\xcb\xa4\xbd\x9e\xc8\x6d\x6a\xb7\x58\xa2\xe5\xe8\xae\xe0\xb4\x78\x22\x39\x10\x4a\x65\x63\x57\x93\x84\x46\x63\xbf\x71\xa4\x2d\x42\xb7\x2a\x18\x70\xe1\xfe\xa4\x8d\x36\xb2\xea\x9c\x40\xce\x4b\xf4\xa0\xbf\x6e\x27\x2d\xcc\x35\xa9\x30\x85\x81\xbd\x68\x83\xa7\x1b\x66\x83\xe9\x81\x9f\xfc\xd2\x92\xdb\x8d\x68\x97\x14\xfc\x6f\x87\xa0\xf0\xb1\xe1\x0a\x61\xa7\x41\x2a\xe0\x35\xed\x0e\x9b\xbd\x63\xf6\x49\x89\xb1\x61\xbb\x92\xfc\xdf\x56\x57\x32\xfc\xba\x9c\xa7\xb0\xd3\xe9\x68\x64\x1b\x50\x16\x52\x9b\x74\x16\x8f\x93\xbe\x95\xee\xec\xae\x89\xcd\x84\x53\x1b\xec\x9a\xe8\x85\x7d\xa6\x10\xf8\xfd\xef\x8d\x72\xc9\x2b\x6e\x5a\xe5\xb9\x7d\xa6\x30\x9e\x04\x61\x34\x9d\xbe\xa0\xa8\x91\xae\x57\x2d\xb1\xc4\xaf\xbc\x8c\x22\x42\x13\x47\xd7\x3e\x03\xc6\xda\x33\x4d\x20\x2b\x25\xdd\x00\x11\xac\x4b\x04\x8c\xe2\xeb\x35\x2a\x64\x2d\xa1\x0d\xee\x4d\xdf\xe6\x96\xd4\x89\x6f\x59\xfd\x9e\x63\x85\x84\x81\x14\xe5\xc1\x0e\x4b\x4f\xf5\xfe\x5b\xa5\x0f\xe9\x17\xf4\x12\x09\x7b\x09\x1f\xc4\x1d\xfa\xb5\xed\xc3\xf3\xd8\x6b\x29\x4b\xa8\xc8\x1e\x14\x1a\xc5\xdb\x7b\xa1\x51\x30\x20\x2f\xd4\xe4\x16\x95\x07\x56\x71\xd9\xea\xa5\x10\x76\x35\xfd\x3d\x24\x17\x06\xd5\x96\x94\x0e\xf7\xd0\xd2\x9f\xd8\x00\x69\xa3\x94\xbb\x91\xcf\x2c\x0a\xa2\x21\x43\xb4\x47\xd4\x20\x35\xae\x4c\x3d\x80\xf5\x67\x77\x54\xd8\x65\x70\xce\xb5\xe3\x8a\x43\xd4\xb2\x7a\xc3\x35\x0d\x4c\x82\x90\x06\x74\x53\xd7\x52\x19\x30\x7b\x17\x11\xa9\xb9\xfd\x4c\xda\x2f\xa4\x2c\x4f\xa8\x5d\x0a\x17\xc2\x22\xb1\x14\x8c\x6a\xd0\xf3\xfe\x0d\x00\x00\xff\xff\x0a\x16\x18\x68\x1b\x0a\x00\x00") func goCentrifugeBuildConfigsDefault_configYamlBytes() ([]byte, error) { return bindataRead( @@ -84,7 +84,7 @@ func goCentrifugeBuildConfigsDefault_configYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "go-centrifuge/build/configs/default_config.yaml", size: 2387, mode: os.FileMode(420), modTime: time.Unix(1540471826, 0)} + info := bindataFileInfo{name: "go-centrifuge/build/configs/default_config.yaml", size: 2587, mode: os.FileMode(420), modTime: time.Unix(1540892585, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -104,7 +104,7 @@ func goCentrifugeBuildConfigsTesting_configYaml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "go-centrifuge/build/configs/testing_config.yaml", size: 938, mode: os.FileMode(420), modTime: time.Unix(1540471826, 0)} + info := bindataFileInfo{name: "go-centrifuge/build/configs/testing_config.yaml", size: 938, mode: os.FileMode(420), modTime: time.Unix(1540808141, 0)} a := &asset{bytes: bytes, info: info} return a, nil }