8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
namespace eval ::nano::key {}
namespace eval ::nano::block {}
namespace eval ::nano::block::json {}
namespace eval ::nano::block::dict {}
namespace eval ::nano::block::create {}
namespace eval ::nano::work {}
namespace eval ::nano::account {}
# Constants
set ::nano::block::stateBlockPreamble [binary decode hex "0000000000000000000000000000000000000000000000000000000000000006"]
set ::nano::address::base32alphabet {13456789abcdefghijkmnopqrstuwxyz}
# Address management functions
proc ::nano::address::toPublicKey {address args} {
|
>
>
>
|
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
namespace eval ::nano::key {}
namespace eval ::nano::block {}
namespace eval ::nano::block::json {}
namespace eval ::nano::block::dict {}
namespace eval ::nano::block::create {}
namespace eval ::nano::work {}
namespace eval ::nano::account {}
namespace eval ::nano::rpc {}
namespace eval ::nano::rpc::client {}
namespace eval ::nano::balance {}
# Constants
set ::nano::block::stateBlockPreamble [binary decode hex "0000000000000000000000000000000000000000000000000000000000000006"]
set ::nano::address::base32alphabet {13456789abcdefghijkmnopqrstuwxyz}
# Address management functions
proc ::nano::address::toPublicKey {address args} {
|
1100
1101
1102
1103
1104
1105
1106
|
set newFrontierHash [dict get [json::json2dict $block] "_blockHash"]
setFrontier $account $newFrontierHash $balance $representative
return $block
}
|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
|
set newFrontierHash [dict get [json::json2dict $block] "_blockHash"]
setFrontier $account $newFrontierHash $balance $representative
return $block
}
# RPC Client
proc ::nano::rpc::client::init args {
dict with args {}
if {![info exists url]} {
set url {http://localhost:7076/}
}
set ::nano::rpc::client::url $url
}
proc ::nano::rpc::client {action args} {
::nano::rpc::client::init
set rpcURL $::nano::rpc::client::url
set jsonArgs [list]
foreach {key value} $args {
switch -exact -- $key {
"-count" {}
"-accounts" {
set valueAsStrings [lmap valueItem $value { json::write string $valueItem }]
set value [json::write array {*}$valueAsStrings]
}
default {
set value [json::write string $value]
}
}
set key [string range $key 1 end]
lappend jsonArgs $key $value
}
set query [json::write object action [json::write string $action] {*}$jsonArgs]
catch {
set token [http::geturl $rpcURL -query $query]
set ncode [http::ncode $token]
set data [http::data $token]
} error
if {![info exists data]} {
set ncode -1
set data $error
}
if {[info exists token]} {
http::cleanup $token
}
if {$ncode ne "200"} {
return -code error "$ncode: $data"
}
set data [json::json2dict $data]
return $data
}
# Account balance manipulation
set ::nano::balance::_conversion {
GNano 1000000000000000000000000000000000000000
MNano 1000000000000000000000000000000000000
Gnano 1000000000000000000000000000000000
Gxrb 1000000000000000000000000000000000
KNano 1000000000000000000000000000000000
Nano 1000000000000000000000000000000
_USER 1000000000000000000000000000000
NANO 1000000000000000000000000000000
Mnano 1000000000000000000000000000000
Mxrb 1000000000000000000000000000000
Mrai 1000000000000000000000000000000
knano 1000000000000000000000000000
kxrb 1000000000000000000000000000
mNano 1000000000000000000000000000
nano 1000000000000000000000000
xrb 1000000000000000000000000
uNano 1000000000000000000000000
mnano 1000000000000000000000
mxrb 1000000000000000000000
unano 1000000000000000000
uxrb 1000000000000000000
Traw 1000000000000
Graw 1000000000
Mraw 1000000
Kraw 1000
raw 1
}
proc ::nano::balance::toUnit {raw toUnit {decimals 0}} {
set divisor [dict get $::nano::balance::_conversion $toUnit]
if {$decimals == 0} {
set balance [expr {entier(($raw / ($divisor * 1.0)) + 0.5)}]
} else {
set balance [expr {$raw / ($divisor * 1.0)}]
set balance [format "%.${decimals}f" $balance]
}
return $balance
}
proc ::nano::balance::toRaw {balance fromUnit} {
set multiplier [dict get $::nano::balance::_conversion $fromUnit]
# Determine how long the multiplier is
set zeros [expr {entier(log10($multiplier))}]
# Find the location of the decimal point (or add it)
set decimal [string first "." $balance]
if {$decimal == -1} {
append balance "."
set decimal [string first "." $balance]
}
# Ensure that the balance has atleast the right number of trailing zeros
append balance [string repeat "0" $zeros]
# Remove the decimal point
set balance [string replace $balance $decimal $decimal]
# Get the subset of the string that corresponds to the balance
set balance [string range $balance 0 [expr {$zeros + $decimal - 1}]]
# Convert to a integer type
set balance [expr {entier($balance)}]
return $balance
}
proc ::nano::balance::normalizeUnitName {unit} {
set multiplier [dict get $::nano::balance::_conversion $unit]
foreach {unitName multiplierCheck} $::nano::balance::_conversion {
if {$multiplierCheck == $multiplier} {
return $unitName
}
}
}
proc ::nano::balance::toHuman {raw {decimals 3}} {
set humanUnit [normalizeUnitName _USER]
set humanUnitMultiplier [dict get $::nano::balance::_conversion $humanUnit]
if {$raw > [expr {$humanUnitMultiplier / 10000000}]} {
set balance [toUnit $raw $humanUnit 7]
set baseUnit $humanUnit
set balance [expr {entier($balance * 1000000)}]
set labels {u m "" K M G T}
} else {
set balance $raw
set baseUnit "raw"
set labels {"" K M G T}
}
set labelIdx -1
foreach label $labels {
incr $labelIdx
if {$balance < 1000} {
break
}
set balance [expr {$balance / 1000}]
}
set unit "${label}${baseUnit}"
set unit [normalizeUnitName $unit]
set balance [toUnit $raw $unit $decimals]
set balance [string trimright $balance "0."]
set result [list $balance $unit]
return $result
}
|