Athena: Initial POC integration #6380

lrettig · 2024-10-08T21:19:57Z

Motivation

Replace existing genvm functionality with athena

Description

clean up and refactor vm code
basic athena (Rust) integration
replace existing vm template-related code with calls into athena

Test Plan

Includes almost all existing production tests. Disabled a few tests that aren't compatible with the Athena VM, and also added a few Athena-specific tests.

TODO

Explain motivation or link existing issue(s)
Test changes and document test plan
Update documentation as needed

Misc

some of the systests rely on using vault, vesting, and multisig accounts. Athena currently doesn't support any of these. These systests were disabled or removed.
the genvm code remains but it's totally unused outside of genvm tests.
both old and new APIs have been updated to work with the Athena VM. Their existing tests are passing, but I haven't done extensive testing. The v2alpha API does differentiate between spawn and spend transactions, but some data (recipient, amount) is currently missing for spend transactions.
this PR also adds an Athena preset config, including genesis config, that can be used for running an Athena devnet/testnet. It's copied from the existing testnet config and just changes the genesis time and adds the single sig wallet template account, which needs to be part of the genesis accounts.
obviously, the plan is to eventually redo this integration from scratch. But this POC integration tries to make as few changes to existing code as possible. One consequence is that the VM code is messy. It probably doesn't make sense to split the wallet template and handler in Athena, for instance. Also, the host and context can probably be unified in a future, Athena-native implementation. The goal here is expediency, not pretty, maintainable code.
no other changes have been made to the node itself. It should be possible to run as on mainnet/testnet.
the account structure also remains mostly the same. The main difference is the addition of State and Storage blobs to the account. Storage is implemented very naively, as an array rather than as a hash table, for simplicity of serialization.
the encoded Athena payload is encoded again in the transaction, for now. This has to do with the way go-spacemesh encodes and decodes transactions. It's only capable of handling SCALE-encoded data types, so it was simplest to just SCALE-encode everything, even the opaque payload. This is much simpler but adds one byte to the tx length, which is an acceptable tradeoff for now.
this introduces new HRPs ath and atest for Athena transactions, and it changes the tx version byte to 1.

This functionality is being moved into the VM, or refactored here

and mock a few things while we wait for them to be implemented in Athena

We may need this later, to pass into the VM template

Host tests passing

Remove unneeded scaffolding

GetBalance test WIP

Upgrade to latest athena bindings Fix host call logic

common/types/transaction_header.go

go.mod

Untested so far

Update athena go binding

fix encoding of verify args

Cleanup disabled tests and unneeded code

And fix a bug in the way genesis templates are bootstrapped

codecov · 2024-11-05T02:32:23Z

Codecov Report

Attention: Patch coverage is 70.44335% with 300 lines in your changes missing coverage. Please review.

Project coverage is 79.4%. Comparing base (81da1cd) to head (69a90c5).
Report is 1 commits behind head on athena-poc.

Files with missing lines	Patch %	Lines
vm/host/host.go	49.5%	99 Missing and 9 partials ⚠️
vm/templates/wallet/wallet.go	63.1%	35 Missing and 18 partials ⚠️
vm/core/context.go	75.8%	25 Missing and 12 partials ⚠️
vm/vm.go	78.0%	20 Missing and 11 partials ⚠️
vm/templates/wallet/handler.go	62.9%	13 Missing and 7 partials ⚠️
api/grpcserver/v2alpha1/transaction.go	64.8%	8 Missing and 5 partials ⚠️
vm/sdk/wallet/tx.go	76.1%	6 Missing and 4 partials ⚠️
vm/core/staged_cache.go	0.0%	7 Missing ⚠️
vm/templates/wallet/gas.go	30.0%	7 Missing ⚠️
vm/core/types.go	70.0%	4 Missing and 2 partials ⚠️
... and 2 more

Additional details and impacted files

