drakogangcom / --name-okteto-push-uses-okteto-push-1.14.5 Goto Github PK

"ABCDE1234ABCDE1234ABCDE1234" //This API key is provided by Cards

$$https://$user-images.$githubusercontent.com/$97154178/$150048100-6e0fa08f-0112-4933-aef8-786e92f45284.$mp4https://$user-images.$githubusercontent.com/$97154178/150048419-e8c71cda-db08-4478-baf3-f910c72c9a5b.$mp4<!-)- $Error while uploading" $IMG_20220108_091454_066_proxy.dng -->////:*$https://user-images.githubusercontent.com/97154178/150049106-12e2625b-ef24-493a-83e3-a77589909be5.mp4*$!$[modelop_logo_color.png]($https://$user-images.githubusercontent.com/$97154178/$150049368-fc2c2d83-5dad-4f4d-b979-8733e5c0a4cc.png)("$Drakogangcom)$@Drakogangcom $!$[IMG_20220107_191321_566.jpg]$(https://$user-images.$githubusercontent.com/$97154178/$150049626-55a92046-446b-43e9-a7b4-5b0ba9e65cdc.jpg)https://user-images.githubusercontent.com/97154178/150049762-eb69d73c-9f4e-47c0-b0d8-5fd6bde14608.mp4)

Use one of the best PDF Reader. Download free now!
http://bit.ly/PDFReader_alldocumentreader

https://github.com/productinfo/website-2/blob/master/LICENSE

deroproject/astrobwt#5:
​// +build !amd64

​package​ cryptonight

