mirror of
https://github.com/luxfi/proto.git
synced 2026-10-30 15:21:09 +00:00
zeekayandHanzo Dev
938b06d485
proto required luxfi/node and luxfi/node required proto, with no replace directive on either side. The cycle was not load-bearing: most of it was proto reaching into the node for packages proto already owns — p/warp, p/txs, p/signer, p/stakeable, p/security, x/txs — which now name themselves. Two were real. The UTXO components moved here, where the chains that use them already live, and the node is the only other caller, so that dependency now runs one way. And p/config held the node's chain manager to queue a chain the P-Chain had accepted a CreateChainTx for; it calls one method, so it declares one method. A P-Chain that imports the node to describe QueueChainCreation is what made two modules require each other. Dropping the requirement dropped a registration with it: lux.ParseUTXO is a registry filled by an init, which the node used to link in on proto's behalf. The packages that call it now say so themselves. Co-authored-by: Hanzo Dev <[email protected]>
94 lines
2.3 KiB
Go
94 lines
2.3 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package lux
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/luxfi/ids"
|
|
"github.com/luxfi/math/set"
|
|
"github.com/luxfi/vm/chains/atomic"
|
|
)
|
|
|
|
var _ AtomicUTXOManager = (*atomicUTXOManager)(nil)
|
|
|
|
type atomicUTXOManager struct {
|
|
sm atomic.SharedMemory
|
|
}
|
|
|
|
// NewAtomicUTXOManager returns an AtomicUTXOManager backed by ZAP-native
|
|
// wire bytes in cross-chain shared memory (no codec.Manager). Callers rely
|
|
// on this package's init() fx-aware UTXO.Unmarshal dispatch.
|
|
func NewAtomicUTXOManager(sm atomic.SharedMemory) AtomicUTXOManager {
|
|
return &atomicUTXOManager{sm: sm}
|
|
}
|
|
|
|
func (a *atomicUTXOManager) GetAtomicUTXOs(
|
|
chainID ids.ID,
|
|
addrs set.Set[ids.ShortID],
|
|
startAddr ids.ShortID,
|
|
startUTXOID ids.ID,
|
|
limit int,
|
|
) ([]*UTXO, ids.ShortID, ids.ID, error) {
|
|
addrsList := make([][]byte, addrs.Len())
|
|
i := 0
|
|
for addr := range addrs {
|
|
copied := addr
|
|
addrsList[i] = copied[:]
|
|
i++
|
|
}
|
|
|
|
allUTXOBytes, lastAddr, lastUTXO, err := a.sm.Indexed(
|
|
chainID,
|
|
addrsList,
|
|
startAddr.Bytes(),
|
|
startUTXOID[:],
|
|
limit,
|
|
)
|
|
if err != nil {
|
|
return nil, ids.ShortID{}, ids.Empty, fmt.Errorf("error fetching atomic UTXOs: %w", err)
|
|
}
|
|
|
|
lastAddrID, err := ids.ToShortID(lastAddr)
|
|
if err != nil {
|
|
lastAddrID = ids.ShortEmpty
|
|
}
|
|
lastUTXOID, err := ids.ToID(lastUTXO)
|
|
if err != nil {
|
|
lastUTXOID = ids.Empty
|
|
}
|
|
|
|
utxos := make([]*UTXO, len(allUTXOBytes))
|
|
for i, utxoBytes := range allUTXOBytes {
|
|
utxo := &UTXO{}
|
|
if err := utxo.Unmarshal(utxoBytes); err != nil {
|
|
return nil, ids.ShortID{}, ids.Empty, fmt.Errorf("error parsing UTXO: %w", err)
|
|
}
|
|
utxos[i] = utxo
|
|
}
|
|
return utxos, lastAddrID, lastUTXOID, nil
|
|
}
|
|
|
|
// GetAtomicUTXOs returns exported UTXOs such that at least one of the
|
|
// addresses in [addrs] is referenced.
|
|
//
|
|
// Returns at most [limit] UTXOs.
|
|
//
|
|
// Returns:
|
|
// * The fetched UTXOs
|
|
// * The address associated with the last UTXO fetched
|
|
// * The ID of the last UTXO fetched
|
|
// * Any error that may have occurred upstream.
|
|
func GetAtomicUTXOs(
|
|
sharedMemory atomic.SharedMemory,
|
|
chainID ids.ID,
|
|
addrs set.Set[ids.ShortID],
|
|
startAddr ids.ShortID,
|
|
startUTXOID ids.ID,
|
|
limit int,
|
|
) ([]*UTXO, ids.ShortID, ids.ID, error) {
|
|
manager := NewAtomicUTXOManager(sharedMemory)
|
|
return manager.GetAtomicUTXOs(chainID, addrs, startAddr, startUTXOID, limit)
|
|
}
|