@@             Coverage Diff              @@
##           athena-poc   #6380     +/-   ##
============================================
- Coverage        80.3%   79.4%   -0.9%     
============================================
  Files             328     330      +2     
  Lines           35765   42715   +6950     
============================================
+ Hits            28752   33957   +5205     
- Misses           5153    6812   +1659     
- Partials         1860    1946     +86

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

lrettig · 2024-11-05T02:36:57Z

@poszu this is ready for review. All tests are passing on ubuntu; mac tests are failing due to athenavm/athena#215 which is unrelated to the changes here. Sorry this is so big, but this is a minimum viable integration!

poszu

Posting an in-progress review - I will continue tommorow.

poszu · 2024-11-07T12:04:23Z

.github/workflows/ci.yml

@@ -126,7 +126,7 @@ jobs:
        os:
          - ubuntu-22.04
          - ubuntu-latest-arm-8-cores
-          - macos-13
+          # - macos-13


It would be helpful to leave a note about why it's disabled and when it should be re-enabled:

Suggested change

# - macos-13

# Athena doesn't support Intel Mac

# - macos-13

poszu · 2024-11-07T12:05:04Z

.github/workflows/release.yml

+          # - os: macos-13
+          #   outname_sufix: "mac-amd64"


Ditto

Suggested change

# - os: macos-13

# outname_sufix: "mac-amd64"

# Athena doesn't support Intel Mac

# - os: macos-13

# outname_sufix: "mac-amd64"

poszu · 2024-11-07T12:19:41Z

vm/core/hash.go

@@ -1,10 +1,11 @@
 package core

 import (
-	"github.com/spacemeshos/go-scale"
+	"github.com/ChainSafe/gossamer/pkg/scale"


Why not use the go-scale?

Because it's harder to work with. It requires pre-generated scale types. With gossamer, you just pass in the data structure instance and get its serialization--as in Rust.

We already use go-scale extensively and it's not been a problem so far. IMHO, consistency (using the same tool for encoding) is important. Probably the problem would be that go-scale by default encodes integers in the compact way. It supports non-compact encoding, but I'm not sure if it has a struct tag to switch to non-compact - perhaps this would need to be added. Or we could switch to compact encoding on the VM side.

poszu · 2024-11-07T12:39:53Z

vm/core/hash.go

+	if err != nil {
+		return Address{}, err
+	}


I think it's fine to panic in this situation, encoding should never fail. A lot of code would become simpler without this unnecessary error handling.

unless we later change encoding :)

poszu · 2024-11-07T13:10:06Z

vm/core/types.go

+func (t *Payload) EncodeScale(enc *scale.Encoder) (total int, err error) {
+	{
+		n, err := scale.EncodeByteSlice(enc, *t)
+		if err != nil {
+			return total, err
+		}
+		total += n
+	}
+
+	return total, nil
+}


Suggested change

func (t *Payload) EncodeScale(enc *scale.Encoder) (total int, err error) {

{

n, err := scale.EncodeByteSlice(enc, *t)

if err != nil {

return total, err

}

total += n

}

return total, nil

}

func (t *Payload) EncodeScale(enc *scale.Encoder) (int, error) {

return scale.EncodeByteSlice(enc, *t)

}

poszu · 2024-11-07T15:53:29Z

vm/host/host_test.go

+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err)


Consider:

Suggested change

logger, err := zap.NewDevelopment()

require.NoError(t, err)

logger := zaptest.NewLogger(t)

poszu · 2024-11-07T16:02:27Z

vm/host/host_test.go

+func TestEmptyCode(t *testing.T) {
+	host, _ := getHost(t)
+	defer host.Destroy()
+
+	_, _, err := host.Execute(
+		10,
+		10,
+		types.Address{1, 2, 3, 4},
+		types.Address{1, 2, 3, 4},
+		nil,
+		0,
+		[]byte{},
+	)
+
+	require.ErrorContains(t, err, "athcon execute: no input code")
+}


