From 14b2d4324d6564faa29490877c6fd1f9ae27ae41 Mon Sep 17 00:00:00 2001 From: Zahary Karadjov Date: Wed, 28 Oct 2020 20:35:31 +0200 Subject: [PATCH] openarray -> openArray --- beacon_chain/beacon_chain_db.nim | 4 +-- beacon_chain/beacon_node_common.nim | 2 +- beacon_chain/eth2_discovery.nim | 2 +- beacon_chain/fork_choice/fork_choice.nim | 12 ++++----- beacon_chain/fork_choice/proto_array.nim | 2 +- beacon_chain/merkle_minimal.nim | 4 +-- beacon_chain/peer_pool.nim | 2 +- beacon_chain/spec/beaconstate.nim | 2 +- beacon_chain/spec/helpers.nim | 2 +- beacon_chain/spec/keystore.nim | 26 +++++++++---------- beacon_chain/spec/network.nim | 2 +- beacon_chain/ssz/bitseqs.nim | 10 +++---- beacon_chain/ssz/bytes_reader.nim | 24 ++++++++--------- beacon_chain/ssz/dynamic_navigator.nim | 4 +-- beacon_chain/ssz/merkleization.nim | 20 +++++++------- beacon_chain/ssz/navigator.nim | 2 +- beacon_chain/ssz/ssz_serialization.nim | 2 +- beacon_chain/sync_manager.nim | 6 ++--- .../validator_slashing_protection.nim | 4 +-- benchmarks/bench_bls_sig_agggregation.nim | 4 +-- docker/manage_testnet_hosts.nims | 2 +- .../src/02.1.4_closure_iterators.md | 2 +- tests/mocking/mock_validator_keys.nim | 6 ++--- tests/official/fixtures_utils.nim | 2 +- .../justification_finalization_helpers.nim | 2 +- tests/test_ssz_merkleization.nim | 6 ++--- 26 files changed, 78 insertions(+), 78 deletions(-) diff --git a/beacon_chain/beacon_chain_db.nim b/beacon_chain/beacon_chain_db.nim index 90e414859..0094ac9c2 100644 --- a/beacon_chain/beacon_chain_db.nim +++ b/beacon_chain/beacon_chain_db.nim @@ -11,7 +11,7 @@ import type DbSeq*[T] = object - insertStmt: SqliteStmt[openarray[byte], void] + insertStmt: SqliteStmt[openArray[byte], void] selectStmt: SqliteStmt[int64, seq[byte]] recordCount: int64 @@ -132,7 +132,7 @@ proc init*[T](Seq: type DbSeq[T], db: SqStoreRef, name: string): Seq = let insertStmt = db.prepareStmt( "INSERT INTO " & name & "(value) VALUES (?);", - openarray[byte], void).expect("this is a valid statement") + openArray[byte], void).expect("this is a valid statement") selectStmt = db.prepareStmt( "SELECT value FROM " & name & " WHERE id = ?;", diff --git a/beacon_chain/beacon_node_common.nim b/beacon_chain/beacon_node_common.nim index 987d29f79..c13cf21b1 100644 --- a/beacon_chain/beacon_node_common.nim +++ b/beacon_chain/beacon_node_common.nim @@ -61,7 +61,7 @@ const MaxEmptySlotCount* = uint64(10*60) div SECONDS_PER_SLOT # TODO stew/sequtils2 -template findIt*(s: openarray, predicate: untyped): int = +template findIt*(s: openArray, predicate: untyped): int = var res = -1 for i, it {.inject.} in s: if predicate: diff --git a/beacon_chain/eth2_discovery.nim b/beacon_chain/eth2_discovery.nim index 0f06b604d..9c65f956c 100644 --- a/beacon_chain/eth2_discovery.nim +++ b/beacon_chain/eth2_discovery.nim @@ -86,7 +86,7 @@ proc new*(T: type Eth2DiscoveryProtocol, conf: BeaconNodeConf, ip: Option[ValidIpAddress], tcpPort, udpPort: Port, pk: PrivateKey, - enrFields: openarray[(string, seq[byte])], rng: ref BrHmacDrbgContext): + enrFields: openArray[(string, seq[byte])], rng: ref BrHmacDrbgContext): T {.raises: [Exception, Defect].} = # TODO # Implement more configuration options: diff --git a/beacon_chain/fork_choice/fork_choice.nim b/beacon_chain/fork_choice/fork_choice.nim index 2b6fe8592..d10585d95 100644 --- a/beacon_chain/fork_choice/fork_choice.nim +++ b/beacon_chain/fork_choice/fork_choice.nim @@ -33,12 +33,12 @@ export proto_array.len # ---------------------------------------------------------------------- func compute_deltas( - deltas: var openarray[Delta], + deltas: var openArray[Delta], indices: Table[Eth2Digest, Index], indices_offset: Index, votes: var openArray[VoteTracker], - old_balances: openarray[Gwei], - new_balances: openarray[Gwei] + old_balances: openArray[Gwei], + new_balances: openArray[Gwei] ): FcResult[void] # TODO: raises [Defect] - once https://github.com/nim-lang/Nim/issues/12862 is fixed # https://github.com/status-im/nimbus-eth2/pull/865#pullrequestreview-389117232 @@ -377,12 +377,12 @@ func prune*(self: var ForkChoice): FcResult[void] = self.backend.prune(self.checkpoints.finalized.root) func compute_deltas( - deltas: var openarray[Delta], + deltas: var openArray[Delta], indices: Table[Eth2Digest, Index], indices_offset: Index, votes: var openArray[VoteTracker], - old_balances: openarray[Gwei], - new_balances: openarray[Gwei] + old_balances: openArray[Gwei], + new_balances: openArray[Gwei] ): FcResult[void] = ## Update `deltas` ## between old and new balances diff --git a/beacon_chain/fork_choice/proto_array.nim b/beacon_chain/fork_choice/proto_array.nim index f58b062dd..5c198d865 100644 --- a/beacon_chain/fork_choice/proto_array.nim +++ b/beacon_chain/fork_choice/proto_array.nim @@ -104,7 +104,7 @@ func init*(T: type ProtoArray, func apply_score_changes*( self: var ProtoArray, - deltas: var openarray[Delta], + deltas: var openArray[Delta], justified_epoch: Epoch, finalized_epoch: Epoch ): FcResult[void] = diff --git a/beacon_chain/merkle_minimal.nim b/beacon_chain/merkle_minimal.nim index f40553060..a846d34d7 100644 --- a/beacon_chain/merkle_minimal.nim +++ b/beacon_chain/merkle_minimal.nim @@ -23,7 +23,7 @@ import const depositContractLimit* = Limit(1'u64 shl (DEPOSIT_CONTRACT_TREE_DEPTH - 1'u64)) -func attachMerkleProofs*(deposits: var openarray[Deposit]) = +func attachMerkleProofs*(deposits: var openArray[Deposit]) = let depositsRoots = mapIt(deposits, hash_tree_root(it.data)) var incrementalMerkleProofs = createMerkleizer(depositContractLimit) @@ -32,7 +32,7 @@ func attachMerkleProofs*(deposits: var openarray[Deposit]) = incrementalMerkleProofs.addChunkAndGenMerkleProof(depositsRoots[i], deposits[i].proof) deposits[i].proof[32].data[0..7] = toBytesLE uint64(i + 1) -template getProof*(proofs: seq[Eth2Digest], idxParam: int): openarray[Eth2Digest] = +template getProof*(proofs: seq[Eth2Digest], idxParam: int): openArray[Eth2Digest] = let idx = idxParam startIdx = idx * DEPOSIT_CONTRACT_TREE_DEPTH diff --git a/beacon_chain/peer_pool.nim b/beacon_chain/peer_pool.nim index f7af4ca40..58a241f3e 100644 --- a/beacon_chain/peer_pool.nim +++ b/beacon_chain/peer_pool.nim @@ -565,7 +565,7 @@ proc release*[A, B](pool: PeerPool[A, B], peer: A) = dec(pool.acqOutPeersCount) pool.fireNotEmptyEvent(item[]) -proc release*[A, B](pool: PeerPool[A, B], peers: openarray[A]) {.inline.} = +proc release*[A, B](pool: PeerPool[A, B], peers: openArray[A]) {.inline.} = ## Release array of peers ``peers`` back to PeerPool ``pool``. for item in peers: pool.release(item) diff --git a/beacon_chain/spec/beaconstate.nim b/beacon_chain/spec/beaconstate.nim index 312e8554c..7256980eb 100644 --- a/beacon_chain/spec/beaconstate.nim +++ b/beacon_chain/spec/beaconstate.nim @@ -15,7 +15,7 @@ import ../../nbench/bench_lab # https://github.com/ethereum/eth2.0-specs/blob/v1.0.0-rc.0/specs/phase0/beacon-chain.md#is_valid_merkle_branch -func is_valid_merkle_branch*(leaf: Eth2Digest, branch: openarray[Eth2Digest], +func is_valid_merkle_branch*(leaf: Eth2Digest, branch: openArray[Eth2Digest], depth: int, index: uint64, root: Eth2Digest): bool {.nbench.}= ## Check if ``leaf`` at ``index`` verifies against the Merkle ``root`` and diff --git a/beacon_chain/spec/helpers.nim b/beacon_chain/spec/helpers.nim index af39354f6..b971e8921 100644 --- a/beacon_chain/spec/helpers.nim +++ b/beacon_chain/spec/helpers.nim @@ -81,7 +81,7 @@ func get_randao_mix*(state: BeaconState, ## Returns the randao mix at a recent ``epoch``. state.randao_mixes[epoch mod EPOCHS_PER_HISTORICAL_VECTOR] -func bytes_to_uint64*(data: openarray[byte]): uint64 = +func bytes_to_uint64*(data: openArray[byte]): uint64 = doAssert data.len == 8 # Little-endian data representation diff --git a/beacon_chain/spec/keystore.nim b/beacon_chain/spec/keystore.nim index b1c971a0f..71db546d7 100644 --- a/beacon_chain/spec/keystore.nim +++ b/beacon_chain/spec/keystore.nim @@ -303,8 +303,8 @@ template add(m: var Mnemonic, s: cstring) = proc generateMnemonic*( rng: var BrHmacDrbgContext, - words: openarray[cstring] = englishWords, - entropyParam: openarray[byte] = @[]): Mnemonic = + words: openArray[cstring] = englishWords, + entropyParam: openArray[byte] = @[]): Mnemonic = ## Generates a valid BIP-0039 mnenomic: ## https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki#generating-the-mnemonic var entropy: seq[byte] @@ -413,7 +413,7 @@ proc keyFromPath*(mnemonic: Mnemonic, path: KeyPath): ValidatorPrivKey = deriveChildKey(deriveMasterKey(mnemonic, password), path) -proc shaChecksum(key, cipher: openarray[byte]): Sha256Digest = +proc shaChecksum(key, cipher: openArray[byte]): Sha256Digest = var ctx: sha256 ctx.init() ctx.update(key) @@ -421,7 +421,7 @@ proc shaChecksum(key, cipher: openarray[byte]): Sha256Digest = result = ctx.finish() ctx.clear() -proc writeJsonHexString(s: OutputStream, data: openarray[byte]) +proc writeJsonHexString(s: OutputStream, data: openArray[byte]) {.raises: [IOError, Defect].} = s.write '"' s.write ncrutils.toHex(data, {HexFlags.LowerCase}) @@ -624,10 +624,10 @@ proc decryptNetKeystore*(nkeystore: JsonString, proc createCryptoField(kdfKind: KdfKind, rng: var BrHmacDrbgContext, - secret: openarray[byte], + secret: openArray[byte], password = KeystorePass.init "", - salt: openarray[byte] = @[], - iv: openarray[byte] = @[]): Crypto = + salt: openArray[byte] = @[], + iv: openArray[byte] = @[]): Crypto = type AES = aes128 let kdfSalt = @@ -685,8 +685,8 @@ proc createNetKeystore*(kdfKind: KdfKind, privKey: lcrypto.PrivateKey, password = KeystorePass.init "", description = "", - salt: openarray[byte] = @[], - iv: openarray[byte] = @[]): NetKeystore = + salt: openArray[byte] = @[], + iv: openArray[byte] = @[]): NetKeystore = let secret = privKey.getBytes().get() cryptoField = createCryptoField(kdfKind, rng, secret, password, salt, iv) @@ -707,8 +707,8 @@ proc createKeystore*(kdfKind: KdfKind, password = KeystorePass.init "", path = KeyPath "", description = "", - salt: openarray[byte] = @[], - iv: openarray[byte] = @[]): Keystore = + salt: openArray[byte] = @[], + iv: openArray[byte] = @[]): Keystore = let secret = privKey.toRaw[^32..^1] cryptoField = createCryptoField(kdfKind, rng, secret, password, salt, iv) @@ -727,8 +727,8 @@ proc createWallet*(kdfKind: KdfKind, rng: var BrHmacDrbgContext, seed: KeySeed, name = WalletName "", - salt: openarray[byte] = @[], - iv: openarray[byte] = @[], + salt: openArray[byte] = @[], + iv: openArray[byte] = @[], password = KeystorePass.init "", nextAccount = none(Natural), pretty = true): Wallet = diff --git a/beacon_chain/spec/network.nim b/beacon_chain/spec/network.nim index 1e13cbe93..e1ad98df7 100644 --- a/beacon_chain/spec/network.nim +++ b/beacon_chain/spec/network.nim @@ -123,7 +123,7 @@ proc getStabilitySubnetLength*(): uint64 = rand(EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION.int).uint64 proc get_attestation_subnet_changes*( - state: BeaconState, attachedValidators: openarray[ValidatorIndex], + state: BeaconState, attachedValidators: openArray[ValidatorIndex], prevAttestationSubnets: AttestationSubnets, epoch: Epoch): tuple[a: AttestationSubnets, b: set[uint8], c: set[uint8]] = static: doAssert ATTESTATION_SUBNET_COUNT == 64 # Fits in a set[uint8] diff --git a/beacon_chain/ssz/bitseqs.nim b/beacon_chain/ssz/bitseqs.nim index 602b85edf..f56175868 100644 --- a/beacon_chain/ssz/bitseqs.nim +++ b/beacon_chain/ssz/bitseqs.nim @@ -23,7 +23,7 @@ type BitArray*[bits: static int] = object bytes*: array[(bits + 7) div 8, byte] -func bitsLen*(bytes: openarray[byte]): int = +func bitsLen*(bytes: openArray[byte]): int = let bytesCount = bytes.len lastByte = bytes[bytesCount - 1] @@ -63,14 +63,14 @@ func toBytesLE(x: uint): array[sizeof(x), byte] = else: static: doAssert false, "requires a 32-bit or 64-bit platform" -func loadLEBytes(WordType: type, bytes: openarray[byte]): WordType = +func loadLEBytes(WordType: type, bytes: openArray[byte]): WordType = # TODO: this is a temporary proc until the endians API is improved var shift = 0 for b in bytes: result = result or (WordType(b) shl shift) shift += 8 -func storeLEBytes(value: SomeUnsignedInt, dst: var openarray[byte]) = +func storeLEBytes(value: SomeUnsignedInt, dst: var openArray[byte]) = doAssert dst.len <= sizeof(value) let bytesLE = toBytesLE(value) copyMem(addr dst[0], unsafeAddr bytesLE[0], dst.len) @@ -213,8 +213,8 @@ template clearBit*(a: var BitArray, pos: Natural) = # TODO: Submit this to the standard library as `cmp` # At the moment, it doesn't work quite well because Nim selects # the generic cmp[T] from the system module instead of choosing -# the openarray overload -func compareArrays[T](a, b: openarray[T]): int = +# the openArray overload +func compareArrays[T](a, b: openArray[T]): int = result = cmp(a.len, b.len) if result != 0: return diff --git a/beacon_chain/ssz/bytes_reader.nim b/beacon_chain/ssz/bytes_reader.nim index 148f7a9c4..868eef9d9 100644 --- a/beacon_chain/ssz/bytes_reader.nim +++ b/beacon_chain/ssz/bytes_reader.nim @@ -22,7 +22,7 @@ proc setOutputSize(list: var List, length: int) {.raisesssz.} = # fromSszBytes copies the wire representation to a Nim variable, # assuming there's enough data in the buffer -func fromSszBytes*(T: type UintN, data: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type UintN, data: openArray[byte]): T {.raisesssz.} = ## Convert directly to bytes the size of the int. (e.g. ``uint16 = 2 bytes``) ## All integers are serialized as **little endian**. if data.len != sizeof(result): @@ -30,46 +30,46 @@ func fromSszBytes*(T: type UintN, data: openarray[byte]): T {.raisesssz.} = T.fromBytesLE(data) -func fromSszBytes*(T: type bool, data: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type bool, data: openArray[byte]): T {.raisesssz.} = # Strict: only allow 0 or 1 if data.len != 1 or byte(data[0]) > byte(1): raise newException(MalformedSszError, "invalid boolean value") data[0] == 1 -func fromSszBytes*(T: type Eth2Digest, data: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type Eth2Digest, data: openArray[byte]): T {.raisesssz.} = if data.len != sizeof(result.data): raiseIncorrectSize T copyMem(result.data.addr, unsafeAddr data[0], sizeof(result.data)) -func fromSszBytes*(T: type GraffitiBytes, data: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type GraffitiBytes, data: openArray[byte]): T {.raisesssz.} = if data.len != sizeof(result): raiseIncorrectSize T copyMem(result.addr, unsafeAddr data[0], sizeof(result)) -template fromSszBytes*(T: type Slot, bytes: openarray[byte]): Slot = +template fromSszBytes*(T: type Slot, bytes: openArray[byte]): Slot = Slot fromSszBytes(uint64, bytes) -template fromSszBytes*(T: type Epoch, bytes: openarray[byte]): Epoch = +template fromSszBytes*(T: type Epoch, bytes: openArray[byte]): Epoch = Epoch fromSszBytes(uint64, bytes) -func fromSszBytes*(T: type ForkDigest, bytes: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type ForkDigest, bytes: openArray[byte]): T {.raisesssz.} = if bytes.len != sizeof(result): raiseIncorrectSize T copyMem(result.addr, unsafeAddr bytes[0], sizeof(result)) -func fromSszBytes*(T: type Version, bytes: openarray[byte]): T {.raisesssz.} = +func fromSszBytes*(T: type Version, bytes: openArray[byte]): T {.raisesssz.} = if bytes.len != sizeof(result): raiseIncorrectSize T copyMem(result.addr, unsafeAddr bytes[0], sizeof(result)) -template fromSszBytes*(T: type BitSeq, bytes: openarray[byte]): auto = +template fromSszBytes*(T: type BitSeq, bytes: openArray[byte]): auto = BitSeq @bytes proc `[]`[T, U, V](s: openArray[T], x: HSlice[U, V]) {.error: - "Please don't use openarray's [] as it allocates a result sequence".} + "Please don't use openArray's [] as it allocates a result sequence".} template checkForForbiddenBits(ResulType: type, - input: openarray[byte], + input: openArray[byte], expectedBits: static int64) = ## This checks if the input contains any bits set above the maximum ## sized allowed. We only need to check the last byte to verify this: @@ -84,7 +84,7 @@ template checkForForbiddenBits(ResulType: type, if (input[^1] and forbiddenBitsMask) != 0: raiseIncorrectSize ResulType -func readSszValue*[T](input: openarray[byte], +func readSszValue*[T](input: openArray[byte], val: var T, updateRoot: bool = true) {.raisesssz.} = mixin fromSszBytes, toSszType diff --git a/beacon_chain/ssz/dynamic_navigator.nim b/beacon_chain/ssz/dynamic_navigator.nim index 68c1fd0f5..eb703be63 100644 --- a/beacon_chain/ssz/dynamic_navigator.nim +++ b/beacon_chain/ssz/dynamic_navigator.nim @@ -133,12 +133,12 @@ func navigatePath*(n: DynamicSszNavigator, path: string): DynamicSszNavigator {. raises: [Defect, IOError, ValueError, MalformedSszError, SszSizeMismatchError] .} = navigatePathImpl n, split(path, '/') -func navigatePath*(n: DynamicSszNavigator, path: openarray[string]): DynamicSszNavigator {. +func navigatePath*(n: DynamicSszNavigator, path: openArray[string]): DynamicSszNavigator {. raises: [Defect, IOError, ValueError, MalformedSszError, SszSizeMismatchError] .} = navigatePathImpl n, path func init*(T: type DynamicSszNavigator, - bytes: openarray[byte], Navigated: type): T = + bytes: openArray[byte], Navigated: type): T = T(m: MemRange(startAddr: unsafeAddr bytes[0], length: bytes.len), typ: typeInfo(Navigated)) diff --git a/beacon_chain/ssz/merkleization.nim b/beacon_chain/ssz/merkleization.nim index 58f460fb4..b9f471686 100644 --- a/beacon_chain/ssz/merkleization.nim +++ b/beacon_chain/ssz/merkleization.nim @@ -34,7 +34,7 @@ type totalChunks: uint64 topIndex: int -template chunks*(m: SszChunksMerkleizer): openarray[Eth2Digest] = +template chunks*(m: SszChunksMerkleizer): openArray[Eth2Digest] = m.combinedChunks.toOpenArray(0, m.topIndex) func digest(a, b: openArray[byte]): Eth2Digest = @@ -56,7 +56,7 @@ func digest(a, b, c: openArray[byte]): Eth2Digest = h.update c trs "HASH RESULT ", result -func mergeBranches(existing: Eth2Digest, newData: openarray[byte]): Eth2Digest = +func mergeBranches(existing: Eth2Digest, newData: openArray[byte]): Eth2Digest = trs "MERGING BRANCHES OPEN ARRAY" let paddingBytes = bytesPerChunk - newData.len @@ -77,7 +77,7 @@ func computeZeroHashes: array[sizeof(Limit) * 8, Eth2Digest] = const zeroHashes* = computeZeroHashes() -func addChunk*(merkleizer: var SszChunksMerkleizer, data: openarray[byte]) = +func addChunk*(merkleizer: var SszChunksMerkleizer, data: openArray[byte]) = doAssert data.len > 0 and data.len <= bytesPerChunk if getBitLE(merkleizer.totalChunks, 0): @@ -109,7 +109,7 @@ template isOdd(x: SomeNumber): bool = func addChunkAndGenMerkleProof*(merkleizer: var SszChunksMerkleizer, hash: Eth2Digest, - outProof: var openarray[Eth2Digest]) = + outProof: var openArray[Eth2Digest]) = var hashWrittenToMerkleizer = false hash = hash @@ -146,7 +146,7 @@ func completeStartedChunk(merkleizer: var SszChunksMerkleizer, break func addChunksAndGenMerkleProofs*(merkleizer: var SszChunksMerkleizer, - chunks: openarray[Eth2Digest]): seq[Eth2Digest] = + chunks: openArray[Eth2Digest]): seq[Eth2Digest] = doAssert chunks.len > 0 and merkleizer.topIndex > 0 let proofHeight = merkleizer.topIndex + 1 @@ -300,7 +300,7 @@ proc init*(S: type SszMerkleizer): S = totalChunks: 0) proc init*(S: type SszMerkleizer, - combinedChunks: openarray[Eth2Digest], + combinedChunks: openArray[Eth2Digest], totalChunks: uint64): S = new result.combinedChunks result.combinedChunks[][0 ..< combinedChunks.len] = combinedChunks @@ -321,10 +321,10 @@ proc clone*[L: static[Limit]](cloned: SszMerkleizer[L]): SszMerkleizer[L] = template addChunksAndGenMerkleProofs*( merkleizer: var SszMerkleizer, - chunks: openarray[Eth2Digest]): seq[Eth2Digest] = + chunks: openArray[Eth2Digest]): seq[Eth2Digest] = addChunksAndGenMerkleProofs(merkleizer.m, chunks) -template addChunk*(merkleizer: var SszMerkleizer, data: openarray[byte]) = +template addChunk*(merkleizer: var SszMerkleizer, data: openArray[byte]) = addChunk(merkleizer.m, data) template totalChunks*(merkleizer: SszMerkleizer): uint64 = @@ -409,7 +409,7 @@ template writeBytesLE(chunk: var array[bytesPerChunk, byte], atParam: int, chunk[at ..< at + sizeof(val)] = toBytesLE(val) func chunkedHashTreeRootForBasicTypes[T](merkleizer: var SszChunksMerkleizer, - arr: openarray[T]): Eth2Digest = + arr: openArray[T]): Eth2Digest = static: doAssert T is BasicType @@ -687,7 +687,7 @@ func hash_tree_root*(x: auto): Eth2Digest {.raises: [Defect].} = trs "HASH TREE ROOT FOR ", name(type x), " = ", "0x", $result -iterator hash_tree_roots_prefix*[T](lst: openarray[T], limit: static Limit): Eth2Digest = +iterator hash_tree_roots_prefix*[T](lst: openArray[T], limit: static Limit): Eth2Digest = # This is a particular type's instantiation of a general fold, reduce, # accumulation, prefix sums, etc family of operations. As long as that # Eth1 deposit case is the only notable example -- the usual uses of a diff --git a/beacon_chain/ssz/navigator.nim b/beacon_chain/ssz/navigator.nim index 4f3903681..c057091f5 100644 --- a/beacon_chain/ssz/navigator.nim +++ b/beacon_chain/ssz/navigator.nim @@ -15,7 +15,7 @@ type SszNavigator*[T] = object m: MemRange -func sszMount*(data: openarray[byte], T: type): SszNavigator[T] = +func sszMount*(data: openArray[byte], T: type): SszNavigator[T] = let startAddr = unsafeAddr data[0] SszNavigator[T](m: MemRange(startAddr: startAddr, length: data.len)) diff --git a/beacon_chain/ssz/ssz_serialization.nim b/beacon_chain/ssz/ssz_serialization.nim index 14c5fb511..8d4d839a2 100644 --- a/beacon_chain/ssz/ssz_serialization.nim +++ b/beacon_chain/ssz/ssz_serialization.nim @@ -175,7 +175,7 @@ proc writeValue*(w: var SszWriter, x: auto) {.gcsafe, raises: [Defect, IOError]. func sszSize*(value: auto): int {.gcsafe, raises: [Defect].} -func sszSizeForVarSizeList[T](value: openarray[T]): int = +func sszSizeForVarSizeList[T](value: openArray[T]): int = result = len(value) * offsetSize for elem in value: result += sszSize(toSszType elem) diff --git a/beacon_chain/sync_manager.nim b/beacon_chain/sync_manager.nim index 87a2e287d..c532bedd7 100644 --- a/beacon_chain/sync_manager.nim +++ b/beacon_chain/sync_manager.nim @@ -141,7 +141,7 @@ proc validate*[T](sq: SyncQueue[T], return await sblock.resfut proc getShortMap*[T](req: SyncRequest[T], - data: openarray[SignedBeaconBlock]): string = + data: openArray[SignedBeaconBlock]): string = ## Returns all slot numbers in ``data`` as placement map. var res = newStringOfCap(req.count) var slider = req.slot @@ -169,7 +169,7 @@ proc cmp*[T](a, b: SyncRequest[T]): int = result = cmp(uint64(a.slot), uint64(b.slot)) proc checkResponse*[T](req: SyncRequest[T], - data: openarray[SignedBeaconBlock]): bool = + data: openArray[SignedBeaconBlock]): bool = if len(data) == 0: # Impossible to verify empty response. return true @@ -199,7 +199,7 @@ proc checkResponse*[T](req: SyncRequest[T], return false proc getFullMap*[T](req: SyncRequest[T], - data: openarray[SignedBeaconBlock]): string = + data: openArray[SignedBeaconBlock]): string = # Returns all slot numbers in ``data`` as comma-delimeted string. result = mapIt(data, $it.message.slot).join(", ") diff --git a/beacon_chain/validator_slashing_protection.nim b/beacon_chain/validator_slashing_protection.nim index 2ace88826..b05b341ec 100644 --- a/beacon_chain/validator_slashing_protection.nim +++ b/beacon_chain/validator_slashing_protection.nim @@ -263,14 +263,14 @@ func subkey(kind: static SlashingKeyKind, valIndex: uint32): array[5, byte] = result[1..<5] = toBytesBE(valIndex) result[0] = byte ord(kind) -proc put(db: SlashingProtectionDB, key: openarray[byte], v: auto) = +proc put(db: SlashingProtectionDB, key: openArray[byte], v: auto) = db.backend.put( key, SSZ.encode(v) ).expect("working database") proc get(db: SlashingProtectionDB, - key: openarray[byte], + key: openArray[byte], T: typedesc): Opt[T] = const ExpectedNodeSszSize = block: diff --git a/benchmarks/bench_bls_sig_agggregation.nim b/benchmarks/bench_bls_sig_agggregation.nim index 1687536fc..e1a657b0b 100644 --- a/benchmarks/bench_bls_sig_agggregation.nim +++ b/benchmarks/bench_bls_sig_agggregation.nim @@ -140,8 +140,8 @@ proc main(nb_samples: Natural) = # TODO: update with IETF API (Eth2 v0.11.1) # func fastAggregateVerify*[T: byte|char]( - # publicKeys: openarray[PublicKey], - # message: openarray[T], + # publicKeys: openArray[PublicKey], + # message: openArray[T], # signature: Signature # Aggregated signature # ): bool diff --git a/docker/manage_testnet_hosts.nims b/docker/manage_testnet_hosts.nims index bae046e0c..e89fc94b7 100644 --- a/docker/manage_testnet_hosts.nims +++ b/docker/manage_testnet_hosts.nims @@ -44,7 +44,7 @@ var sort(validators) -proc findOrDefault[K, V](tupleList: openarray[(K, V)], key: K, default: V): V = +proc findOrDefault[K, V](tupleList: openArray[(K, V)], key: K, default: V): V = for t in tupleList: if t[0] == key: return t[1] diff --git a/docs/the_auditors_handbook/src/02.1.4_closure_iterators.md b/docs/the_auditors_handbook/src/02.1.4_closure_iterators.md index e125d8d0e..fe7ce4fcf 100644 --- a/docs/the_auditors_handbook/src/02.1.4_closure_iterators.md +++ b/docs/the_auditors_handbook/src/02.1.4_closure_iterators.md @@ -9,7 +9,7 @@ a pointer + an environment that stores the captured state necessary to execute the function. The Nim compiler has a limited form of borrow checking and prevents -capturing mutable variable or openarray (pointer+length pair). +capturing mutable variable or openArray (pointer+length pair). It otherwise copies the capture variables in case of objects with value semantics or increment the reference count in case of ref object. diff --git a/tests/mocking/mock_validator_keys.nim b/tests/mocking/mock_validator_keys.nim index 050b20ac2..24606a0f6 100644 --- a/tests/mocking/mock_validator_keys.nim +++ b/tests/mocking/mock_validator_keys.nim @@ -33,14 +33,14 @@ proc newKeyPair(rng: var BrHmacDrbgContext): BlsResult[tuple[pub: ValidatorPubKe # this is being indexed inside "mock_deposits.nim" by a value up to `validatorCount` # which is `num_validators` which is `MIN_GENESIS_ACTIVE_VALIDATOR_COUNT` -proc genMockPrivKeys(privkeys: var openarray[ValidatorPrivKey]) = +proc genMockPrivKeys(privkeys: var openArray[ValidatorPrivKey]) = let rng = newRng() for i in 0 ..< privkeys.len: let pair = newKeyPair(rng[])[] privkeys[i] = pair.priv -func genMockPubKeys(pubkeys: var openarray[ValidatorPubKey], - privkeys: openarray[ValidatorPrivKey]) = +func genMockPubKeys(pubkeys: var openArray[ValidatorPubKey], + privkeys: openArray[ValidatorPrivKey]) = for i in 0 ..< privkeys.len: pubkeys[i] = toPubKey(privkeys[i]) diff --git a/tests/official/fixtures_utils.nim b/tests/official/fixtures_utils.nim index 957f56cf9..4b53fc02d 100644 --- a/tests/official/fixtures_utils.nim +++ b/tests/official/fixtures_utils.nim @@ -57,7 +57,7 @@ proc parseTest*(path: string, Format: typedesc[Json or SSZ], T: typedesc): T = template readFileBytes*(path: string): seq[byte] = cast[seq[byte]](readFile(path)) -proc sszDecodeEntireInput*(input: openarray[byte], Decoded: type): Decoded = +proc sszDecodeEntireInput*(input: openArray[byte], Decoded: type): Decoded = var stream = unsafeMemoryInput(input) var reader = init(SszReader, stream) reader.readValue(result) diff --git a/tests/spec_epoch_processing/justification_finalization_helpers.nim b/tests/spec_epoch_processing/justification_finalization_helpers.nim index 8bc0e46c4..a1f79229b 100644 --- a/tests/spec_epoch_processing/justification_finalization_helpers.nim +++ b/tests/spec_epoch_processing/justification_finalization_helpers.nim @@ -86,7 +86,7 @@ proc getCheckpoints*(epoch: Epoch): tuple[c1, c2, c3, c4, c5: Checkpoint] = proc putCheckpointsInBlockRoots*( state: var BeaconState, - checkpoints: openarray[Checkpoint]) = + checkpoints: openArray[Checkpoint]) = for c in checkpoints: let idx = c.epoch.compute_start_slot_at_epoch() mod SLOTS_PER_HISTORICAL_ROOT state.block_roots[idx] = c.root diff --git a/tests/test_ssz_merkleization.nim b/tests/test_ssz_merkleization.nim index 9419ce22c..046424b10 100644 --- a/tests/test_ssz_merkleization.nim +++ b/tests/test_ssz_merkleization.nim @@ -21,7 +21,7 @@ type SparseMerkleTree[Depth: static int] = object nnznodes*: array[Depth+1, seq[Eth2Digest]] # nodes that leads to non-zero leaves func merkleTreeFromLeaves( - values: openarray[Eth2Digest], + values: openArray[Eth2Digest], Depth: static[int] = DEPOSIT_CONTRACT_TREE_DEPTH ): SparseMerkleTree[Depth] = ## Depth should be the same as is_valid_merkle_branch @@ -167,7 +167,7 @@ proc testMerkleMinimal*(): bool = doAssert testMerkleMinimal() -proc compareTreeVsMerkleizer(hashes: openarray[Eth2Digest], limit: static Limit) = +proc compareTreeVsMerkleizer(hashes: openArray[Eth2Digest], limit: static Limit) = const treeHeight = binaryTreeHeight(limit) let tree = merkleTreeFromLeaves(hashes, treeHeight) @@ -228,7 +228,7 @@ for prelude in [0, 1, 2, 5, 6, 12, 13, 16]: testMultiProofsGeneration(prelude, proofs, followUpHashes, 128) testMultiProofsGeneration(prelude, proofs, followUpHashes, 5000) -func attachMerkleProofsReferenceImpl(deposits: var openarray[Deposit]) = +func attachMerkleProofsReferenceImpl(deposits: var openArray[Deposit]) = let deposit_data_roots = mapIt(deposits, it.data.hash_tree_root) merkle_tree = merkleTreeFromLeaves(deposit_data_roots)