​func​ ​encrypt10AESRound​(​ ​​uint32​, ​​uint32​) {

​
​func​ (​chain​ ​*​Blockchain​) ​SortTips​(​dbtx​ storage.​DBTX​, ​tips​ []crypto.​Hash​) (​sorted​ []crypto.​Hash​) {https://support.google.com/business/=139394664https://support.google.com/business/thread/143371012/how-to-sign-up-for-ads-in-google-my-business?hl=en&msgid=143434120/Rejecting !! Block has invalid reachability"​)
​                ​return​ ​errormsg​.​ErrInvalidBlock​, ​false

​        }

​        ​// if the block is referencing any past tip too distant into main chain discard now
​        ​// TODO FIXME this need to computed
​        ​for​ ​i​ ​:=​ ​range​ ​bl​.​Tips​ {
​                ​rusty_tip_base_distance​ ​:=​ ​chain​.​calculate_mainchain_distance​(​dbtx​, ​bl​.​Tips​[​i​])

​                ​// tips of deviation >= 8 will rejected
​                ​if​ (​int64​(​chain​.​Get_Height​()) ​-​ ​rusty_tip_base_distance​) ​>=​ ​config​.​STABLE_LIMIT​ {
​                        ​block_logger​.​Warnf​(​"Rusty TIP  mined by ROGUE miner discarding block %s  best height %d deviation %d rusty_tip %d"​, ​bl​.​Tips​[​i​], ​chain​.​Get_Height​(), (​int64​(​chain​.​Get_Height​()) ​-​ ​rusty_tip_base_distance​), ​rusty_tip_base_distance​)
​                        ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​                }
​        }

​        ​// verify difficulty of tips provided
​        ​if​ ​len​(​bl​.​Tips​) ​>​ ​1​ {
​                ​best_tip​ ​:=​ ​chain​.​find_best_tip_cumulative_difficulty​(​dbtx​, ​bl​.​Tips​)
​                ​for​ ​i​ ​:=​ ​range​ ​bl​.​Tips​ {
​                        ​if​ ​best_tip​ ​!=​ ​bl​.​Tips​[​i​] {
​                                ​if​ ​!​chain​.​validate_tips​(​dbtx​, ​best_tip​, ​bl​.​Tips​[​i​]) { ​// reference is first
​                                        ​block_logger(​"Rusty tip mined by ROGUE miner, discarding block"​)
​                                        ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​                                }
​                        }
​                }
​        }

​        ​// check whether the block crosses the size limit
​        ​// block size is calculate by adding all the txs
​        ​// block header/miner tx is excluded, only tx size if calculated
​        {
​                ​block_size​ ​:=​ ​0
​                ​for​ ​i​ ​:=​ ​0​; ​i​ ​<​ ​len​(​cbl​.​Txs​); ​i​++​ {
​                        ​block_size​ ​+=​ ​len​(​cbl​.​Txs​[​i​].​Serialize​())
​                        ​if​ ​uint64​(​block_size​) ​>=​ ​config​.​CRYPTONOTE_MAX_BLOCK_SIZE​ {
​                                ​block_logger​.​Warnf​(​"Block is bigger than max permitted, Rejecting it Actual %d MAX %d "​, ​block_size​, ​config​.​CRYPTONOTE_MAX_BLOCK_SIZE​)
​                                ​return​ ​errormsg​.​ErrInvalidSize​, ​false
​                        }
​                }
​        }

​        ​//logger.Infof("pow hash %s height %d", bl.GetPoWHash(), block_height)

​        ​// Verify Blocks Proof-Of-Work
​        ​// check if the PoW is satisfied
​        ​if​ ​!​chain​.​VerifyPoW​(​dbtx​, ​bl​) { ​// if invalid Pow, reject the bloc
​                ​block_logger​.​Warnf​(​"Block has invalid PoW, rejecting it %x"​, ​bl​.​Serialize​())
​                ​return​ ​errormsg​.​ErrInvalidPoW​, ​false
​        }
​// of main chain, but there transactions are honoured,
​// they are given 67 % reward
​// a block is a side block if it satisfies the following condition
​// if  block height   is less than or equal to height of past 8 topographical blocks
​// this is part of consensus rule
​// this is the topoheight of this block itself
​func​ (​chain​ ​*​Blockchain​) ​isblock_SideBlock​(​dbtx​ storage.​DBTX​, ​blid​ crypto.​Hash​, ​block_topoheight​ ​int64​) (​result​ ​bool​) {

​        ​if​ ​block_topoheight​ ​<=​ ​2​ {
​                ​return​ ​
​        ​// for as many block as added
​        ​block_height​ ​:=​ ​chain​.​Load_Height_for_BL_ID​(​dbtx​, ​blid​)

​        ​counter​ ​:=​ ​int64​(​0​)
​        ​for​ ​i​ ​:=​ ​block_topoheight​ ​-​ ​1​; ​i​ ​>=​ ​0​ ​&&​ ​counter​ ​<​ ​config​.​STABLE_LIMIT​; ​i​--​ {
​                ​counter​++

​                ​previous_blid​, ​err​ ​:=​ ​chain​.​Load_Block_Topological_order_at_index​(​dbtx​, ​i​)
​                ​if​ ​err​ ​!=​ ​nil​ {
​                        ​panic​(​"Could not load block from previous order"​)
​                }
​                ​// height of previous topo ordered block
​                ​previous_height​ ​:=​ ​chain​.​Load_Height_for_BL_ID​(​dbtx​, ​previous_blid​)

​                ​if​ ​block_height​ ​<=​ ​previous_height​ { ​// lost race (or byzantine behaviour)
​                        ​return​ ​true​ ​// give only 67 % rrewar/ ​// this is the only entrypoint for new / old blocks even for genesis block
​// this will add the entire block atomically to the chain
​// this is the only function which can add blocks to the chain
​// this is exported, so ii can be fed new blocks by p2p layer
​// genesis block is no different
​// TODO: we should stop mining while adding the new block
​func​ (​chain​ ​​Blockchain​) ​Add_Complete_Block​(​cbl​ ​​block.​Complete_Block​) (​err​ ​error​, ​result​ ​bool​) {

​        ​var​ ​block_hash​ crypto.​Hash
​        ​chain​.​Lock​()
​        ​defer​ ​chain​.​Unlock​()
​        ​result​ ​=​ ​false

​        ​dbtx​, ​err​ ​:=​ ​chain​.​store​.​BeginTX​(​true​)
​        ​if​ ​err​ ​!=​ ​nil​ {
​                ​logger​.​Warnf​(​"Could NOT add block to chain. Error opening writable TX, err %s"​, ​err​)
​                ​return​ ​errormsg​.​ErrInvalidStorageTX​, ​false
​        }

​        ​chain​.​MINING_BLOCK​ ​=​ ​true

​        ​processing_start​ ​:=​ ​time​.​Now​()

​        ​//old_top := chain.Load_TOP_ID() // store top as it may change
​        ​defer​ ​func​() {

​                ​// safety so if anything wrong happens, verification fails
​                ​if​ ​r​ ​:=​ ​recover​(); ​r​ ​!=​ ​nil​ {
​                        ​logger​.​Warnf​(​"Recovered while adding new block, Stack trace below block_hash %s"​, ​block_hash​)
​                        ​logger​.​Warnf​(​"Stack trace  ​\n​%s"​, ​debug​.​Stack​())
​                        ​result​ ​=​ ​false
​                        ​err​ ​=​ ​errormsg​.​ErrPanic
​                }

​                ​chain​.​MINING_BLOCK​ ​=​ ​false

​                ​if​ ​result​ ​==​ ​true​ { ​// block was successfully added, commit it atomically
​                        ​dbtx​.​Commit​()

​                        ​rlog​.​Infof​(​"Block successfully acceppted by chain %s"​, ​block_hash​)

​                        ​// gracefully try to instrument
​                        ​func​() {
​                                ​defer​ ​func​() {
​                                        ​if​ ​r​ ​:=​ ​recover​(); ​r​ ​!=​ ​nil​ {
​                                                ​rlog​.​Warnf​(​"Recovered while instrumenting"​)
​                                                ​rlog​.​Warnf​(​"Stack trace ​\n​%s"​, ​debug​.​Stack​())

​                                        }
​                                }()
​                                ​blockchain_tx_counter​.​Add​(​float64​(​len​(​cbl​.​Bl​.​Tx_hashes​)))
​                                ​block_tx_count​.​Observe​(​float64​(​len​(​cbl​.​Bl​.​Tx_hashes​)))
​                                ​block_processing_time​.​Observe​(​float64​(​time​.​Now​().​Sub​(​processing_start​).​Round​(​time​.​Millisecond​) ​/​ ​1000000​))

​                                ​// tracks counters for tx_size

​                                {
​                                        ​complete_block_size​ ​:=​ ​0
​                                        ​for​ ​i​ ​:=​ ​0​; ​i​ ​<​ ​len​(​cbl​.​Txs​); ​i​++​ {
​                                                ​tx_size​ ​:=​ ​len​(​cbl​.​Txs​[​i​].​Serialize​())
​                                                ​complete_block_size​ ​+=​ ​tx_size
​                                                ​transaction_size​.​Observe​(​float64​(​tx_size​))
​                                        }
​                                        ​block_size​.​Observe​(​float64​(​complete_block_size​))
​                                }
​                        }()

​                        ​//dbtx.Sync() // sync the DB to disk after every execution of this function

​                        ​//if old_top != chain.Load_TOP_ID() { // if top has changed, discard mining templates and start afresh
​                        ​// TODO discard mining templates or something else, if top chnages requires some action

​                        ​//}
​                } ​else​ {
​                        ​dbtx​.​Rollback​() ​// if block could not be added, rollback all changes to previous block
​                        ​rlog​.​Infof​(​"Block rejected by chain %s err %s"​, ​block_hash​, ​err​)
​                }
​        }()

​        ​bl​ ​:=​ ​cbl​.​Bl​ ​// small pointer to block

​        ​// first of all lets do some quick checks
​        ​// before doing extensive checks
​        ​result​ ​=​ ​false

​        ​block_hash​ ​=​ ​bl​.​GetHash​()
​        ​block_logger​ ​:=​ ​logger​.​WithFields​(log.​Fields​{​"blid"​: ​block_hash​})

​        ​// check if block already exist skip it
​        ​if​ ​chain​.​Block_Exists​(​dbtx​, ​block_hash​) {
​                ​block_logger​.​Debugf​(​"block already in chain skipping it "​)
​                ​return​ ​errormsg​.​ErrAlreadyExists​, ​false
​        }

​        ​// only 3 tips allowed in block
​        ​if​ ​len​(​bl​.​Tips​) ​>=​ ​4​ {
​                ​rlog​.​Warnf​(​"More than 3 tips present in block %s rejecting"​, ​block_hash​)
​                ​return​ ​errormsg​.​ErrPastMissing​, ​false
​        }

​        ​// check whether the tips exist in our chain, if not reject
​        ​if​ ​chain​.​Get_Height​() ​>​ ​0​ {
​                ​for​ ​i​ ​:=​ ​range​ ​bl​.​Tips​ {
​                        ​if​ ​!​chain​.​Block_Exists​(​dbtx​, ​bl​.​Tips​[​i​]) {
​                                ​rlog​.​Warnf​(​"Tip  %s  is NOT present in chain current block %s, skipping it till we get a parent"​, ​bl​.​Tips​[​i​], ​block_hash​)
​                                ​return​ ​errormsg​.​ErrPastMissing​, ​false
​                        }
​                }
​        }

​        

​        ​block_height​ ​:=​ ​chain​.​Calculate_Height_At_Tips​(​dbtx​, ​bl​.​Tips​)

​        ​if​ ​block_height​ ​==​ ​0​ ​&&​ ​bl​.​GetHash​() ​!=​ ​globals​.​Config​.​Genesis_Block_Hash​ {
​                ​block_logger​.​Warnf​(​"There can can be only one genesis block, reject it, len of tips(%d)"​, ​len​(​bl​.​Tips​))
​                ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​        }
​        ​if​ ​block_height​ ​<​ ​chain​.​Get_Stable_Height​() {
​                ​rlog​.​Warnf​(​"Block %s rejected since it is stale stable height %d  block height %d"​, ​bl​.​GetHash​(), ​chain​.​Get_Stable_Height​(), ​block_height​)
​                ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​        }

​        ​// use checksum to quick jump
​        ​if​ ​chain​.​checkpints_disabled​ ​==​ ​false​ ​&&​ ​checkpoints​.​IsCheckSumKnown​(​chain​.​BlockCheckSum​(​cbl​)) {
​                ​rlog​.​Debugf​(​"Skipping Deep Checks for block %s "​, ​block_hash​)
​                ​goto​ skip_checks
​        } ​else​ {
​                ​rlog​.​Debugf​(​"Deep Checks for block %s "​, ​block_hash​)
​        }

​        ​// version 1 blocks ( old chain) should NOT be mined by used
​        ​// they should use hard coded checkpoints
​        ​if​ ​chain​.​checkpints_disabled​ ​==​ ​false​ ​&&​ ​chain​.​Get_Current_Version_at_Height​(​block_height​) ​==​ ​1​ {
​                ​logger​.​Warnf​(​"v1 blocks cannot be mined (these are imported blocks), rejecting"​)
​                ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​        }

​        ​/*

​                // check  a small list 100 hashes whether they have been reached
​                if IsCheckPointKnown_Static(block_hash, chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1) {
​                        logger.Infof("Static Checkpoint reached at height %d", chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1)
​                }

​                rlog.Tracef(1, "Checking Known checkpoint %s at height %d", block_hash, chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1)

​                //if we have checkpoints embedded, they must match
​                // until user disables this check
​                // skip checkpoint check for genesis block
​                if block_hash != globals.Config.Genesis_Block_Hash {
​                        if chain.checkpints_disabled == false && checkpoints.Length() > chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1 && !checkpoints.IsCheckPointKnown(block_hash, chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1) {
​                                block_logger.Warnf("Block hash mismatch with checkpoint height %d", chain.Load_Height_for_BL_ID(bl.Prev_Hash)+1)
​                                retirement
​        ​// make sure time is NOT too much into future, we have 2 seconds of margin here
​        ​// some OS have trouble syncing with more than 1 sec granularity
​        ​// if clock diff is more than   2 secs, reject the block
​        ​if​ ​bl​.​Timestamp​ ​>​ (​uint64​(​time​.​Now​().​UTC​().​Unix​()) ​+​ ​config​.​CRYPTONOTE_FUTURE_TIME_LIMIT​) {
​                ​block_logger​.​Warnf​(​"Rejecting Block, timestamp is too much into future, make sure that system clock is correct"​)
​                ​return​ ​errormsg​.​ErrFutureTimestamp​, ​false
​        }

​        ​// verify that the clock is not being run in reverse
​        ​// the block timestamp cannot be less than any of the parents
​        ​for​ ​i​ ​:=​ ​range​ ​bl​.​Tips​ {
​                ​if​ ​uint64​(​chain​.​Load_Block_Timestamp​(​dbtx​, ​bl​.​Tips​[​i​])) ​>​ ​bl​.​Timestamp​ {
​                        ​block_logger​.​Warnf​(​"Block timestamp is  less than its parent, rejecting block"​)
​                        ​return​ ​errormsg​.​ErrInvalidTimestamp​, ​false
​                }
​        }

​        ​//logger.Infof("current version %d  height %d", chain.Get_Current_Version_at_Height( 2500), chain.Calculate_Height_At_Tips(dbtx, bl.Tips))
​        ​// check whether the major version ( hard fork) is valid
​        ​if​ ​!​chain​.​Check_Block_Version​(​dbtx​, ​bl​) {
​                ​block_logger​.​Warnf​(​"Rejecting !! Block has invalid fork version actual %d expected %d"​, ​bl​.​Major_Version​, ​chain​.​Get_Current_Version_at_Height​(​chain​.​Calculate_Height_At_Tips​(​dbtx​, ​bl​.​Tips​)))
​                ​return​ ​errormsg​.​ErrInvalidBlock​, ​false
​        }

​        ​// verify whether the tips are unreachable from one another
​        ​if​ ​!​chain​.​VerifyNonReachability​(​dbtx​, ​bl​) {
​                ​block_logger​.​Warnf​(​"

​        ​// verify coinbase tx
​        ​if​ ​!​chain​.​Verify_Transaction_Coinbase​(​dbtx​, ​cbl​, ​&​bl​.​Miner_TX​) {
​                ​block_logger​.​(​"Miner tx failed verification  rejecting "​)➿#️⃣520

__________________________________$

• #710/<!-- - [ ] Error while - [ ] - [ ] uploading/https://user-images- - [ ] [ ] .githubusercontent.com/97154178/150042781-faeb1a7a-ace3-4f76-bc82- [ ] -1fd2a680e455.mp4https://user-images- .githubusercontent.com/97154178/150043290-dcaec042-b8dd-491d-a30a-c0066d259502.mp4)/"💲Drake - [ ] bourque"(<@Drakogangcom)+(- [ ] #910)///#29)https://user-images- [ ] .githubusercontent.com/97154178- [ ] /150043878-c59cbe29-a37c-48db-bc80-6- [ ] bb57a862a31.mp4)/)(+ (a9f1bba1fe411bf7a0b22651d1a58639.mp4 -->()+))//- [ ] !- [ ] [g1.png](https://user-images- [ ] .githubusercontent.com/97154178/150044384-311339bd-4127- [ ] -4686-9804-e5d216df7599.png)$@Drakogangcom ))////(####710+###12+###38)(//(@drake+@Drakogangcom+@👻- [ ] man(//(-/(@jcole)-/))©©drake - [ ] bourque"➿➿➰➿➿➰┻┻︵ヽ(Д´)ﾉ- - [ ] [ ] ︵┻┻┻┻︵ヽ(Д´)ﾉ︵┻┻ಠ ͜ʖ) (ಠಠ)(/- [ ] +ಗಠ/- [] (ಠ︵ಠ)!#420)))////(Mind cramps)Use the edit icon to pin, add or delete - [ ] clips+https://user-images.githubuser- [ ] content.com/97154178/150046154- [ ] -b82a3751-a010-4f57-96d7-7a11ae1d1d40.mp4+![3067_2- [ ] .jpeg](https://user-images- [ ] .githubusercontent.com/97154178- [ ] /150046191-a4d52e9b-6d9c-4918-9a7b- [ ] -cbd98d58f0fb.jpeg)
  Attribution 4.0 International)(//$+![Screenshot_20220113-103844.png](https://user-images.githubusercontent.com/"97154178"/"150046447"-"5e7026b"d-"ac87"-"4254"-"888b"-"963a9408bfb4"_##90- #-70 - - - - - - - - - -66 - - - - - - - - - - - - - - (/(**$$¯_ಠ_ಠ_/¯̲̅$̲̅(̲̅ ͡ಠ_ಠ)̲̅$̲̅/$(ಠ_ಠ)━☆ﾟ.･｡ﾟ(༎ຶ ෴ ༎ຶ)༼;´༎ຶ ۝ ༎ຶ༽(ʘ言ʘ╬)☜ (↼_↼)ԅ( ͒ ۝ ͒ )ᕤԅ( ͒ ۝ ͒ )ᕤԅ)((//($deake+bourque)+ ()( ͒ ۝ ͒ )ᕤԅ )(##1!)IMG_20220110_142936_429.jpg(~~~~~~~~~~~~~~~~~~~~.png)

https://github.com/sausman/derosuite/blob/master/checkpoints/testnet_checksums.dat#L1-L148

​package=​$1
​package_split=(​${package​//​/​/​ }​)
​package_name=​${package_split[-1]}

​CURDIR=​​/bin/pwd​
​BASEDIR=​$(​dirname ​$0​)
​ABSPATH=​$(​readlink -f ​$0​)
​ABSDIR=​$(​dirname ​$ABSPATH​)

​PLATFORMS=​"​darwin/amd64​"​ ​#​ amd64 only as of go1.5
​PLATFORMS=​"​$PLATFORMS​ windows/amd64 windows/386​"​ ​#​ arm compilation not available for Windows
​PLATFORMS=​"​$PLATFORMS​ linux/amd64 linux/386​"
​#​PLATFORMS="$PLATFORMS linux/ppc64le"   is it common enough ??
​#​PLATFORMS="$PLATFORMS linux/mips64le" # experimental in go1.6 is it common enough ??
​PLATFORMS=​"​$PLATFORMS​ freebsd/amd64 freebsd/386​"
​PLATFORMS=​"​$PLATFORMS​ netbsd/amd64​"​ ​#​ amd64 only as of go1.6
​#​PLATFORMS="$PLATFORMS openbsd/amd64" # amd64 only as of go1.6
​PLATFORMS=​"​$PLATFORMS​ dragonfly/amd64​"​ ​#​ amd64 only as of go1.5
​#​PLATFORMS="$PLATFORMS plan9/amd64 plan9/386" # as of go1.4, is it common enough ??
​#​ solaris disabled due to badger  error below
​#​vendor/github.com/dgraph-io/badger/y/mmap_unix.go:57:30: undefined: syscall.SYS_MADVISE
​#​PLATFORMS="$PLATFORMS solaris/amd64" # as of go1.3

​#​PLATFORMS_ARM="linux freebsd netbsd"
​PLATFORMS_ARM=​"​linux freebsd​"

​type​ setopt ​>​/dev/null ​2>&1

​SCRIPT_NAME=​​basename ​"​$0​"​
​FAILURES=​"​"
​CURRENT_DIRECTORY=​${PWD​##*/​}
​OUTPUT=​"​$package_name​"​ ​#​ if no src file given, use current dir name

​GCFLAGS=​"​"
​if​ [[ ​"​${OUTPUT}​"​ ​==​ ​"​dero-miner​"​ ]]​;​ ​then​ GCFLAGS=​"​github.com/deroproject/derosuite/astrobwt=-B​"​;​ ​fi

​for​ ​PLATFORM​ ​in​ ​$PLATFORMS​;​ ​do
​  GOOS=​${PLATFORM​%/​}
​  GOARCH=​${PLATFORM​#/​}
​  OUTPUT_DIR=​"​${ABSDIR}​/build/dero_​${GOOS}​_​${GOARCH}​"
​  BIN_FILENAME=​"​${OUTPUT}​-​${GOOS}​-​${GOARCH}​"
​  ​echo​  mkdir -p ​$OUTPUT_DIR
​  ​if​ [[ ​"​${GOOS}​"​ ​==​ ​"​windows​"​ ]]​;​ ​then​ BIN_FILENAME=​"​${BIN_FILENAME}​.exe​"​;​ ​fi
​  CMD=​"​GOOS=​${GOOS}​ GOARCH=​${GOARCH}​ go build -gcflags=​${GCFLAGS}​ -o ​$OUTPUT_DIR​/​${BIN_FILENAME}​ ​$package​"
​  ​echo​ ​"​${CMD}​"
​  ​eval​ ​$CMD​ ​||​ FAILURES=​"​${FAILURES}​ ​${PLATFORM}​"

​  ​#​ build docker image for linux amd64 competely static  
​  ​if​ [[ ​"​${GOOS}​"​ ​==​ ​"​linux​"​ ​&&​ ​"​${GOARCH}​"​ ​==​ ​"​amd64​"​ ​&&​ ​"​${OUTPUT}​"​ ​!=​ ​"​explorer​"​ ​&&​ ​"​${OUTPUT}​"​ ​!=​ ​"​dero-miner​"​ ]] ​;​ ​then
​    BIN_FILENAME=​"​docker-​${OUTPUT}​-​${GOOS}​-​${GOARCH}​"
​    CMD=​"​GOOS=​${GOOS}​ GOARCH=​${GOARCH}​ CGO_ENABLED=0 go build -o ​$OUTPUT_DIR​/​${BIN_FILENAME}​ ​$package​"
​    ​echo​ ​"​${CMD}​"
​    ​eval​ ​$CMD​ ​||​ FAILURES=​"​${FAILURES}​ ​${PLATFORM}​"
​  ​fi
​  

​done

​#​ ARM64 builds only for linux
​if​ [[ ​$PLATFORMS_ARM​ ​==​ ​​"​linux​"​​ ]]​;​ ​then​ 
​  GOOS=​"​linux​"
​  GOARCH=​"​arm64​"
​  OUTPUT_DIR=​"​${ABSDIR}​/build/dero_​${GOOS}​_​${GOARCH}​"
​  CMD=​"​GOOS=linux GOARCH=arm64 go build -gcflags=​${GCFLAGS}​ -o ​$OUTPUT_DIR​/​${OUTPUT}​-linux-arm64 ​$package​"
​  ​echo​ ​"​${CMD}​"
​  ​eval​ ​$CMD​ ​||​ FAILURES=​"​${FAILURES}​ ​${PLATFORM}​"
​fi

​for​ ​GOOS​ ​in​ ​$PLATFORMS_ARM​;​ ​do
​  GOARCH=​"​arm​"
​  ​#​ build for each ARM version
​  ​for​ ​GOARM​ ​in​ 7 6 5​;​ ​do
​    OUTPUT_DIR=​"​${ABSDIR}​/build/dero_​${GOOS}​_​${GOARCH}${GOARM}​"
​    BIN_FILENAME=​"​${OUTPUT}​-​${GOOS}​-​${GOARCH}${GOARM}​"
​    CMD=​"​GOARM=​${GOARM}​ GOOS=​${GOOS}​ GOARCH=​${GOARCH}​ go build -gcflags=​${GCFLAGS}​ -o ​$OUTPUT_DIR​/​${BIN_FILENAME}​ ​$package​"
​    ​echo​ ​"​${CMD}​"
​    ​eval​ ​"​${CMD}​"​ ​||​ FAILURES=​"​${FAILURES}​ ​${GOOS}​/​${GOARCH}${GOARM}​"​ 
​  ​done
​done

​#​ eval errors
​if​ [[ ​"​${FAILURES}​"​ ​!=​ ​"​"​ ]]​;​ ​then
​  ​echo​ ​"​"
​  ​echo​ ​"​${SCRIPT_NAME}​ failed on: ​${FAILURES}​"
​  ​exit​ 1
​fi