ACN keys #85

Karrenbelt · 2022-03-12T15:44:08Z

ACN REPORT

documentation

Code

python side:

example observation

_make_libp2p_connection creates:

key:  # agent_key
  address = {str} '0x695dEc35E3B66c4d1e11D544950bA894b7c2b303'
  entity = {LocalAccount} <eth_account.signers.local.LocalAccount object at 0x7ff3daaabe90>
  identifier = {str} 'ethereum'
  private_key = {str} '0xec315ae719c8aa687c4372ffcb09855983a4a3b558174381a2a18c0868354a88'
  public_key = {str} '0x333720d8c88241e1f689e9b4face9b234d1462a4afe55f52052370a221c062cb1e70d68ace0a26d75cce9ca58113fa478fd14798b2c3c24ed272e70ad3ed821f'

node_key: 
  address = {str} 'cosmos10sllfup83akmqf6zluffs5udusnnpajwreqec2'
  entity = {SigningKey} <ecdsa.keys.SigningKey object at 0x7ff3ece44410>
  helper = {ABCMeta} <class 'aea_ledger_cosmos.cosmos.CosmosHelper'>
  identifier = {str} 'cosmos'
  private_key = {str} '5a93d9c1116c38a73579555c5c0a67f221647baa63cbfdde6f3669501eab9081'
  public_key = {str} '0269580bab436eaa2a851a80d8f2d6040e703d8570027dd1cc9e06fdf2baa18df1'

.evn.libp2p

  AEA_AGENT_ADDR=0x695dEc35E3B66c4d1e11D544950bA894b7c2b303
  AEA_P2P_ID=5a93d9c1116c38a73579555c5c0a67f221647baa63cbfdde6f3669501eab9081
  AEA_P2P_URI=127.0.0.1:10234
  AEA_P2P_ENTRY_URIS=
  NODE_TO_AEA=36211
  AEA_TO_NODE=36211
  AEA_P2P_URI_PUBLIC=127.0.0.1:10234
  AEA_P2P_DELEGATE_URI=
  AEA_P2P_URI_MONITORING=
  AEA_P2P_POR_ADDRESS=0x695dEc35E3B66c4d1e11D544950bA894b7c2b303
  AEA_P2P_POR_PUBKEY=0x333720d8c88241e1f689e9b4face9b234d1462a4afe55f52052370a221c062cb1e70d68ace0a26d75cce9ca58113fa478fd14798b2c3c24ed272e70ad3ed821f
  AEA_P2P_POR_PEER_PUBKEY=0269580bab436eaa2a851a80d8f2d6040e703d8570027dd1cc9e06fdf2baa18df1
  AEA_P2P_POR_SIGNATURE=0x7004582d9d71c78696c250adcd4948a1261c738e39d34f09b334d668b3b1d8a864e1e4ca556826badbdf0cfe56047a735a7ee2bd717fbf554095b6106cfc15f61b
  AEA_P2P_POR_SERVICE_ID=acn
  AEA_P2P_POR_LEDGER_ID=ethereum
  AEA_P2P_CFG_REGISTRATION_DELAY=0.0
  AEA_P2P_CFG_STORAGE_PATH=
  AEA_P2P_MAILBOX_URI=

representation of information (in environment)

thus, what we get from the python side of things:

libp2p_node # executable
libp2p_node_<port>.log

.evn.libp2p

  AEA_AGENT_ADDR = key.address
  AEA_P2P_ID = node_key.private_key 
  AEA_P2P_POR_ADDRESS = key.address  # why is this here again?
  AEA_P2P_POR_PUBKEY = key.public_key
  AEA_P2P_POR_PEER_PUBKEY = node_key.public_key
  AEA_P2P_POR_SIGNATURE=0x7004582d9d71c78696c250adcd4948a1261c738e39d34f09b334d668b3b1d8a864e1e4ca556826badbdf0cfe56047a735a7ee2bd717fbf554095b6106cfc15f61b

agent_address_cert.txt # signed agent public key
<node_public_key>.txt # contains the node_key.private_key

helpers/acn/agent_record/AgentRecord.from_cert_request
cert_request.get_signature(data_dir)
-> creates <agent_address>_cert.txt
here the signature is generated, serving as the proof-of-representation (PoR), stored in .evn.libp2p