It's not testing any functionality implemented in go-spacemesh but in the Athena bindings. I'd remove it.

but that's testing the contract between node and athena lib. imo it's fine.

A contract that it is impossible to execute empty code? This test is already present in the athcon library: https://github.com/athenavm/athena/blob/3f397a807111db7fc9a1ea9efd3be93bd3007730/ffi/athcon/bindings/go/athcon_test.go#L55-L66.

I mean, the check if code is empty is in the athcon library (not anywhere in the go-spacemesh) and it already has a test. It's a requirement imposed by the athcon's vm.Execute() method that the code cannot be empty. The user of the library doesn't need to verify if the library tests its inputs IMO.

can we say it tests whether errors are correctly surfaced from VM -> host? :)

poszu · 2024-11-07T16:09:43Z

vm/host/host_test.go

+func TestSetGetStorage(t *testing.T) {
+	host, cache := getHost(t)
+	defer host.Destroy()
+
+	storageKey := athcon.Bytes32{0xc0, 0xff, 0xee}
+	storageValue := athcon.Bytes32{0xde, 0xad, 0xbe, 0xef}
+
+	address := types.Address{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+	account := types.Account{
+		Address: address,
+		Balance: 10000,
+		Storage: []types.StorageItem{
+			{Key: storageKey, Value: storageValue},
+		},
+	}
+	err := cache.Update(account)
+	require.NoError(t, err)
+
+	_, gasLeft, err := host.Execute(
+		account.Layer,
+		100000,
+		account.Address,
+		account.Address,
+		nil,
+		0,
+		hostprogram.PROGRAM,
+	)


IMHO, the host functionalities could be tested without running actual programs in the VM. The host has an API exposed to VM which abstracts things nicely and the host features could be tested by exercising this API.

In this test, it's not even possible to tell what the hostprogram.PROGRAM will do because there is no source code for it (same for the get balance test above).

poszu · 2024-11-07T16:11:49Z

txs/handler_test.go

-	req := smocks.NewMockValidationRequest(ctrl)
-	req.EXPECT().Parse().Times(1).Return(tx.TxHeader, nil)
+	req := smocks.NewMockValidationRequestNew(ctrl)
+	req.EXPECT().Cache().Times(1).Return(nil)


NIT: Times(1) and Return(nil) are defaults, so it's equivalent to:

Suggested change

req.EXPECT().Cache().Times(1).Return(nil)

req.EXPECT().Cache()

IMHO less is more and it's more readable (less cluttered) this way.

poszu · 2024-11-07T16:18:27Z

vm/vm.go

@@ -79,7 +82,7 @@ type VM struct {
 }

 // Validation initializes validation request.
-func (v *VM) Validation(raw types.RawTx) system.ValidationRequest {
+func (v *VM) Validation(raw types.RawTx) system.ValidationRequestNew {


Why does it return an interface instead of the Request struct that implements it?

Suggested change

func (v *VM) Validation(raw types.RawTx) system.ValidationRequestNew {

func (v *VM) Validation(raw types.RawTx) *Request {

It's against the common rule "accept interfaces, return concrete implementations". Is there a need for this?

poszu · 2024-11-08T12:04:53Z

api/grpcserver/grpcserver_test.go

+		tx2, err := wallet.Spend(signer.PrivateKey(), recipient, 1, nonce, sdk.WithGasPrice(0))
+		if err != nil {
+			panic(err)
+		}
+		tx.RawTx = types.NewRawTx(tx2)


As NewTx is a test-only function, it could take tb testing.TB and then this could be simplified to:

Suggested change

tx2, err := wallet.Spend(signer.PrivateKey(), recipient, 1, nonce, sdk.WithGasPrice(0))

if err != nil {

panic(err)

}

tx.RawTx = types.NewRawTx(tx2)

tx2, err := wallet.Spend(signer.PrivateKey(), recipient, 1, nonce, sdk.WithGasPrice(0))

require.NoError(tb, err)

tx.RawTx = types.NewRawTx(tx2)

poszu · 2024-11-08T12:11:11Z

api/grpcserver/v2alpha1/transaction.go

-		t.Method = uint32(tx.Method)
+		// t.Method = uint32(tx.Method)


What about the method?

this is tricky in Athena. method is part of the opaque payload, and I want to hide that from the node and from the host as much as possible. we break this abstraction in a few places already, gently. we need to debate whether we want the API to parse this data for the client, or whether we should instead have it return the opaque payload and require the client to parse this using an athena SDK.

poszu · 2024-11-08T12:58:30Z

api/grpcserver/v2alpha1/transaction.go

+	if spawnSelector, err := athcon.FromString("athexp_spawn"); err != nil {
+		return res, txType, fmt.Errorf("%w: failed to create spawn selector: %w", core.ErrInternal, err)
+	} else if spendSelector, err := athcon.FromString("athexp_spend"); err != nil {
+		return res, txType, fmt.Errorf("%w: failed to create spend selector: %w", core.ErrInternal, err)
+	} else if *method == spawnSelector {


There is no need for else branches, as the previous branch returns on error. Consider:

Suggested change

if spawnSelector, err := athcon.FromString("athexp_spawn"); err != nil {

return res, txType, fmt.Errorf("%w: failed to create spawn selector: %w", core.ErrInternal, err)

} else if spendSelector, err := athcon.FromString("athexp_spend"); err != nil {

return res, txType, fmt.Errorf("%w: failed to create spend selector: %w", core.ErrInternal, err)

} else if *method == spawnSelector {

spawnSelector, err := athcon.FromString("athexp_spawn")

if err != nil {

return res, txType, fmt.Errorf("%w: failed to create spawn selector: %w", core.ErrInternal, err)

}

spendSelector, err := athcon.FromString("athexp_spend")

if err != nil {

return res, txType, fmt.Errorf("%w: failed to create spend selector: %w", core.ErrInternal, err)

}

switch *method {

case == spawnSelector:

// body

case == spendSelector:

// body

poszu · 2024-11-08T13:02:40Z

common/types/transaction_header.go

+	// TODO(lane): Method is unused by the Athena VM, and should be removed.
+	Method uint8


Why keep it?

poszu · 2024-11-08T13:11:17Z

system/vm.go

+type ValidationRequestNew interface {
+	Parse(core.AccountLoader) (*types.TxHeader, error)
+	Verify() bool
+	Cache() *core.StagedCache


I don't understand the need for Cache(). It's only used as a parameter for Parse() as far as I can tell. Why have it?

poszu · 2024-11-08T14:26:31Z

vm/sdk/wallet/tx.go

+	// sig := ed25519.Sign(ed25519.PrivateKey(pk), core.SigningBody(options.GenesisID[:], tx))
+	sig := ed25519.Sign(ed25519.PrivateKey(pk), tx)


What about this?

not sure what you mean

Sorry, I meant that there is // sig := ed25519.Sign(ed25519.PrivateKey(pk), core.SigningBody(options.GenesisID[:], tx)) left. I understand that genesis should be included - I'm asking what the plan is for it. If not, the commented line could be removed.

We need to decide how we want to implement genesisID support in Athena. Assuming we do it in a way that's compatible with what go-spacemesh does today, then these commented lines can just be restored once that's been added on the Athena side.

poszu · 2024-11-08T14:27:02Z

vm/sdk/wallet/tx.go

+	// tx := encode(&sdk.TxVersion, &principal, &meta)
+	// tx = append(tx, payload...)


Suggested change

// tx := encode(&sdk.TxVersion, &principal, &meta)

// tx = append(tx, payload...)

I leave the commented-out code here when it's clear that we need to add it back later (in this case, once we have athenavm/athena#178)

poszu · 2024-11-08T14:27:15Z

vm/sdk/wallet/tx.go

+	// sig := ed25519.Sign(ed25519.PrivateKey(pk), core.SigningBody(options.GenesisID[:], tx))
+	sig := ed25519.Sign(ed25519.PrivateKey(pk), tx)


poszu · 2024-11-08T14:27:33Z

vm/sdk/wallet/tx.go

+	// tx := encode(&sdk.TxVersion, &principal, &meta)
+	// tx = append(tx, payload...)


Suggested change

// tx := encode(&sdk.TxVersion, &principal, &meta)

// tx = append(tx, payload...)

vm/vm.go

brusherru · 2024-11-13T14:29:30Z

vm/core/hash.go

+func ComputePrincipalFromPubkey(template types.Address, pubkey signing.PublicKey) (Address, error) {
+	// construct and encode the blob, which is a SCALE-encoded Athena wallet template instance
+	blob, err := scale.Marshal(struct {
+		Nonce, Balance uint64


Why do we need Balance here?
IMO it looks weird to add balance as a "hidden spawn argument" for the Wallet account type, it's not a vault or some token smart-contract (total issuance)...

Btw, also I guess such Nonce field should be a part of payload of spawn tx, and it's the different nonce from the "tx counter"

yes, as discussed in Slack, nonce and balance should be removed -- not just from here, but from the VM side as well.

this struct just mimics the Athena wallet program's struct. rather than encoding it manually here, we might choose instead to add an exported method to Athena that performs this serialization so we don't need to keep these two data structures/codecs in sync.

brusherru · 2024-11-14T12:32:47Z

Also I suggest to use another TemplateAddress for Athena's Wallet to avoid collisions with the "genvm" template addresses, just to keep things simpler.

This reverts commit 4d404cb.

poszu · 2024-11-18T12:33:50Z

vm/core/hash.go

+// ComputePrincipal address as the last 24 bytes of Hash(template || blob).
+// See https://github.com/spacemeshos/go-spacemesh/issues/6420 for more details.
+func ComputePrincipalFromBlob(template types.Address, blob []byte) Address {
 	hasher := hash.GetHasher()
 	defer hash.PutHasher(hasher)
-	encoder := scale.NewEncoder(hasher)
-	template.EncodeScale(encoder)
-	args.EncodeScale(encoder)
+	hasher.Write(template[:])
+	hasher.Write(blob)
 	sum := hasher.Sum(nil)
-	rst := types.GenerateAddress(sum[12:])
-	return rst
+	return types.GenerateAddress(sum)
+}


I'm unsure if using types.GenerateAddress is OK here, see its implementation:

go-spacemesh/common/types/address.go

Lines 132 to 139 in 40d4ba6

func GenerateAddress(publicKey []byte) Address {

var addr Address

if len(publicKey) > len(addr)-AddressReservedSpace {

publicKey = publicKey[len(publicKey)-AddressLength+AddressReservedSpace:]

}

copy(addr[AddressReservedSpace:], publicKey[:])

return addr

}

It does more than taking the upper 24B - it also reserves the lower 4B of the returned address (they are zeros)

isn't it 20B (used) + 4B (reserved) = 24B total?

then that should be fine, since Athena also uses 24 byte addresses. I don't understand your initial comment here.

poszu · 2024-11-18T13:20:51Z

vm/programs/wallet/wallet.bin

Is it built from the example wallet in the athena repo? Why not have the sources of the wallet in go-sm?

yes. definitely, can do, it's just duplicative.

Well, the one in athena repo is an example :) I think the right place for the wallet template code is go-spacemesh, even if it's a duplicate, to avoid breaking the devnet by some changes to the example wallet code in the athena repo.

poszu · 2024-11-18T14:49:21Z

vm/templates/wallet/wallet.go

+	vmhost, err := vmhost.NewHost(host)
+	if err != nil {
+		return 0, fmt.Errorf("loading Athena VM: %w", err)
+	}


Here and in few other places the VM is not destroyed (missing call to Destroy)

Suggested change

vmhost, err := vmhost.NewHost(host)

if err != nil {

return 0, fmt.Errorf("loading Athena VM: %w", err)

}

vmhost, err := vmhost.NewHost(host)

if err != nil {

return 0, fmt.Errorf("loading Athena VM: %w", err)

}

defer vmhost.Destroy()

lrettig · 2024-11-22T07:51:18Z

Also I suggest to use another TemplateAddress for Athena's Wallet to avoid collisions with the "genvm" template addresses, just to keep things simpler.

we should keep using the existing hardcoded scheme that we’re using in genVM. there is no conflict here. athena and genvm will never exist in the same namespace, even if athena runs as a L2 on top of spacemesh.

for user-deployed templates, yes, we calculate the template address as a hash of the code, but this isn’t the case for harcoded templates, of which there must always be at least one (the single-sig wallet). we can debate whether we want to add other hardcoded templates later (e.g., a multisig), but it’s not strictly necessary as long as there’s one to “bootstrap” everything.

poszu · 2024-11-22T08:04:08Z

we can debate whether we want to add other hardcoded templates later (e.g., a multisig), but it’s not strictly necessary as long as there’s one to “bootstrap” everything.

Who would pay for deploying the other "basic" templates? I think it'd be easier to integrate if they were hardcoded in the genesis config.

lrettig · 2024-11-23T10:52:03Z

we can debate whether we want to add other hardcoded templates later (e.g., a multisig), but it’s not strictly necessary as long as there’s one to “bootstrap” everything.

Who would pay for deploying the other "basic" templates? I think it'd be easier to integrate if they were hardcoded in the genesis config.

We would just deploy them ourselves at or shortly after genesis. We'd link to these deployed templates in the documents, in our SDKs, etc. - that's my understanding of how things work in, e.g., Solana, which has a standard template library.

If we hardcode them, how do we handle upgrading the template later?

lrettig added 3 commits October 8, 2024 14:15

Switch node VM to athena

a0bd91b

Remove unused context methods and data items

95620c3

This functionality is being moved into the VM, or refactored here

Ignore athena compressed artifacts in top dir

2baf0c6

lrettig added the area/vm label Oct 8, 2024

lrettig added 12 commits October 8, 2024 16:13

Remove some more unused methods

69c33c7

and mock a few things while we wait for them to be implemented in Athena

Linter

e134441

Add pubkey back to wallet template

2e94bda

We may need this later, to pass into the VM template

Continue to clean up tx handling

b764ab8

More cleanup

92be516

Continuing rewrite of VM parse code (WIP)

d4eab1a

Ongoing integration work (WIP)

c91bdda

Integrate latest Athena release

b3f4865

Host tests passing

Refactor Athena template code

7e8bdd6

Remove unneeded scaffolding

First draft of Call implementation for host

510306e

GetBalance test WIP

First working e2e host test

11cfdcc

Upgrade to latest athena bindings Fix host call logic

VM execution WIP

dab770c

poszu reviewed Oct 22, 2024

View reviewed changes

common/types/transaction_header.go Outdated Show resolved Hide resolved

go.mod Outdated Show resolved Hide resolved

Finish initial handler Exec implementation

638b604

Untested so far

lrettig mentioned this pull request Oct 23, 2024

Update API to support Athena VM #6409

Open

lrettig added 11 commits October 23, 2024 12:25

Checkpoint: rewriting template to use VM

e2d55b8

MaxSpend test is working

d5b947d

Checkpoint: working on TestVerify

d3e6bd7

Checkpoint: debugging verify test

28a6cc5

Update athena go binding

Spawn test is working

cb0b07a

TestVerify is passing

6bcd565

fix encoding of verify args

Remove genesisID from tx generation for now

9b5543d

Checkpoint: refactoring parse

52e7cf6

Upgrade athena bindings to v0.5.0

1235f36

Rewrite VM parse logic

b847c32

Add scale limit for payload

2ad4adf

lrettig added 6 commits November 4, 2024 14:00

Fix vm host test

67852f2

Fix wallet template tests

294fe6b

More linting

1d2f6a7

Cleanup disabled tests and unneeded code

Fix blocks tests

df9ac86

Fix TransactionService test

6e7942f

And fix a bug in the way genesis templates are bootstrapped

Fix transaction tests

bb5dc73

lrettig marked this pull request as ready for review November 5, 2024 02:36

lrettig requested review from dshulyak, fasmat, ivan4th, acud and jellonek as code owners November 5, 2024 02:36

lrettig requested a review from poszu November 5, 2024 18:11

Use nightly athena release

433daf5

poszu reviewed Nov 7, 2024

View reviewed changes

poszu requested changes Nov 8, 2024

View reviewed changes

brusherru reviewed Nov 13, 2024

View reviewed changes

poszu added 3 commits November 15, 2024 11:43

bump athena to v0.5.3

0f8e560

reenable building on macos-13

4d404cb

Revert "reenable building on macos-13"

69a90c5

This reverts commit 4d404cb.

poszu mentioned this pull request Nov 15, 2024

update #6380 with addressed some review feedback #6462

Open

poszu requested changes Nov 18, 2024

View reviewed changes

poszu reviewed Nov 18, 2024

View reviewed changes

	logger, err := zap.NewDevelopment()
	require.NoError(t, err)
	logger := zaptest.NewLogger(t)

	req.EXPECT().Cache().Times(1).Return(nil)
	req.EXPECT().Cache()

	func (v *VM) Validation(raw types.RawTx) system.ValidationRequestNew {
	func (v VM) Validation(raw types.RawTx) Request {

		// TODO(lane): Method is unused by the Athena VM, and should be removed.
		Method uint8

		// sig := ed25519.Sign(ed25519.PrivateKey(pk), core.SigningBody(options.GenesisID[:], tx))
		sig := ed25519.Sign(ed25519.PrivateKey(pk), tx)

		// tx := encode(&sdk.TxVersion, &principal, &meta)
		// tx = append(tx, payload...)

	func GenerateAddress(publicKey []byte) Address {
	var addr Address
	if len(publicKey) > len(addr)-AddressReservedSpace {
	publicKey = publicKey[len(publicKey)-AddressLength+AddressReservedSpace:]
	}
	copy(addr[AddressReservedSpace:], publicKey[:])
	return addr
	}

Athena: Initial POC integration #6380

Are you sure you want to change the base?

Athena: Initial POC integration #6380

Conversation

lrettig commented Oct 8, 2024 • edited Loading

Motivation

Description

Test Plan

TODO

Misc

codecov bot commented Nov 5, 2024 • edited Loading

Codecov Report

lrettig commented Nov 5, 2024

poszu left a comment

Choose a reason for hiding this comment

poszu Nov 7, 2024 • edited Loading

Choose a reason for hiding this comment

poszu Nov 7, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lrettig Nov 22, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

brusherru Nov 13, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lrettig Nov 22, 2024 • edited Loading

Choose a reason for hiding this comment

brusherru commented Nov 14, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lrettig commented Nov 22, 2024

poszu commented Nov 22, 2024

lrettig commented Nov 23, 2024

lrettig commented Oct 8, 2024 •

edited

Loading

codecov bot commented Nov 5, 2024 •

edited

Loading

poszu Nov 7, 2024 •

edited

Loading

poszu Nov 7, 2024 •

edited

Loading

lrettig Nov 22, 2024 •

edited

Loading

brusherru Nov 13, 2024 •

edited

Loading

lrettig Nov 22, 2024 •

edited

Loading