ceremonyclient/node/app/db_console.go
Cassandra Heart 5405452f3e
v1.2.11 (#58)
2024-02-20 14:01:10 -06:00

897 lines
25 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package app
import (
"bytes"
"context"
"encoding/base64"
"encoding/hex"
"fmt"
"math/big"
"os"
"strings"
"time"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/peer"
"github.com/multiformats/go-multiaddr"
mn "github.com/multiformats/go-multiaddr/net"
"github.com/pkg/errors"
"golang.org/x/term"
"google.golang.org/grpc"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/credentials/insecure"
"source.quilibrium.com/quilibrium/monorepo/node/config"
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/ceremony/application"
"source.quilibrium.com/quilibrium/monorepo/node/p2p"
"source.quilibrium.com/quilibrium/monorepo/node/protobufs"
"source.quilibrium.com/quilibrium/monorepo/node/tries"
)
var (
textColor = lipgloss.Color("#fff")
primaryColor = lipgloss.Color("#ff0070")
secondaryColor = lipgloss.Color("#ff5c00")
windowHeader = lipgloss.NewStyle().
Foreground(textColor).
Padding(0, 1)
unselectedListStyle = lipgloss.NewStyle().
Foreground(textColor).
Width(28).
Padding(0, 1)
navigatedListStyle = lipgloss.NewStyle().
Foreground(textColor).
Width(28).
Bold(true).
Padding(0, 1)
selectedListStyle = lipgloss.NewStyle().
Foreground(textColor).
Background(primaryColor).
Width(28).
Padding(0, 1)
statusBarStyle = lipgloss.NewStyle().
Foreground(textColor).
Background(primaryColor)
statusStyle = lipgloss.NewStyle().
Foreground(textColor).
Background(primaryColor).
Padding(0, 1)
statusItemStyle = lipgloss.NewStyle().
Foreground(textColor).
Background(secondaryColor).
Padding(0, 1)
docStyle = lipgloss.NewStyle().Padding(0)
border = lipgloss.Border{
Top: "─",
Bottom: "─",
Left: "│",
Right: "│",
TopLeft: "┌",
TopRight: "┐",
BottomLeft: "└",
BottomRight: "┘",
}
)
type DBConsole struct {
nodeConfig *config.Config
}
func newDBConsole(nodeConfig *config.Config) (*DBConsole, error) {
return &DBConsole{
nodeConfig,
}, nil
}
type model struct {
filters []string
cursor int
selectedFilter string
conn *grpc.ClientConn
client protobufs.NodeServiceClient
peerId string
errorMsg string
frame *protobufs.ClockFrame
frames []*protobufs.ClockFrame
frameIndex int
grpcWarn bool
committed bool
lastChecked int64
owned *big.Int
unconfirmedOwned *big.Int
}
func (m model) Init() tea.Cmd {
return nil
}
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
if m.conn.GetState() == connectivity.Ready {
if m.lastChecked < (time.Now().UnixMilli() - 10_000) {
m.lastChecked = time.Now().UnixMilli()
tokenBalance, err := FetchTokenBalance(m.client)
if err == nil {
m.owned = tokenBalance.Owned
m.unconfirmedOwned = tokenBalance.UnconfirmedOwned
}
}
}
switch msg := msg.(type) {
case tea.KeyMsg:
switch msg.String() {
case "ctrl+c", "q":
return m, tea.Quit
case "up", "w":
if m.cursor > 0 {
m.cursor--
}
case "down", "s":
if m.cursor < len(m.filters)-1 {
m.cursor++
}
case "left", "a":
m.committed = false
m.errorMsg = ""
if m.frameIndex > 0 {
m.frameIndex--
if len(m.frames) != 0 && m.conn.GetState() == connectivity.Ready {
filter, _ := hex.DecodeString(m.selectedFilter)
selector, err := m.frames[m.frameIndex].GetSelector()
if err != nil {
m.errorMsg = err.Error()
break
}
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
},
)
if err == nil && bytes.Equal(
frameInfo.ClockFrame.Output,
m.frames[m.frameIndex].Output,
) {
m.committed = true
m.frame = frameInfo.ClockFrame
} else {
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
Selector: selector.FillBytes(make([]byte, 32)),
},
)
if err != nil {
m.errorMsg = hex.EncodeToString(
selector.FillBytes(make([]byte, 32)),
) + ":" + err.Error()
break
}
m.frame = frameInfo.ClockFrame
}
} else {
m.errorMsg = "Not currently connected to node, cannot query."
}
} else {
first := uint64(0)
if len(m.frames) != 0 {
first = m.frames[0].FrameNumber - 1
}
if first == 0 {
break
}
max := uint64(17)
if len(m.frames) != 0 {
max = first
}
min := max - 16
filter, _ := hex.DecodeString(m.selectedFilter)
frames, err := m.client.GetFrames(
context.Background(),
&protobufs.GetFramesRequest{
Filter: filter,
FromFrameNumber: min,
ToFrameNumber: max + 1,
IncludeCandidates: true,
},
)
if err != nil {
m.selectedFilter = ""
m.errorMsg = err.Error()
break
}
if frames.TruncatedClockFrames != nil {
m.frames = frames.TruncatedClockFrames
m.frameIndex = len(m.frames) - 1
selector, err := m.frames[m.frameIndex].GetSelector()
if err != nil {
m.errorMsg = err.Error()
break
}
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
},
)
if err == nil && bytes.Equal(
frameInfo.ClockFrame.Output,
m.frames[m.frameIndex].Output,
) {
m.committed = true
m.frame = frameInfo.ClockFrame
} else {
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
Selector: selector.FillBytes(make([]byte, 32)),
},
)
if err != nil {
m.errorMsg = err.Error()
break
}
m.frame = frameInfo.ClockFrame
}
}
}
case "right", "d":
m.committed = false
m.errorMsg = ""
if m.frameIndex < len(m.frames)-1 {
m.frameIndex++
if len(m.frames) != 0 && m.conn.GetState() == connectivity.Ready {
filter, _ := hex.DecodeString(m.selectedFilter)
selector, err := m.frames[m.frameIndex].GetSelector()
if err != nil {
m.errorMsg = err.Error()
break
}
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
},
)
if err == nil && bytes.Equal(
frameInfo.ClockFrame.Output,
m.frames[m.frameIndex].Output,
) {
m.committed = true
m.frame = frameInfo.ClockFrame
} else {
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
Selector: selector.FillBytes(make([]byte, 32)),
},
)
if err != nil {
m.errorMsg = hex.EncodeToString(
selector.FillBytes(make([]byte, 32)),
) + ":" + err.Error()
break
}
m.frame = frameInfo.ClockFrame
}
} else {
m.errorMsg = "Not currently connected to node, cannot query."
}
} else {
min := uint64(1)
if len(m.frames) != 0 {
min = m.frames[len(m.frames)-1].FrameNumber + 1
}
max := min + 16
filter, _ := hex.DecodeString(m.selectedFilter)
frames, err := m.client.GetFrames(
context.Background(),
&protobufs.GetFramesRequest{
Filter: filter,
FromFrameNumber: min,
ToFrameNumber: max,
IncludeCandidates: true,
},
)
if err != nil {
m.selectedFilter = ""
m.errorMsg = err.Error()
break
}
if frames.TruncatedClockFrames != nil {
m.frames = frames.TruncatedClockFrames
m.frameIndex = 0
selector, err := m.frames[m.frameIndex].GetSelector()
if err != nil {
m.errorMsg = err.Error()
break
}
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
},
)
if err == nil && bytes.Equal(
frameInfo.ClockFrame.Output,
m.frames[m.frameIndex].Output,
) {
m.committed = true
m.frame = frameInfo.ClockFrame
} else {
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
Selector: selector.FillBytes(make([]byte, 32)),
},
)
if err != nil {
m.errorMsg = err.Error()
break
}
m.frame = frameInfo.ClockFrame
}
}
}
case "enter", " ":
m.errorMsg = ""
m.frame = nil
m.committed = false
if m.conn.GetState() == connectivity.Ready {
if m.selectedFilter != m.filters[m.cursor] {
m.selectedFilter = m.filters[m.cursor]
m.frames = []*protobufs.ClockFrame{}
}
min := uint64(1)
if len(m.frames) != 0 {
min = m.frames[len(m.frames)-1].FrameNumber + 1
}
max := min + 16
filter, _ := hex.DecodeString(m.selectedFilter)
frames, err := m.client.GetFrames(
context.Background(),
&protobufs.GetFramesRequest{
Filter: filter,
FromFrameNumber: min,
ToFrameNumber: max,
IncludeCandidates: true,
},
)
if err != nil {
m.selectedFilter = ""
m.errorMsg = err.Error()
break
}
if frames.TruncatedClockFrames != nil {
m.frames = frames.TruncatedClockFrames
m.frameIndex = 0
selector, err := m.frames[m.frameIndex].GetSelector()
if err != nil {
m.errorMsg = err.Error()
break
}
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
},
)
if err == nil && bytes.Equal(
frameInfo.ClockFrame.Output,
m.frames[m.frameIndex].Output,
) {
m.committed = true
m.frame = frameInfo.ClockFrame
} else {
frameInfo, err := m.client.GetFrameInfo(
context.Background(),
&protobufs.GetFrameInfoRequest{
Filter: filter,
FrameNumber: m.frames[m.frameIndex].FrameNumber,
Selector: selector.FillBytes(make([]byte, 32)),
},
)
if err != nil {
m.errorMsg = err.Error()
break
}
m.frame = frameInfo.ClockFrame
}
}
} else {
m.errorMsg = "Not currently connected to node, cannot query."
}
}
}
return m, nil
}
func (m model) View() string {
physicalWidth, physicalHeight, _ := term.GetSize(int(os.Stdout.Fd()))
doc := strings.Builder{}
window := lipgloss.NewStyle().
Border(border, true).
BorderForeground(primaryColor).
Padding(0, 1)
list := []string{}
for i, item := range m.filters {
str := item[0:12] + ".." + item[len(item)-12:]
if m.selectedFilter == item {
list = append(list, selectedListStyle.Render(str))
} else if i == m.cursor {
list = append(list, navigatedListStyle.Render(str))
} else {
list = append(list, unselectedListStyle.Render(str))
}
}
w := lipgloss.Width
statusKey := statusItemStyle.Render("STATUS")
info := statusStyle.Render("(Press Ctrl-C or Q to quit)")
onlineStatus := "gRPC Not Enabled, Please Configure"
if !m.grpcWarn {
switch m.conn.GetState() {
case connectivity.Connecting:
onlineStatus = "CONNECTING"
case connectivity.Idle:
onlineStatus = "IDLE"
case connectivity.Shutdown:
onlineStatus = "SHUTDOWN"
case connectivity.TransientFailure:
onlineStatus = "DISCONNECTED"
default:
onlineStatus = "CONNECTED"
}
}
ownedVal := statusItemStyle.Copy().
Render("Owned: " + m.owned.String())
if m.owned.Cmp(big.NewInt(-1)) == 0 {
ownedVal = statusItemStyle.Copy().
Render("")
}
unconfirmedOwnedVal := statusItemStyle.Copy().
Render("Unconfirmed: " + m.unconfirmedOwned.String())
if m.unconfirmedOwned.Cmp(big.NewInt(-1)) == 0 {
unconfirmedOwnedVal = statusItemStyle.Copy().
Render("")
}
peerIdVal := statusItemStyle.Render(m.peerId)
statusVal := statusBarStyle.Copy().
Width(physicalWidth-w(statusKey)-w(info)-w(peerIdVal)-w(ownedVal)-
w(unconfirmedOwnedVal)).
Padding(0, 1).
Render(onlineStatus)
bar := lipgloss.JoinHorizontal(lipgloss.Top,
statusKey,
statusVal,
info,
peerIdVal,
ownedVal,
unconfirmedOwnedVal,
)
explorerContent := ""
if m.errorMsg != "" {
explorerContent = m.errorMsg
} else if m.frame != nil {
selector, err := m.frame.GetSelector()
if err != nil {
panic(err)
}
committed := "Unconfirmed"
if m.committed {
committed = "Confirmed"
}
explorerContent = fmt.Sprintf(
"Frame %d (Selector: %x, %s):\n\tParent: %x\n\tVDF Proof: %x\n",
m.frame.FrameNumber,
selector.FillBytes(make([]byte, 32)),
committed,
m.frame.ParentSelector,
m.frame.Input[:516],
)
for i := 0; i < len(m.frame.Input[516:])/74; i++ {
commit := m.frame.Input[516+(i*74) : 516+((i+1)*74)]
explorerContent += fmt.Sprintf(
"\tCommitment %+x\n",
commit,
)
explorerContent += fmt.Sprintf(
"\t\tType: %s\n",
m.frame.AggregateProofs[i].InclusionCommitments[0].TypeUrl,
)
switch m.frame.AggregateProofs[i].InclusionCommitments[0].TypeUrl {
case protobufs.IntrinsicExecutionOutputType:
explorerContent += "Application: Ceremony\n"
app, err := application.MaterializeApplicationFromFrame(m.frame)
if err != nil {
explorerContent += "Error: " + err.Error() + "\n"
continue
}
total := new(big.Int)
if app.RewardTrie.Root == nil ||
(app.RewardTrie.Root.External == nil &&
app.RewardTrie.Root.Internal == nil) {
explorerContent += "Total Rewards: 0 QUIL\n"
continue
}
limbs := []*tries.RewardInternalNode{}
if app.RewardTrie.Root.Internal != nil {
limbs = append(limbs, app.RewardTrie.Root.Internal)
} else {
total = total.Add(
total,
new(big.Int).SetUint64(app.RewardTrie.Root.External.Total),
)
}
for len(limbs) != 0 {
nextLimbs := []*tries.RewardInternalNode{}
for _, limb := range limbs {
for _, child := range limb.Child {
child := child
if child.Internal != nil {
nextLimbs = append(nextLimbs, child.Internal)
} else {
total = total.Add(
total,
new(big.Int).SetUint64(child.External.Total),
)
}
}
}
limbs = nextLimbs
}
explorerContent += "Total Rewards: " + total.String() + " QUIL\n"
state := app.LobbyState.String()
explorerContent += "Round State: " + state + "\n"
switch app.LobbyState {
case application.CEREMONY_APPLICATION_STATE_OPEN:
explorerContent += "Joins: \n"
for _, join := range app.LobbyJoins {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
join.PublicKeySignatureEd448.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Preferred Next Round Participants: \n"
for _, next := range app.NextRoundPreferredParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
next.KeyValue,
) + "\n"
}
explorerContent += fmt.Sprintf(
"State Transition Counter: %d\n",
app.StateCount,
)
case application.CEREMONY_APPLICATION_STATE_IN_PROGRESS:
explorerContent += fmt.Sprintf("Sub-Round: %d\n", app.RoundCount)
explorerContent += "Participants: \n"
for _, active := range app.ActiveParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
active.PublicKeySignatureEd448.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Latest Seen: \n"
for _, latest := range app.LatestSeenProverAttestations {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
latest.SeenProverKey.KeyValue,
) + " seen by " + base64.StdEncoding.EncodeToString(
latest.ProverSignature.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Dropped: \n"
for _, dropped := range app.DroppedParticipantAttestations {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
dropped.DroppedProverKey.KeyValue,
) + " confirmed by " + base64.StdEncoding.EncodeToString(
dropped.ProverSignature.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Preferred Next Round Participants: \n"
for _, next := range app.NextRoundPreferredParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
next.KeyValue,
) + "\n"
}
case application.CEREMONY_APPLICATION_STATE_FINALIZING:
explorerContent += fmt.Sprintf(
"Confirmed Shares: %d\n",
len(app.TranscriptShares),
)
explorerContent += "Participants: \n"
for _, active := range app.ActiveParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
active.PublicKeySignatureEd448.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Latest Seen: \n"
for _, latest := range app.LatestSeenProverAttestations {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
latest.SeenProverKey.KeyValue,
) + " seen by " + base64.StdEncoding.EncodeToString(
latest.ProverSignature.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Dropped: \n"
for _, dropped := range app.DroppedParticipantAttestations {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
dropped.DroppedProverKey.KeyValue,
) + " confirmed by " + base64.StdEncoding.EncodeToString(
dropped.ProverSignature.PublicKey.KeyValue,
) + "\n"
}
explorerContent += "Preferred Next Round Participants: \n"
for _, next := range app.NextRoundPreferredParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
next.KeyValue,
) + "\n"
}
case application.CEREMONY_APPLICATION_STATE_VALIDATING:
explorerContent += fmt.Sprintf(
"G1 Powers: %d\n", len(app.UpdatedTranscript.G1Powers),
)
explorerContent += "Preferred Next Round Participants: \n"
for _, next := range app.NextRoundPreferredParticipants {
explorerContent += "\t" + base64.StdEncoding.EncodeToString(
next.KeyValue,
) + "\n"
}
}
}
}
} else {
explorerContent = logoVersion(physicalWidth - 34)
}
doc.WriteString(
lipgloss.JoinVertical(
lipgloss.Left,
lipgloss.JoinHorizontal(
lipgloss.Top,
lipgloss.JoinVertical(
lipgloss.Left,
windowHeader.Render("Filters (Up/Down, Enter)"),
window.Width(30).Height(physicalHeight-4).Render(lipgloss.JoinVertical(lipgloss.Left, list...)),
),
lipgloss.JoinVertical(
lipgloss.Left,
windowHeader.Render("Explorer (Left/Right)"),
window.Width(physicalWidth-34).Height(physicalHeight-4).Render(explorerContent),
),
),
statusBarStyle.Width(physicalWidth).Render(bar),
),
)
if physicalWidth > 0 {
docStyle = docStyle.MaxWidth(physicalWidth)
docStyle = docStyle.MaxHeight(physicalHeight)
}
return docStyle.Render(doc.String())
}
func consoleModel(
conn *grpc.ClientConn,
nodeConfig *config.Config,
grpcWarn bool,
) model {
peerPrivKey, err := hex.DecodeString(nodeConfig.P2P.PeerPrivKey)
if err != nil {
panic(errors.Wrap(err, "error unmarshaling peerkey"))
}
privKey, err := crypto.UnmarshalEd448PrivateKey(peerPrivKey)
if err != nil {
panic(errors.Wrap(err, "error unmarshaling peerkey"))
}
pub := privKey.GetPublic()
id, err := peer.IDFromPublicKey(pub)
if err != nil {
panic(errors.Wrap(err, "error getting peer id"))
}
return model{
filters: []string{
hex.EncodeToString([]byte{
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
}),
hex.EncodeToString(append(
p2p.GetBloomFilter(application.CEREMONY_ADDRESS, 256, 3),
p2p.GetBloomFilterIndices(application.CEREMONY_ADDRESS, 65536, 24)...,
)),
},
cursor: 0,
conn: conn,
client: protobufs.NewNodeServiceClient(conn),
owned: big.NewInt(-1),
unconfirmedOwned: big.NewInt(-1),
peerId: id.String(),
grpcWarn: grpcWarn,
}
}
var defaultGrpcAddress = "localhost:8337"
// Connect to the node via GRPC
func ConnectToNode(nodeConfig *config.Config) (*grpc.ClientConn, error) {
addr := defaultGrpcAddress
if nodeConfig.ListenGRPCMultiaddr != "" {
ma, err := multiaddr.NewMultiaddr(nodeConfig.ListenGRPCMultiaddr)
if err != nil {
panic(err)
}
_, addr, err = mn.DialArgs(ma)
if err != nil {
panic(err)
}
}
return grpc.Dial(
addr,
grpc.WithTransportCredentials(
insecure.NewCredentials(),
),
grpc.WithDefaultCallOptions(
grpc.MaxCallSendMsgSize(600*1024*1024),
grpc.MaxCallRecvMsgSize(600*1024*1024),
),
)
}
type TokenBalance struct {
Owned *big.Int
UnconfirmedOwned *big.Int
}
func FetchTokenBalance(client protobufs.NodeServiceClient) (TokenBalance, error) {
info, err := client.GetTokenInfo(
context.Background(),
&protobufs.GetTokenInfoRequest{},
)
if err != nil {
return TokenBalance{}, errors.Wrap(err, "error getting token info")
}
conversionFactor, _ := new(big.Int).SetString("1DCD65000", 16)
owned := new(big.Int).SetBytes(info.OwnedTokens)
owned.Div(owned, conversionFactor)
unconfirmedOwned := new(big.Int).SetBytes(info.UnconfirmedOwnedTokens)
unconfirmedOwned.Div(unconfirmedOwned, conversionFactor)
return TokenBalance{
Owned: owned,
UnconfirmedOwned: unconfirmedOwned,
}, nil
}
// Runs the DB console
func (c *DBConsole) Run() {
conn, err := ConnectToNode(c.nodeConfig)
if err != nil {
panic(err)
}
defer conn.Close()
grpcWarn := c.nodeConfig.ListenGRPCMultiaddr == ""
p := tea.NewProgram(consoleModel(conn, c.nodeConfig, grpcWarn))
if _, err := p.Run(); err != nil {
panic(err)
}
}
func logoVersion(width int) string {
var out string
if width >= 83 {
out = " %#########\n"
out += " #############################\n"
out += " ########################################&\n"
out += " ###############################################\n"
out += " &#####################% %######################\n"
out += " ################# #################\n"
out += " ############### ###############\n"
out += " ############# ##############\n"
out += " ############# ############&\n"
out += " ############ ############\n"
out += " ########### ########## &###########\n"
out += " ########### ############## ###########\n"
out += " ########### ############## ##########&\n"
out += " ########## ############## ##########\n"
out += "%########## ########## ##########\n"
out += "##########& ##########\n"
out += "########## &#########\n"
out += "##########& ####### ####### ##########\n"
out += " ########## &######################### ##########\n"
out += " ########## ##############% ############## &##########\n"
out += " %########## &############## ############### ##########\n"
out += " ########### ############### ##############% ###########\n"
out += " ###########& ########## ############### ########\n"
out += " ############ ##### ##############% ####\n"
out += " ############ ###############\n"
out += " ############## ##############%\n"
out += " ############### ###############\n"
out += " #################& ##############%\n"
out += " #########################&&&############# ###############\n"
out += " ########################################% ############\n"
out += " ####################################### ########\n"
out += " ############################# ##\n"
out += " \n"
out += " Quilibrium Node - v1.2.11 Dawn\n"
out += " \n"
out += " DB Console\n"
} else {
out = "Quilibrium Node - v1.2.11 Dawn - DB Console\n"
}
return out
}