checking with different key combinations for agent and peer node

example of (private) peer key (id), as output by our python to .evn.libp2p
*I removed all irrelevant keys

DEFAULT_LEDGER = DEFAULT_LEDGER_LIBP2P_NODE = "fetchai"; tests: PASS

    AEA_AGENT_ADDR=fetch16k3x9vw8jraxxddkhmz6rh3j74xjjrsdvcs2gz
    AEA_P2P_ID=17d0eb590228d1418d0693bbbf41a3e1fd51b516b2fd37ed16301232c18b4e8e
    AEA_P2P_POR_ADDRESS=fetch16k3x9vw8jraxxddkhmz6rh3j74xjjrsdvcs2gz
    AEA_P2P_POR_PUBKEY=0296bd7ad062c2ca5a85ada147c7cb951cb0e1672778aa99abf0f641de578e0e65
    AEA_P2P_POR_PEER_PUBKEY=021aed1ce78a449109de6cc7ef516602a60d76e771b0cc2fef448b81d234d5b06b
    AEA_P2P_POR_SIGNATURE=iUcIQWrj+9KACugzIRDlyRuoNL7UThexSOn/l8ukBn9jEs1w4HJCcdfbNLEjfUrwOkMK3tX+Yaw3q80UicaNAQ==
    AEA_P2P_POR_SERVICE_ID=acn
    AEA_P2P_POR_LEDGER_ID=fetchai

2.DEFAULT_LEDGER = DEFAULT_LEDGER_LIBP2P_NODE = "ethereum"; tests: FAIL

    AEA_AGENT_ADDR=0x0B2F0C90222badbBC3C03b762FaB51c4192748F5
    AEA_P2P_ID=0xeddbb87bd92c82f5e6700e8b9960a044a23cb2323ea4b827fa5927f0af03e564
    AEA_P2P_POR_ADDRESS=0x0B2F0C90222badbBC3C03b762FaB51c4192748F5
    AEA_P2P_POR_PUBKEY=0x03ec9f0a631d746b97c101bb442558ac9a57da7152a5761593a96046ef85f7c7e4577aa95ff47ede6eb74a1f13c4c74ec408a9e75ca5f548e5ada6f4f1adffc0
    AEA_P2P_POR_PEER_PUBKEY=0x5355ba6a065dfe10619f080894d66343b952ca6768988112afd5f2228fbf813d331097564d8fb5ec9e8dbd8ff0f8d2b72e02a61956d2f89a731af4626ec3753c
    AEA_P2P_POR_SIGNATURE=0x8dd7a585dc4a9c7186dfe66b728f610f4aeb422a27e79ec2bc7b11cd4ea0fdaf0ea7bb8efa2bb8844bb38a38b2df6675c87bcb444525bec22f7f7f69530d92861b
    AEA_P2P_POR_SERVICE_ID=acn
    AEA_P2P_POR_LEDGER_ID=ethereum

DEFAULT_LEDGER, DEFAULT_LEDGER_LIBP2P_NODE = "ethereum", "fetchai"; tests: PASS

    AEA_AGENT_ADDR=0x011a6845c7a09d5bF1316B783d9fB7C803bbfc8b
    AEA_P2P_ID=a369b5be68d3b5c166c782a50247a688f4018b06b6308f8cc72081840eaadcbc
    AEA_P2P_POR_ADDRESS=0x011a6845c7a09d5bF1316B783d9fB7C803bbfc8b
    AEA_P2P_POR_PUBKEY=0x7d8d0de693e1b80b78ff8e616ec47e8f70414ac3104cd85abab119d2da2877a5a6fff91081b49c3d2e7c094d91c161be5bef4989aad8ee692d98dc1d60f9e813
    AEA_P2P_POR_PEER_PUBKEY=035f0610ebb6be14c631c5463d095008a3e421474acc24b3d2cd4a9e7de01622f8
    AEA_P2P_POR_SIGNATURE=0x46e8a9a7acd315482ba9e43d576c7596efca50a68c01ef3a528dd8b241c85a863ddf7e8df8de286b843bb0d8435eedb8857f2cb69cbd55a85ad7a497b639f81c1c
    AEA_P2P_POR_SERVICE_ID=acn
    AEA_P2P_POR_LEDGER_ID=ethereum

DEFAULT_LEDGER, DEFAULT_LEDGER_LIBP2P_NODE = "ethereum", "cosmos"; tests: PASS

    AEA_AGENT_ADDR=0x1C1F3B595272111B175D11bF2EB805139cc4bFB6
    AEA_P2P_ID=1df5be4477279a942fee38de0aea301b1d642318f021ed2686e9d692a5cab7eb
    AEA_P2P_POR_ADDRESS=0x1C1F3B595272111B175D11bF2EB805139cc4bFB6
    AEA_P2P_POR_PUBKEY=0xf7b4fdd1624ead09eef4d3ba92d9a82d38f8726da0819d4877d19d2d76d6e40249e260d8c11de1a90439dc2b21520d1d9187b634184377944dcc95928cc36f8e
    AEA_P2P_POR_PEER_PUBKEY=03d3684a93e4de23175f070276ea5265f1c99cc377914b3c8eb948cd470e743d24
    AEA_P2P_POR_SIGNATURE=0xff5e4b629c42a3b22ac44262524ccf0897fcbf0049be1afa4f1fb29ea684c9b32f8cbe8f5586db970b1835089de8d7063cca70a9b61d8eeed70d76cb9baf29601c
    AEA_P2P_POR_SERVICE_ID=acn
    AEA_P2P_POR_LEDGER_ID=ethereum

summary observations:

the agent keys in any format works
the peer node keys in "Ethereum" format don't match golang expectations
NOTE: AEA_AGENT_ADDR and AEA_P2P_POR_ADDRESS are redundant

golang side:

observations

there are lots of FetchAI-named functions. In reality probably more general
there are 4 cryptolibraries that are using in the code base
NOTE: these contain modules, function as types that are highly similar or even identically named
```
  https://pkg.go.dev/crypto
  https://pkg.go.dev/github.com/libp2p/go-libp2p-core/crypto
  https://pkg.go.dev/github.com/ethereum/go-ethereum/crypto
  https://pkg.go.dev/github.com/btcsuite/btcd/btcec
```
for the crypto libraries now namedspaced: crypto, p2pCrypto, ethCrypto
the errors are passed back to main and raised only there, so you lose the tracestack.
Hence I added: file name and line no. in logging, full traceback on error

changing code:

errors faced: aea:connection.py:521 Couldn't connect to libp2p process: encoding/hex: invalid byte: U+0078 'x'

decoding error: "0x" prefix issue

dhtclient.IdentityFromFetchAIKey -> dhtclient.IdentityFromEthereumKey
dhtpeer.IdentityFromFetchAIKey -> dhtpeer.IdentityFromEthereumKey
utils.KeyPairFromFetchAIKey -> utils.KeyPairFromEthereumKey
aea:connection.py:521 Couldn't connect to libp2p process: Wrong peer public key

it seems like splitting off the "0x" is the right way to go. AgentRecord validation (IsValidProofOfRepresentation) fails, the logging shows
```
representativePeerPubKey: 029ad4a30398fbd4fc61996918e3e36bad3e9241d3e734373b9e795d209019141c 
record.PeerPublicKey:     0x9ad4a30398fbd4fc61996918e3e36bad3e9241d3e734373b9e795d209019141cbd680153b2c8847e2e2134315057004d50971af04b94d46c59ebed2b471a80ce
```
IsValidProofOfRepresentation is defined in dht/dhtnode/utils.go and used in
- dht/common/handlers.go
- dht/dhtnode/utils.go
- dht/dhtclient/dhtclient.go
In these FetchAI specific functions FetchAIPublicKeyFromPubKey and IDFromFetchAIPublicKey are used (defined in utils/utils.go). I implemented the EthereumPublicKeyFromPubKey, which replaces the first two characters of the pub2peer string with 0x

situation is now as follows
```
representativePeerPubKey: 0x52ed3305d6f8fd0bd8d65a1106c44df4b687dbb7d502fcf5e3e269f1a8242e3a 
record.PeerPublicKey:     0x52ed3305d6f8fd0bd8d65a1106c44df4b687dbb7d502fcf5e3e269f1a8242e3adfbda7478defbcdb9d2cc65f6ec572fb63c480136d947e052de0e788d9f98e05
```
Now needs to be figured out is how the other half of the peer public key can be retrieved.

EthereumPublicKeyFromPubKey
KeyPairFromEthereumKey
IDFromEthereumPublicKey
x509: unsupported elliptic curve

testing

the fetch/cosmos and ETH keys are of a different type

func TestFetchAIKeyType(t *testing.T) {
  privateKeyHex := "3e7a1f43b2d8a4b9f63a2ffeb1d597f971a8db7ffd95453173268b453106cadc"
  privKey, pubKey, err := KeyPairFromFetchAIKey(privateKeyHex)
  assert.Equal(t, nil, err)
  assert.Equal(t, "Secp256k1", privKey.Type().String())
  assert.Equal(t, "Secp256k1", pubKey.Type().String())
}

func TestEthereumKeyType(t *testing.T) {
  privateKeyHex := "0xbb0c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
  privKey, pubKey, err := KeyPairFromEthereumKey(privateKeyHex)
  assert.Equal(t, nil, err)
  assert.Equal(t, "ECDSA", privKey.Type().String())
  assert.Equal(t, "ECDSA", pubKey.Type().String())
}

get public key from private key (ensure this matches the environmental variable file)

this is interesting, since it showcases that although the pubKey can be retrieved,
(and type can be checked, see TestEthereumKeyType above)
but only gives an elliptic curve error when calling .Raw() to convert to bytes

func TestKeyPairFromEthereumKey(t *testing.T) {
  privateKeyHex := "0xbb0c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
  expectedPublicKeyHex := "0x4a47e8a74fab63f0a8e7615cc9776960159bc79cefc9b6e3164c4c4e018247f58ee51a200a4286fb49af6246c1e14649395a5e658209dbc6086c89530acf7ade"
  _, pubKey, err := KeyPairFromEthereumKey(privateKeyHex)
  assert.Equal(t, nil, err)
  // pubKeyBytes, err := pubKey.Raw() // x509: unsupported elliptic curve
  // assert.Equal(t, nil, err)
  publicKey, err := crypto.PubKeyToStdKey(pubKey)
  assert.Equal(t, nil, err)
  publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
  assert.Equal(t, true, ok)
  publicKeyBytes := ethCrypto.FromECDSAPub(publicKeyECDSA)
  publicKeyHex := hexutil.Encode(publicKeyBytes[1:]) // remove EC prefix "04"
  assert.Equal(t, expectedPublicKeyHex, publicKeyHex)
}

testing the implementation into KeyPairFromEthereumKey
func TestEthereumPublicKeyFromPubKey(t *testing.T) {
privateKeyHex := "0xbb0c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
expectedPublicKeyHex := "0x4a47e8a74fab63f0a8e7615cc9776960159bc79cefc9b6e3164c4c4e018247f58ee51a200a4286fb49af6246c1e14649395a5e658209dbc6086c89530acf7ade"
_, pubKey, err := KeyPairFromEthereumKey(privateKeyHex)
assert.Equal(t, nil, err)
publicKeyHex, err := EthereumPublicKeyFromPubKey(pubKey)
assert.Equal(t, nil, err)
assert.Equal(t, expectedPublicKeyHex, publicKeyHex)
}
now we still need to get the peerID from the public key
func TestIDFromEthereumPublicKey(t *testing.T) {
privateKeyHex := "0xbb0c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
_, pubKey, err := KeyPairFromEthereumKey(privateKeyHex)
assert.Equal(t, nil, err)
publicKeyHex, err := EthereumPublicKeyFromPubKey(pubKey)
assert.Equal(t, nil, err)
peerID, err := IDFromEthereumPublicKey(publicKeyHex) // Uncompressed
assert.Equal(t, nil, err)
assert.NotEqual(t, 0, len(peerID))
}

key features

representativePeerPubKey: 029ad4a30398fbd4fc61996918e3e36bad3e9241d3e734373b9e795d209019141c
record.PeerPublicKey: 0x9ad4a30398fbd4fc61996918e3e36bad3e9241d3e734373b9e795d209019141cbd680153b2c8847e2e2134315057004d50971af04b94d46c59ebed2b471a80ce

can of course fix first two bytes, that is quite useless (random other key set)

representativePeerPubKey: 0x52ed3305d6f8fd0bd8d65a1106c44df4b687dbb7d502fcf5e3e269f1a8242e3a 
record.PeerPublicKey:     0x52ed3305d6f8fd0bd8d65a1106c44df4b687dbb7d502fcf5e3e269f1a8242e3adfbda7478defbcdb9d2cc65f6ec572fb63c480136d947e052de0e788d9f98e05

What we learn here is that the key is compressed.
https://davidederosa.com/basic-blockchain-programming/elliptic-curve-keys/

e.g. 029ad4a30398fbd4fc61996918e3e36bad3e9241d3e734373b9e795d209019141c
where:

02 = positive
03 = negative
04 = uncompressed

we should thus be able to uncompress the key

looking into libp2p key generation

what we learn here is that the 'default' for libp2p keys is

Secp256k1: 32 and 33 bytes (private, public)
ECDSA: 121 and 91 bytes (private, public)
which does not match what we provide

func TestP2pCryptoGenerateKeyFeatures(t *testing.T) {
    // testing key features

    bits := 1000000000000 // arbitrary

    // Secp256k1
    privKey, pubKey, err := p2pCrypto.GenerateKeyPair(2, bits)
    assert.Equal(t, nil, err)
    assert.Equal(t, "Secp256k1", privKey.Type().String())
    assert.Equal(t, "Secp256k1", pubKey.Type().String())

    privKeyBytes, err := privKey.Raw()
    assert.Equal(t, nil, err)
    assert.Equal(t, 32, len(privKeyBytes))
    pubKeyBytes, err := pubKey.Raw()
    assert.Equal(t, nil, err)
    assert.Equal(t, 33, len(pubKeyBytes))
    privKeyHex := hexutil.Encode(privKeyBytes)
    assert.Equal(t, 66, len(privKeyHex))
    pubKeyHex := hexutil.Encode(pubKeyBytes)
    assert.Equal(t, 68, len(pubKeyHex))

    // ECDSA
    privKey, pubKey, err = p2pCrypto.GenerateKeyPair(3, bits)
    assert.Equal(t, nil, err)
    assert.Equal(t, "ECDSA", privKey.Type().String())
    assert.Equal(t, "ECDSA", pubKey.Type().String())

    privKeyBytes, err = privKey.Raw()
    assert.Equal(t, nil, err)
    assert.Equal(t, 121, len(privKeyBytes))
    pubKeyBytes, err = pubKey.Raw()
    assert.Equal(t, nil, err)
    assert.Equal(t, 91, len(pubKeyBytes))
    privKeyHex = hexutil.Encode(privKeyBytes)
    assert.Equal(t, 244, len(privKeyHex))
    pubKeyHex = hexutil.Encode(pubKeyBytes)
    assert.Equal(t, 184, len(pubKeyHex))
}

key uncompression

should be able to compute the pulbic key myself, knowing the elliptic curve. Trying to decompress the key

func TestEthereumKeyType2(t *testing.T) {
  // notice that size privateKeyHex is different from what p2pCrypto.GenerateKeyPair returns
  // it is clear we get back a compressed key, so we try to Uncompress the key
  privateKeyHex := "0xbb0c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
  expectedHexX := "c01836c9ddfc89a890d829dfaa569be545bac71cf20bbff8e02a114a2f042"
  // expected_y := big.NewInt(97623420452257389929300903432864757085799794291662452208633527327578777264531)

  compressed_bytes, err := hexutil.Decode(privateKeyHex) // Compressed
  assert.Equal(t, nil, err)

  sign_byte := uint(compressed_bytes[0]) // 02 or 03 (04 for uncompressed)
  x_bytes := compressed_bytes[1:]

  x := new(big.Int).SetBytes(x_bytes)
  three := big.NewInt(3)
  curve := elliptic.P256()
  c := curve.Params()

  // The equation is y^2 = x^3 - 3x + b
  // First, x^3, mod P
  x_cubed := new(big.Int).Exp(x, three, c.P)

  // Next, 3x, mod P
  three_X := new(big.Int).Mul(x, three)
  three_X.Mod(three_X, c.P)

  // x^3 - 3x ...
  y_squared := new(big.Int).Sub(x_cubed, three_X)

  // ... + b mod P
  y_squared.Add(y_squared, c.B)
  y_squared.Mod(y_squared, c.P)

  // Now we need to find the square root mod P.
  y := new(big.Int).ModSqrt(y_squared, c.P)
  assert.NotEqual(t, nil, y)

  if y.Bit(0) != sign_byte&1 {
    y.Neg(y)
    y.Mod(y, c.P)
  }

  assert.Equal(t, expectedHexX, toHexInt(x))

  is_on_curve := curve.IsOnCurve(x, y)
  assert.Equal(t, true, is_on_curve)

  // expectedHexY was not known to me
  // expectedHexY := "d7d4e5dbed33e68fa8bd5e82c9976fee3daee9712e93f79ca69d036c518d2193"
  // assert.Equal(t, expectedHexY, toHexInt(y))

  // x1, y1 := elliptic.UnmarshalCompressed(curve, compressed_bytes)
  // assert.Equal(t, x, x1)
  // assert.Equal(t, y, y1)

  // uncompressed := "0xbb0" + toHexInt(x) + toHexInt(y)
  // assert.Equal(t, 0, len(uncompressed))
  // bytes, err := hexutil.Decode(uncompressed)
  // assert.Equal(t, nil, err)

  privKey, err := p2pCrypto.UnmarshalECDSAPrivateKey(compressed_bytes)
  assert.Equal(t, 32, len(compressed_bytes))

  assert.Equal(t, nil, err)
  privK, err := privKey.Raw()
  assert.Equal(t, nil, err)
  assert.Equal(t, 32, len(privK))

  // privKey, pubKey, err := KeyPairFromEthereumKey(uncompressed)
  // assert.Equal(t, nil, err)
  // assert.Equal(t, "ECDSA", privKey.Type().String())
  // assert.Equal(t, "ECDSA", pubKey.Type().String())

  // // these are size we get from p2pCrypto.GenerateKeyPair for ECDSA
  // privKeyBytes, err := privKey.Raw()
  // assert.Equal(t, nil, err)
  // assert.Equal(t, 121, len(privKeyBytes))
  // pubKeyBytes, err := privKey.Raw()
  // assert.Equal(t, nil, err)
  // assert.Equal(t, 91, len(pubKeyBytes))

  // expectedPublicKeyHex := "0x4a47e8a74fab63f0a8e7615cc9776960159bc79cefc9b6e3164c4c4e018247f58ee51a200a4286fb49af6246c1e14649395a5e658209dbc6086c89530acf7ade"

  // assert.Equal(t, nil, err)
  // curve := elliptic.P256()
  // x, y := elliptic.Unmarshal(curve, privKeyBytes)
  // assert.Equal(t, 0, x)
  // assert.Equal(t, 0, y)
  // // privKeyHex = hexutil.Encode(privKeyBytes)

codecov-commenter · 2022-03-12T17:35:47Z

Codecov Report

Merging #85 (eced693) into main (ec0a276) will not change coverage.
The diff coverage is n/a.

@@           Coverage Diff           @@
##             main      #85   +/-   ##
=======================================
  Coverage   96.76%   96.76%           
=======================================
  Files         317      317           
  Lines       24763    24763           
=======================================
  Hits        23962    23962           
  Misses        801      801

Flag	Coverage Δ
unittests	`96.76% <ø> (ø)`

Flags with carried forward coverage won't be shown. Click here to find out more.

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update ec0a276...eced693. Read the comment docs.

8ball030 · 2022-03-13T21:14:38Z

tests/conftest.py

+DEFAULT_LEDGER_LIBP2P_NODE = "fetchai"  # Secp256k1 keys
+


Does this work if we just change it to eth?

nope, now changed to cosmos tho

DavidMinarsch

Please ensure linters pass

Please also open a PR on the go repo and reenable the test to check for matching code, once merged there.

Karrenbelt · 2022-03-15T13:23:16Z

Please also open a PR on the go repo and reenable the test to check for matching code, once merged there.

can we make it so that we simply download / install the open-acn repo into packages/open_aea/connections/p2p_libp2p/? effectively we would end up renaming
.../p2p_libp2p/linp2p_node/ to .../p2p_libp2p/open-acn/

DavidMinarsch · 2022-03-17T08:51:01Z

Please also open a PR on the go repo and reenable the test to check for matching code, once merged there.

can we make it so that we simply download / install the open-acn repo into packages/open_aea/connections/p2p_libp2p/? effectively we would end up renaming .../p2p_libp2p/linp2p_node/ to .../p2p_libp2p/open-acn/

Not at the moment. In a separate step we can make it a submodule. It is important that the whole packages with all its files is downloadable. Otherwise we need to extend the framework.

This reverts commit 1a69c60.

DavidMinarsch

lgtm

Karrenbelt added 5 commits March 12, 2022 10:30

test:change libp2p default ledger

e329b2b

test:p2p default agent eth & peernode fetch

f98ba8d

refactor: go imports

f0fd848

test:p2p default agent eth & peernode fetch

d89ff02

fix:traceback and stack trace

b7f540e

Karrenbelt force-pushed the ACN-keys branch from d89ff02 to 5535b3b Compare March 12, 2022 15:54

test:p2p default agent eth & peernode fetch

eced693

Karrenbelt force-pushed the ACN-keys branch from 5535b3b to eced693 Compare March 12, 2022 15:57

Karrenbelt requested a review from 8ball030 March 13, 2022 16:34

8ball030 reviewed Mar 13, 2022

View reviewed changes

Karrenbelt added 3 commits March 15, 2022 08:27

Merge branch 'ACN-keys-go-imports' into ACN-keys

a3b61ae

fix: stack traceback

d2b3dbf

test: cosmos and disabled code matching

be1df65

DavidMinarsch reviewed Mar 15, 2022

View reviewed changes

Karrenbelt added 2 commits March 15, 2022 14:24

fix:hashes

f617e42

test:debugging-keys

1a69c60

Karrenbelt added 3 commits March 17, 2022 11:09

Revert "test:debugging-keys"

f3158b9

This reverts commit 1a69c60.

fix: matching open-acn

901c8bb

Merge remote-tracking branch 'origin/main' into ACN-keys

d8360ea

Karrenbelt force-pushed the ACN-keys branch from ddf108e to d8360ea Compare March 17, 2022 18:41

Karrenbelt and others added 2 commits March 18, 2022 11:14

trigger

1e0481e

fix: hashes

91f5cc9

Karrenbelt requested a review from dvilelaf March 18, 2022 13:59

DavidMinarsch changed the title ~~[WIP] ACN keys~~ ACN keys Mar 19, 2022

DavidMinarsch approved these changes Mar 19, 2022

View reviewed changes

DavidMinarsch merged commit 5e35f68 into main Mar 19, 2022

DavidMinarsch mentioned this pull request Mar 19, 2022

[DO NOT MERGE] status update acn keys #79

Closed

DavidMinarsch deleted the ACN-keys branch March 19, 2022 23:30

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ACN keys #85

ACN keys #85

Karrenbelt commented Mar 12, 2022 •

edited

Loading

codecov-commenter commented Mar 12, 2022

8ball030 Mar 13, 2022

Karrenbelt Mar 18, 2022

DavidMinarsch left a comment

Karrenbelt commented Mar 15, 2022

DavidMinarsch commented Mar 17, 2022

DavidMinarsch left a comment

ACN keys #85

ACN keys #85

Conversation

Karrenbelt commented Mar 12, 2022 • edited Loading

ACN REPORT

documentation

Code

python side:

golang side:

codecov-commenter commented Mar 12, 2022

Codecov Report

8ball030 Mar 13, 2022

Choose a reason for hiding this comment

Karrenbelt Mar 18, 2022

Choose a reason for hiding this comment

DavidMinarsch left a comment

Choose a reason for hiding this comment

Karrenbelt commented Mar 15, 2022

DavidMinarsch commented Mar 17, 2022

DavidMinarsch left a comment

Choose a reason for hiding this comment

Karrenbelt commented Mar 12, 2022 •

edited

Loading