nice one California this will encourage more immigrants to come in for a better life


US and Iraq war continues


the legend himself. what a man !


this is so sad to read omg


fall of humanity


read about this and I was like how can someone be this influential love itt


wonderful video


Billionaire Investor Bessent Bets on ‘Trump Rally’ in Stock Market Before Election, Big Boom if Trump Wins https://yakihonne.s3.ap-east-1.amazonaws.com/9e9c40af199094b4016880278ea3d8383caf0234f61da915c829d9bee4d8b45f/files/1706880556903-YAKIHONNES3.jpg

Scott Bessent, a billionaire investor, expects the stock market to continue to rally whenever former President Donald Trump leads Democrat President Joe Biden in general election polling. If Trump beats Biden in November, Bessent expects a huge and long-sustained boom in the market.

In an 18-page memo to investors sent on Wednesday, Bessent and his management team at Key Square Capital Management LLC—a top investment firm—laid out what he calls an ongoing “Trump rally” in the markets as investors expect Trump to topple Biden in November of this year.


Defense Secretary Lloyd Austin Apologizes for Secret Hospital Visit https://yakihonne.s3.ap-east-1.amazonaws.com/9e9c40af199094b4016880278ea3d8383caf0234f61da915c829d9bee4d8b45f/files/1706880420733-YAKIHONNES3.jpg

U.S. Secretary of Defense Lloyd Austin apologized on Thursday for his secret hospital visit, during which he seemingly disappeared for several days, admitting that he did not handle it well.


Canadian 'poison killer' Kenneth Law to head straight to trial

The case of a Canadian man accused of supplying a poisonous chemical to people who died by suicide will head straight to trial, an Ontario court has decided.
Prosecutors have also upgraded the charges against Kenneth Law from second-degree to first-degree murder.
Mr Law may have sent more than 1,200 parcels containing lethal substances to around 40 countries, including the UK.
He made his latest court appearance on Thursday.
Mr Law, a 57-year-old former chef from Toronto, is facing a total of 14 first-degree murder charges, as well as 14 counts of aiding and counselling suicide, for a total of 28 charges.

https://www.bbc.com/news/world-us-canada-68176391


Wolves 3-4 Man Utd: Kobbie Mainoo continues rise to stardom with 'dream' winning goal

His first Premier League goal was a 97th-minute winner for his childhood club to seal a 4-3 victory. No wonder Kobbie Mainoo was grinning ear to ear.

"It is a dream come true," the 18-year-old Manchester United midfielder told TNT Sports, following his winner in a Premier League classic against Wolverhampton Wanderers at Molineux.

https://www.bbc.com/sport/football/68176430


Happy Grundsaudaag! The ancient Germanic history of Groundhog Day

You say Groundhog Day, I say Grundsaudaag: how German and Swiss settlers in Pennsylvania created a new language – and a much-loved American holiday.

E
Every 2 February since at least 1886, people have been gathering in the Pennsylvanian town of Punxsutawney to watch a groundhog – a furry rodent – crawl out of a hole after its winter sleep. If the day is sunny and the groundhog sees its own shadow, there will be six more weeks of cold weather, according to legend – but if it's a cloudy day, and there is no shadow, spring has arrived. Across the US, the quirky tradition is known as Groundhog Day. But among its original celebrants, it has a different name: Grundsaudaag.

https://www.bbc.com/future/article/20240131-how-the-pennsylvania-dutch-created-groundhog-day


The Courts Have Caught Up to Canadian Government Overreach

Canada’s Federal Court has ruled that the government’s response to the 2022 trucker protest violated the law. But will Canadians care?
Governments everywhere did many absurd and unaccountable things during the Covid pandemic, but one, at least, is now being held accountable by the courts. In Canada, the Federal Court has ruled that the Trudeau government’s invocation of the Emergencies Act.

Christine Van Geyn of the Canadian Constitution Foundation (CCF), a Calgary-based public-interest organization that alongside other civil-liberty groups mounted a legal challenge against the use of the Emergencies Act, called the Federal Court decision “a complete repudiation of the government’s position and a massive political humiliation for the Liberals” and “extremely gratifying for Canadians

https://www.nationalreview.com/2024/02/the-courts-have-caught-up-to-canadian-government-overreach/


Terror By Night: Who Pays The Price For Botched SWAT Team Raids? We Do...

Sometimes you don’t get a warning before all hell breaks loose.

Imagine it, if you will: It’s the middle of the night. Your neighborhood is in darkness. Your household is asleep. Suddenly, you’re awakened by a loud noise.

Barely ten seconds later, someone or an army of someones has crashed through your front door.

The intruders are in your home.

Your heart begins racing. Your stomach is tied in knots. The adrenaline is pumping through you.

You’re not just afraid. You’re terrified.

Desperate to protect yourself and your loved ones from whatever threat has invaded your home, you scramble to lay hold of something—anything—that you might use in self-defense. It might be a flashlight, a baseball bat, or that licensed and registered gun you thought you’d never need.


Majority Of Germans Reject Left-Liberal Government's Radical Immigration Law

A majority of Germans oppose the government’s radical immigration law, which will allow up to 2.5 million foreigners to obtain German citizenship in time for the federal election in 2025.


UK could recognize Palestinian state before any deal with Israel, says David Cameron
U.K.’s top diplomat says recognition “can’t come at the start of the process, but it doesn’t have to be the very end of the process.”


GOP puts Dems on defensive over border security in bellwether special election


great graphics I must say.


The Libra blockchain is designed to store billions of dollars in assets, so the security of code that executes transactions is important. the libra blockchain has a new language for implementing transactions, called “move.” this paper describes the move prover, an automatic formal verification system for move. we overview the unique features of the move language and then describe the architecture of the prover, including the language for formal specification and the translation to the boogie intermediate verification language .

Original Link : https://dl.acm.org/doi/10.1007/978-3-030-53288-8_7

Original Author : [Jingyi Emma Zhong ](https://dl.acm.org/pb-assets/icons/DOs/default-profile-1543932446943.svg), [Kevin Cheang](https://dl.acm.org/pb-assets/icons/DOs/default-profile-1543932446943.svg), [Shaz Qadeer](), [Wolfgang Grieskamp](), [Sam Blackshear](), [Junkil Park](), [Yoni Zohar](), [Clark Barrett](), [David L. Dill]().

2020 Jan. The Move Proper (older outdated paper)


**INTRODUCTION**

the move prover (mvp) serves as a formal verification tool intended for regular usage during code development for smart contracts. its verification process is swift and predictable, akin to running compilers, linters, and other development tools. achieving a fast verifier was a non-trivial task, and in this paper, we aim to divulge the critical engineering and architectural decisions facilitating this achievement.

smart contracts offer a favorable ground for verification due to several reasons: their compact code size, execution within a well-defined isolated environment, and typically sequential, deterministic computations with minimal interactions with the environment, devoid of explicit i/o operations. moreover, the imperative for formal verification is accentuated in the realm of smart contracts due to substantial financial and regulatory risks, underscored by significant losses that have occurred previously.

a pivotal factor contributing to mvp's success is its close integration with the move programming language , developed as part of the diem blockchain , designed from its inception to be used in tandem with formal verification. move evolves in parallel with mvp and facilitates specifying pre-, post-, and abort conditions of functions, alongside invariants over data structures and the global persistent memory (the blockchain's state). however, the liberal use of quantification in specifications poses a challenge to verification.

despite the complexity of specifications, mvp efficiently verifies the complete move implementation of the diem blockchain, known as the diem framework , within a few minutes. this framework encompasses functionalities managing accounts and their interactions, supporting multiple currencies, account roles, and transaction rules. comprising approximately 8,800 lines of move code and 6,500 lines of specifications (inclusive of comments), the extensive specification demonstrates the framework's rigorousness. furthermore, verification occurs seamlessly through automated processes, running continuously alongside unit and integration tests, attesting to its practicality. ensuring reliability is as crucial as speed during integration tests, where sporadic failures or timeouts are deemed unacceptable.

mvp, an intricate and evolving software piece, has undergone various tuning and optimization iterations. determining the precise implementation decisions yielding swift and reliable performance remains challenging. however, three principal concepts have notably enhanced speed and reliability since the initial mvp prototype description :

1) an alias-free memory model based on move’s semantics, akin to the rust programming language.
2) fine-grained invariant checking to maintain invariants at every state, unless developers intentionally suspend them.
3) monomorphization, instantiating type parameters within move’s generic structures, functions, and specification properties.

these enhancements transformed a tool prone to frustrating, occasionally random timeouts, especially on complex or erroneous specifications, into one that consistently completes in under 30 seconds. moreover, numerous other improvements include an enhanced specification language, reduced false positives, and improved error reporting.

the paper proceeds by initially introducing the move language and its synergy with mvp, followed by an exploration of mvp's design and the three primary optimizations. an appendix detailing the injection of function specifications complements these sections.

**MOVE AND THE PROVER**

move, originally designed for the diem blockchain, isn't specifically tailored solely for blockchain applications. a move execution involves a sequence of updates that evolve a global persistent memory state, referred to simply as the (global) memory. analogous to other blockchains, these updates comprise a series of atomic transactions. any runtime errors lead to a transaction abort, maintaining the blockchain state unaltered, except for transferring some currency ("gas") from the sending account to cover the transaction execution cost.

the global memory is structured as a collection of resources, delineated by move structures (data types). a resource within the memory is identified by a pairing of a type and an address (e.g., the address of a user account). for instance, the expression exists<coin<usd>>(addr) would yield true if a value of type coin<usd> is stored at addr. demonstrating this example, move employs type generics, where the usage of generic functions and types is a characteristic aspect of move programming.

a move application is constituted by a series of transaction scripts. each script defines a move function with input parameters but lacks output parameters. this function modifies the global memory and may emit events. the execution of this function might abort explicitly due to an abort instruction or implicitly as a consequence of a runtime error, such as an out-of-bounds vector index.

fig. 1
![image](https://yakihonne.s3.ap-east-1.amazonaws.com/9e9c40af199094b4016880278ea3d8383caf0234f61da915c829d9bee4d8b45f/files/1704454747744-YAKIHONNES3.png)

programming in move

in move, transactions are defined via script functions that take a set of parameters and can invoke other functions. script and regular functions are encapsulated within modules. move modules serve as the domain where structs are defined. fig. 1 (for an elaborate description, refer to the move book ) illustrates a basic move contract. this example depicts a straightforward account that maintains a balance within the struct account, providing the script function "transfer" to manage this resource. generally, scripts incorporate signer arguments, representing account addresses authenticated by cryptographic signatures. in the given example, the "assert" statement prompts a move transaction to terminate execution if the condition isn't met. move, akin to rust, supports references (e.g., &signer) and mutable references (e.g., &mut t). however, references cannot be part of structs stored in global memory.

Image

fig. 2: account example specification

![image](https://yakihonne.s3.ap-east-1.amazonaws.com/9e9c40af199094b4016880278ea3d8383caf0234f61da915c829d9bee4d8b45f/files/1704454816136-YAKIHONNES3.jpg)

move's specification language supports design by contract, enabling developers to establish pre and post conditions for functions, encompassing conditions over parameters and global memory. developers can also define invariants over data structures and global memory contents. the language supports universal and existential quantification over bounded and effectively unbounded domains, such as indices of a vector or memory addresses and integers, respectively. although quantifiers can render the verification problem undecidable and introduce difficulties with timeouts, in practice, they offer the advantage of enabling more direct formalization of numerous properties, thereby enhancing specification clarity.

fig. 2 demonstrates the specification language extension of the account example in fig. 1 (refer to for the specification language definition). it includes the specification of the "transfer" function, a helper function "bal" for specification usage, and two global memory invariants. the first invariant stipulates that a balance cannot fall below a specific minimum threshold. the second invariant concerns a global memory update with pre and post states: the account balance cannot decrease by more than a certain amount in a single step. notably, while the move programming language uses only unsigned integers, the specification language employs arbitrary precision signed integers, facilitating the specification of expressions like x + y <= limit without grappling with arithmetic overflow complexities.

specifications for the "withdraw" and "deposit" functions are omitted in this instance. mvp allows omission of specifications for non-recursive functions, treating them as if they are inlined at the caller site.

running the prover

mvp operates entirely automatically, akin to a type checker or linter, aiming to complete within a reasonable time frame, enabling seamless integration into the regular development workflow. executing mvp on the "account" module reveals multiple errors. the first error detected is:

fig. 3: move prover architecture

![image](https://yakihonne.s3.ap-east-1.amazonaws.com/9e9c40af199094b4016880278ea3d8383caf0234f61da915c829d9bee4d8b45f/files/1704454910341-YAKIHONNES3.png)

mvp identifies the absence of an implicit abort condition in the specification of the "withdraw" function. it displays the error context, along with an execution trace leading to the error. the smt solver's counterexample values for variable assignments, along with the execution trace, are presented. logically, the counterexample highlights variable assignments where the program fails to adhere to the specification. mvp endeavors to generate user-friendly diagnostics for move developers, without necessitating a deep understanding of the prover's internals.

additional verification errors in this instance relate to the global invariants: the code doesn't enforce the limits specified in "min_balance()" and "max_decrease()." this issue can be resolved by adding more assert statements to validate these limits (see appendix b).

the programs and specifications handled by mvp are considerably larger than this example. the conditions that can prompt a transaction abort in the diem framework typically involve dozens of individual predicates originating from other functions called by the transaction. furthermore, hundreds of memory invariants are specified, encoding access control and other requirements for the diem blockchain.

**MOVE PROVER DESIGN**
fig. 3 illustrates the architecture of mvp. the process initiates with move code, incorporating specifications as input into the tool chain, generating two key artifacts: an abstract syntax tree (ast) of the specifications and the resulting bytecode. the move model unifies these elements alongside additional metadata from the original code, forming an integrated object model that feeds into the subsequent tool chain stages.

the subsequent phase involves the prover compiler, functioning as a pipeline of bytecode transformations. this discussion centers on pivotal transformations: reference elimination, specification injection, and monomorphization. while the prover operates with a modified version of move vm bytecode as an intermediate representation, we elucidate these transformations at the move source level for clarity.

the transformed bytecode is further compiled into the boogie intermediate verification language. boogie supports an imperative programming model adept at encoding transformed move code. boogie subsequently translates to multiple smt solver backends, including z3  and cvc5 , with z3 being the current default choice for the move prover.

reference elimination

reference elimination stands as the cornerstone of the alias-free memory model within the move prover. this elimination is instrumental in enhancing system speed and reliability by mitigating the proliferation of possible aliasing relationships present in most software verification and static analysis systems.

in move, the reference system is grounded in borrow semantics , akin to rust programming language principles. initial borrowing must stem from either global memory or a local stack variable (termed locations herein). move facilitates the creation of immutable references (with syntax &x) and mutable references (with syntax &mut x) for local variables. for global memories, references are created through borrow_global and borrow_global_mut built-ins. borrowing a reference to a whole struct allows field borrowing via &mut x.f and &x.f. similarly, referencing a vector involves element borrowing through native functions vector::borrow(v, i) and vector::borrow_mut(v, i). enforced by the borrow checker, move offers the following guarantees:

each location allows either precisely one mutable reference or n immutable references. this rule mirrors rust's borrow semantics but is enforced differently for global memories via acquires annotations. for instance, consider function withdraw acquiring the account global location, thereby prohibiting withdraw from calling other functions that might borrow or modify the account global memory (e.g., deposit).

the lifetime of references to stack data cannot surpass the lifetime of the stack location. this restriction encompasses global memories borrowed within a function. consequently, a reference to a global memory cannot be returned, either wholly or partially, from the function.
these assurances enable the elimination of references from a move program, obviating the need to reason about aliasing.

immutable references

immutable references undergo replacement by values. for instance, we eliminate the reference type constructor and all reference-taking operations from the code:

move
copy code
// example transformation
while immutable references are pivotal during move program execution to prevent copies for performance and enforce ownership, their distinction from values becomes inconsequential for symbolic reasoning on correct move programs.

mutable references

mutating a location l commences with an initial borrow of the entire data stored in that location, generating a reference r. as long as r remains alive, move code can either update its value (*r = v) or derive a sub-reference (r’ = &mut r.f). the mutation concludes when both r and any derived go out of scope.

the borrow checker guarantees that no other reference can exist into the same data in l while mutating the data—rendering it impossible for other move code to ascertain whether the value has mutated during the reference's retention.

these semantics facilitate the handling of mutable references through read-update-write cycles. a copy of the data in l can be created, followed by a series of mutation steps represented as functional data updates. upon the last reference for the data in l exiting scope, the updated value is written back to l. consequently, an imperative program with references transitions into one with only state updates on global memory or stack variables, devoid of aliasing. the basics of this approach are illustrated below:

move
copy code
// example illustration
dynamic mutable references

while the aforementioned setup addresses a majority of everyday move code use cases, the general case becomes more intricate when the referenced location isn't known statically. for instance, consider the following move code:

move
copy code
let r = if (p) &mut s1 else &mut s2; increment_field(r);

such cases necessitate additional logical encoding. when a reference expires, knowledge of its derived location becomes crucial for writing back the updated value. fig. 4 delineates this approach, introducing a new type mut<t> internal to mvp. this type tracks both the location from which t was derived and the value of t. mut<t> supports various operations:

mvp::mklocal(value, local_id): generates a new mutation value for a local with the given local id, where the local id uniquely identifies a local variable in the function,  the elimination of mutable references, depicting operations related to mut<t> type.
mvp executes this transformation by constructing a borrow graph from the program via data flow analysis. this graph monitors when references are released and their relationships. for instance, r’ = &mut r.f creates an edge from r to r’ labeled with f. this inter-procedural borrow analysis necessitates computed summaries for the borrow graph of called functions, guiding the transformation by inserting mut<t> type operations.

global invariant injection
smart contract correctness hinges significantly on blockchain state accuracy, rendering global invariants crucial in the move specification language. for instance, within the diem framework, global invariants might encapsulate requirements such as an account being accompanied by various other types stored at the same address or specific state changes permitted only for certain accounts by the access control scheme.

most software verification tools ascertain that functions maintain invariants by presuming the invariant's presence at each function entry and verifying them upon exit. within a module or class, it's essential to validate that invariants are preserved by public functions since internal implementations might inadvertently violate invariants. a previous move prover version embraced precisely this approach.

contrarily, the current prover implementation emphasizes ensuring invariants persist after every instruction, unless explicitly suspended by a user. this fine-grained approach boasts performance benefits: invariants are solely proven upon executing instructions that could potentially invalidate them, often resulting in computationally simple proofs due to minor changes from a single instruction. the suspension of relatively few invariants, over a small span of instructions, preserves these advantages. additionally, pervasive invariant adherence throughout the code grants their availability to confirm other properties like abort conditions. for instance, if a function accesses type t1 followed by t2, t2's access will never abort if the presence of t1 implies t2's presence at every state in the function body—an occurrence frequently observed in the diem framework.

invariant types and proof methodology

inductive invariants: declared in move modules, these properties must, by default, hold for the global memory consistently. inductive invariants frequently quantify over addresses. grounded in move's borrow semantics, inductive invariants don't require adherence while memory is mutated since changes remain invisible to other code until written back. this aligns with the reference elimination outlined

modular verification aims to ensure the seamless integration of untrusted modules into open systems without compromising established invariants. each invariant corresponds to a specific subset of move modules, forming a unique 'cluster.' proving the invariant's validity within this cluster guarantees its consistency across all modules, including those developed after the initial proof. this cluster encompasses all functions capable of invalidating the invariant. in cases of suspension, it includes all callers of such functions. notably, functions outside the cluster inherently preserve the invariant, necessitating verification only for functions defined within the cluster.

mvp (modular verification process) systematically assesses a given set of modules, referred to as 'target modules,' typically one at a time. the 'target invariants' encompass all global invariants within these modules. the cluster itself constitutes the smallest set comprising all target modules.

the initial phase involves analyzing the injection of global invariants without considering type parameters. for instance,represents an inductive invariant, assumed upon function entry, and asserted post-state update. conversely, i2 serves as an update invariant, relating pre and post states by storing a state snapshot labeled i2_before, utilized subsequently in an assertion.

efficient global invariant injection is achieved through leveraging the prover's knowledge, obtained via static analysis, concerning accessed and modified memory. 'accessed(f)' refers to the memory accessed by a function 'f,' while 'modified(f)' signifies the memory modified by 'f.' similarly, 'accessed(i)' encompasses the memory accessed by an invariant, including all functions it calls.

the injection process assumes 'i' at 'f's entry if accessed(f) overlaps with accessed(i). after each program step, 'i' is asserted if the step either modifies a memory location 'm' in accessed(i), or if it involves a call to function 'f' where 'i' is suspended, and modifies(f') intersects with accessed (i). moreover, for an update invariant 'i,' a memory snapshot save is injected before the update or call.

challenges arise concerning genericity, especially in determining if a function can modify an invariant. for example, i1 applies to a specific type instantiation 's<u64>,' while i2 is generic across all type instantiations for 's<t>'. a non-generic function 'f,' operating on 's<u8>,' requires the injection of the specialized instance 'i2[t = u8]'. however, 'i1' (relevant to 's<u64>') must also be injected alongside 'i2' because 'g,' being generic in type 'r,' could be instantiated as 'u64.'

addressing genericity involves type unification, wherein successful unification of memory types for a function 'f<r>' and an invariant 'i<t>' results in a substitution for both type parameters. this integration includes the invariant with 't' specialized according to the substitution.

monomorphization, as a transformational process, removes generic types from a move program by specializing it for relevant type instantiations. in verification contexts, the specialized program validates only if the generic program does, supporting types as first-class values in an encoding format that enables faster verification through a multi-sorted representation in smt logic.

to verify a generic function across all possible instantiations, monomorphization skolemizes the type parameter, ensuring verification for a new type representing an arbitrary type. this process involves specializing all called functions and used data types with this new type and any other concrete types they might use, as depicted in fig. 7.

however, this approach faces an issue in move where the provided genericity type doesn't allow full type erasure. this limitation stems from the use of types to index global memory (e.g., global<s<t>>(addr) where 't' is a generic type). consider the following move function

the efficacy of monomorphization in handling type-dependent code hinges on assessing accessed memory and injected specifications to derive additional function instantiations requiring verification. for instance, verifying both 'f_t' and an instantiation 'f_u64' sufficiently cover various function behavior cases.

the algorithm for computing instances requiring verification operates through a specific methodology. for a verified target function 'f<t1,..,tn>' with all injected specifications and expanded inlined function calls:

for each memory 'm' in 'modified(f),' if a memory 'm’' in 'modified(f) + accessed(f)' can unify with 'm' via 't1,..,tn,' an instantiation of the type parameters 'ti' is collected from the resulting substitution. this instantiation might not assign values to all type parameters, leaving some parameters unchanged (e.g., 'f<t1, t2>' yielding a partial instantiation 'f<t1, u8>').

following this, all partial instantiations are computed and extended by unifying them against each other. if '<t>' and '<t’>' unify under the substitution 's,' then '<s(t)>' becomes part of the set. for example, given 'f<t1, t2>' modifying 'm<t1>' and 'r<t2>' and accessing 'm<u64>' and 'r<u8>,' instantiations '<u64, t2>' and '<t1, u8>' lead to the addition of '<u64, u8>' to the set.

**ANALYSIS**

reliability and performance the three improvements described above resulted in a major qualitative change in performance and reliability. in the version of mvp released in september 2020, correct examples veriﬁed fairly quickly and reliably. but that is because we needed speed and reliability, so we disabled some properties that always timed out and others that timed out unpredictably when there were small changes in the framework. we learned that incorrect programs or speciﬁcations would time out predictably enough that it was a good bet that examples that timed out were erroneous. however, localizing the error to ﬁx it was very hard, because debugging is based on a counterexample that violates the property, and getting a counterexample requires termination!

with each of the transformations described, we witnessed signiﬁcant speedups and, more importantly, reductions in timeouts. monomorphization was the last feature implemented, and, with it, timeouts almost disappeared. although this was the most important improvement in practice, it is difﬁcult to quantify because there have been many changes in diem framework, its speciﬁcations, mvp, and even the move language over that time.

it is simpler (but less important) to quantify the changes in run time of mvp on one of our more challenging modules, the diemaccount module, which is the biggest module in the diem framework. this module implements basic functionality to create and maintain multiple types of accounts on the blockchain, as well as manage their coin balances. it was called libraaccount in release 1.0 of mvp, and is called diemaccount today. the comparison requires various patches as described in [16]. the table below lists the consolidated numbers of lines, functions, invariants, conditions (requires, ensures, and aborts-if), as well as the veriﬁcation times:

notice that diemaccount has signiﬁcantly grown in size compared to the older version. speciﬁcally, additional speciﬁcations have been added. moreover, in the original libraaccount, some of the most complex functions had to be disabled for veriﬁcation because the old version of mvp would time out on them. in contrast, in diemaccount and with the new version, all functions are veriﬁed. veriﬁcation time has been improved by roughly 20%, in the presence of three times more global invariants, and 50% more function conditions.

we were able to observe similar improvements for the remaining of the 40 modules of the diem framework. all of the roughly half-dozen timeouts resolved after introduction of the transformations described in this paper.

causes for the improvements it’s difﬁcult to pin down and measure exactly why the three transformations described improved performance and reliability so dramatically. we have explained some reasons in the subsections above: the alias-free memory model reduced search through combinatorial sharing arrangments, and the ﬁne-grained invariant checking results in simpler formulas for the smt solver.

we found that most timeouts in speciﬁcations stemmed from our liberal use of quantiﬁers. to disprove a property p0 after assuming a list of properties, p1, . . . pn, the smt solver must show that ¬p0 ∧ p1 ∧ . . . ∧ pn is satisﬁable. the search usually involves instantiating universal quantiﬁers in p1, . . . , pn. the smt solver can do this endlessly, resulting in a timeout. indeed, we often found that proving a postcondition false would time out, because the smt solver was instantiating quantiﬁers to ﬁnd a satisfying assignment of p1 ∧ . . . ∧ pn. simpler formulas result in fewer intermediate terms during solving, resulting in fewer opportunities to instantiate quantiﬁed formulas.

we believe that one of the biggest impacts, speciﬁcally on removing timeouts and improving predictability, is monomorphization. the reason for this is that monomorphization allows a multi-sorted representation of values in boogie (and eventually the smt solver). in contrast, before monomorphization, we used a universal domain for values in order to represent values in generic functions, roughly as follows:

type value = num( int) | address (int ) | struct (vector < value >) | ...

this creates a large overhead for the smt solver, as we need to exhaustively inject type assumptions (e.g. that a value is actually an address), and pack/unpack values. consider a quantiﬁer like forall a: address: p(x) in move. before monomorphization, we have to represent this in boogie as forall a: value: is#address(a)=> p(v#address(a)). this quantiﬁer is triggered where ever is# address(a) is present, independent of the structure of p. over-triggering or inadequate triggering of quantiﬁers is one of the suspected sources of timeouts, as also discussed in [11].

moreover, before monomorphization, global memory was indexed in boogie by an address and a type instantiation. that is, for struct r<t> we would have one boogie array [type, int]value. with monomorphization, the type index is eliminated, as we create different memory variables for each type instantiation. quantiﬁcation over memory content works now on a one-dimensional instead of an ndimensional boogie array.

discussion and related work many approaches have been applied to the veriﬁcation of smart contracts; see e.g. the surveys [13,28]. [28] refers to at least two dozen systems for smart contract veriﬁcation. it distinguishes between contract and program level approaches. our approach has aspects of both: we address program level properties via pre/post conditions, and contract (“blockchain state”) level properties via global invariants. to the best of our knowledge, among the existing approaches, the move ecosystem is the ﬁrst one where contract programming and speciﬁcation language are fully integrated, and the language is designed from ﬁrst principles inﬂuenced by veriﬁcation. methodologically, move and the move prover are thereby closer to systems like dafny [10], or the older spec# system [4], where instead of adding a speciﬁcation approach posterior to an existing language, it is part from the beginning. this allows us not only to deliver a more consistent user experience, but also to make veriﬁcation technically easier by curating the programming language.

in contrast to other approaches that only focus on speciﬁc vulnerability patterns [6,14,20,30], mvp offers a universal speciﬁcation language. to the best of our knowledge, no existing speciﬁcation approach for smart contracts based on inductive hoare logic has similar expressiveness. we support universal quantiﬁcation over arbitrary memory content, a suspension mechanism of invariants to allow nonatomic construction of memory content, and generic invariants. for comparison, the smt checker build into solidity [7,8,9] does not support quantiﬁers, because it interprets programming language constructs (requires and assert statements) as speciﬁcations and has no dedicated speciﬁcation language. while in solidity one can simulate aspects of global invariants using modiﬁers by attaching pre/post conditions, this is not the same as our invariants, which are guaranteed to hold independent of whether a user may or (accidentally) may not attach a modiﬁer, and which are optimized to be only evaluated as needed.

while the expressiveness of move speciﬁcations comes with the price of undecidability and the dependency from heuristics in smt solvers, mvp deals with this by its elaborated translation to smt logic, as described in this paper. the result is a practical veriﬁcation system that is fully integrated into the diem blockchain production process, running in continuous integration, which is (to the best of our knowledge) a ﬁrst in the industry.

the individual techniques we described are novel each by themselves. reference elimination relies on borrow semantics, similar as in the rust [15] language. we expect reference elimination to apply for the safe subset of rust, though some extra work would be needed to deal with references aggregated by structs. however, we are not aware of that something similar has been attempted in existing rust veriﬁcation work [1,2,12,29]. global invariant injection and the approach to minimize the number of assumptions and assertions is not applied in any existing veriﬁcation approach we know of; however, we co-authored a while ago a similar line of work for runtime checking of invariants in spec# [27], yet that work never left the conceptual state. monomorphization is well known as a technique for compiling languages like c++ or rust, where it is called specialization; however, we are not aware of it being generalized for modular veriﬁcation of generic code where full type erasure is not possible, as it is the case in move.

future work mvp is conceived as a tool for achieving higher assurance systems, not as a bug hunting tool. having at least temporarily achieved satisfactory performance and reliability, we are turning our attention to the question of the goal of higher assurance, which raises several issues. if we’re striving for high assurance, it would be great to be able to measure progress towards that goal. since system requirements often stem from external business and regulatory needs, lightweight processes for exposing those requirements so we know what needs to be formally speciﬁed would be highly desirable.

as with many other systems, it is too hard to write high-quality speciﬁcations. our current speciﬁcations are more verbose than they need to be, and we are working to require less detailed speciﬁcations, especially for individual functions. we could expand the usefulness of mvp for programmers if we could make it possible for them to derive value from simple reusable speciﬁcations. finally, software tools for assessing the consistency and completeness of formal speciﬁcations would reduce the risk of missing bugs because of speciﬁcation errors.

however, as more complex smart contracts are written and as more people write speciﬁcations, we expect that the inherent computational difﬁculty of solving logic problems will reappear, and there will be more opportunities for improving performance and reliability. in addition to translation techniques, it will be necessary to identify opportunities to improve smt solvers for the particular kinds of problems we generate.

**CONCLUSION**
we described key aspects of the move prover (mvp), a tool for formal veriﬁcation of smart contracts written in the move language. mvp has been successfully used to verify large parts of the diem framework, and is used in continuous integration in production. the speciﬁcation language is expressive, speciﬁcally by the powerful concept of global invariants. we described key implementation techniques which (as conﬁrmed by our benchmarks) contributed to the scalability of mvp. one of the main areas of our future research is to improve speciﬁcation productivity and reduce the effort of reading and writing specs, as well as to continue to improve speed and predictability of veriﬁcation.

Original Link : https://arxiv.org/abs/2110.08362

Original Author : [David Dill](https://arxiv.org/search/cs?searchtype=author&query=Dill,+D), [Wolfgang Grieskamp](https://arxiv.org/search/cs?searchtype=author&query=Grieskamp,+W),[Junkil Park](https://arxiv.org/search/cs?searchtype=author&query=Park,+J), [Shaz Qadeer](https://arxiv.org/search/cs?searchtype=author&query=Qadeer,+S), [Meng Xu](https://arxiv.org/search/cs?searchtype=author&query=Xu,+M), [Emma Zhong](https://arxiv.org/search/cs?searchtype=author&query=Zhong,+E)


rooch v0.2 has been released, featuring accountabstraction, introducing a dashboard, and launching a developer testnet. this is part of rooch's third milestone called "rooting."

**Key Features of Rooch v0.2#**

main features of this release include:

**rooch command line and nodes**

* improved local configuration files and private key management. added functionality to recover private keys through mnemonics and enhanced local private key security. future upgrades will ensure client configuration file compatibility.
* implemented storage for states, transactions, and events.

**account abstraction**

* introduced authenticationabstraction, allowing third parties to develop authentication validator to extend signature validation or social logins.
* implemented sessionkey. these temporary private keys can sign transactions and are stored within the app rather than the wallet. this avoids the need for wallet signatures with every operation, enhancing user experience.

 for a detailed design on rooch accountabstraction, refer to:[Design and Implementation of Account Abstraction](https://rooch.network/docs/dive-into-rooch/account-abstraction.en-US)

**ETHEREUM SUPPORT**

* rooch move framework now support ethereum address mapping and ethereum signature verification.

* improved rooch's ethereum rpc api and enhanced support for metamask.

* launched rooch ethereum relayer and move ethereum light client prototype to synchronize ethereum block headers' timestamps to rooch

**BITCOIN SUPPORT**.

* rooch move framework now support bitcoin address mapping and bitcoin signature verification.

* provide schnorr signature validation in move

**Advanced Multi-chain Settlement Solutions**
* [Multi-chain settlement](https://rooch.network/docs/tech-highlights/multi-chain-settlement.en-us)

* [Multi-chain Settlement by L2-Myth or Reality](https://rooch.network/blog/multi-chain_settlement_by_layer2-myth_or_Reality.en-US)

**Move Standard Library, Framework and Virtual Machine**
* Enabled publishing Move modules in Move:
[account_storage::publish_modules_entry.](https://github.com/rooch-network/rooch/blob/7fd6418dff1aa7e40cae9e8eede375b776bbb771/moveos/moveos-stdlib/moveos-stdlib/sources/account_storage.move#L224)

* Implemented [Coin](https://github.com/rooch-network/rooch/blob/main/crates/rooch-framework/sources/coin.move), [Coinstore](https://github.com/rooch-network/rooch/blob/main/crates/rooch-framework/sources/coin_store.move), and [account_coin_store](https://github.com/rooch-network/rooch/blob/main/crates/rooch-framework/sources/account_coin_store.move). To further understand Rooch’s Coin standards, refer to [examples/coins](https://github.com/rooch-network/rooch/tree/main/examples/coins).

* Introduced Gas billing and Gastoken.

* Introduced [Event ](https://github.com/rooch-network/rooch/blob/main/moveos/moveos-stdlib/moveos-stdlib/sources/event.move)standards.

* Improved [Object ](https://rooch.network/docs/developer-guides/object.en-US)and [StorageAbstraction](https://rooch.network/docs/dive-into-rooch/storage-abstraction.en-US) designs.

**JSON RPC and SDK**

this version standardizes rpc api outputs and inputs, promising future rpc api compatibility.

* offered transaction query and traversal api: rooch_gettransactionsbyhash, rooch_gettransactionsbyorder.

* offered state query and traversal api: rooch_getstates, rooch_liststates.

* offered event traversal api: rooch_geteventsbyeventhandle.

* introduced balance query and traversal api: rooch_getbalance, rooch_getbalances.

* Released [Rooch typescript SDK](https://www.npmjs.com/package/@roochnetwork/sdk)

**Rooch Dashboard **

the rooch dashboard is a web application based on rooch json rpc, providing state and transaction queries, and account setting management features. more features will be added in the future. visit: https://dashboard.rooch.network/

**Developer Testnet**

Developer Network information:

1. Name: dev

2. ChainID: 20230103

3. RPC: https://dev-seed.rooch.network/

For Guidance on using the developer testnet, refer to: [Connecting to Developer Testnet ](https://rooch.network/docs/developer-guides/connect-devnet.en-US)

**NEXT STEPS**

rooch's primary objectives moving forward:

1. connect to the da chain, allowing rooch to initiate move applications' sovereign rollup.

2. launch the official testnet, providing a stable testing environment for developers to deploy apps and for users to try out.

3. achieve asset interoperability with ethereum, allowing users to deposit eth/erc20 assets into rooch.

4. realize data interoperability with bitcoin, enabling developers to process and verify bitcoin transactions on rooch using move

For more, stay tuned to : [Rooch v0.3 Roadmap](https://github.com/rooch-network/rooch/issues/1000)

**Rooch Milestones**
before the launch of the mainnet, rooch has five milestones. we have named these milestones via the stages of plant growth, aiming for rooch to grow from a seed to a towering tree, becoming the infrastructure for web3.

**seeding -- 2023 q1**
complete technical design and team formation.

**sprouting -- 2023 q2**
release the first preview version of rooch container, providing basic developer tools for building applications on rooch.

**rooting -- 2023 q3**
connect to different l1 public chains and da chains, providing support for multi-chain settlement. release a stable version of the move framework. run a public developer test network.

**branching -- 2023 q4**
collaborate with ecosystem teams to build frameworks and layer2 infrastructure, providing app-specific containers and storage solutions. run a permanent incentive test network.

**strengthening -- 2024 q1**
enhance security and optimize performance. run a pre-main network.

**foliage -- 2024 q1**
numerous applications thrive on the rooch network. run the mainnet.

**CONCLUSION**

rooch's milestones are driven by application scenarios, focusing on the experience of developers and users. the goal is to expand the boundaries of web3 applications and explore the possibilities of mass adoption. to learn more and try rooch, please refer to the [Getting Started](https://rooch.network/docs/getting-started.en-US)documentation. For more detailed information on Rooch v0.2, please enter to the [Rooch v0.2 release notes ](https://github.com/rooch-network/rooch/releases/tag/v0.2.1). We would like to thank the over ten developers who have contributed to rooch so far. if you want to learn more and get involved in rooch, please join the [Rooch Discord](https://discord.gg/rooch)

Original Link :https://rooch.network/blog/release-231018

Original Author : [JOLESTAR](https://twitter.com/jolestar)

2023 Oct. Rooch v0.2 release, launching developer testnet


This post is to delete!


Yesterday, the u.s. food and drug administration approved two milestone treatments, casgevy and lyfgenia, representing the first cell-based gene therapies for the treatment of sickle cell disease (scd) in patients 12 years and older. additionally, one of these therapies, casgevy, is the first fda-approved treatment to utilize a type of novel genome editing technology, signaling an innovative advancement in the field of gene therapy.

sickle cell disease is a group of inherited blood disorders affecting approximately 100,000 people in the u.s. it is most common in african americans and, while less prevalent, also affects hispanic americans. the primary problem in sickle cell disease is a mutation in hemoglobin, a protein found in red blood cells that delivers oxygen to the body’s tissues. this mutation causes red blood cells to develop a crescent or “sickle” shape. these sickled red blood cells restrict the flow in blood vessels and limit oxygen delivery to the body’s tissues, leading to severe pain and organ damage called vaso-occlusive events (voes) or vaso-occlusive crises (vocs). the recurrence of these events or crises can lead to life-threatening disabilities and/or early death.

“sickle cell disease is a rare, debilitating and life-threatening blood disorder with significant unmet need, and we are excited to advance the field especially for individuals whose lives have been severely disrupted by the disease by approving two cell-based gene therapies today,” said nicole verdun, m.d., director of the office of therapeutic products within the fda’s center for biologics evaluation and research. “gene therapy holds the promise of delivering more targeted and effective treatments, especially for individuals with rare diseases where the current treatment options are limited.”

casgevy, a cell-based gene therapy, is approved for the treatment of sickle cell disease in patients 12 years of age and older with recurrent vaso-occlusive crises. casgevy is the first fda-approved therapy utilizing crispr/cas9, a type of genome editing technology. patients’ hematopoietic (blood) stem cells are modified by genome editing using crispr/cas9 technology.

crispr/cas9 can be directed to cut dna in targeted areas, enabling the ability to accurately edit (remove, add, or replace) dna where it was cut. the modified blood stem cells are transplanted back into the patient where they engraft (attach and multiply) within the bone marrow and increase the production of fetal hemoglobin (hbf), a type of hemoglobin that facilitates oxygen delivery. in patients with sickle cell disease, increased levels of hbf prevent the sickling of red blood cells.

lyfgenia is a cell-based gene therapy. lyfgenia uses a lentiviral vector (gene delivery vehicle) for genetic modification and is approved for the treatment of patients 12 years of age and older with sickle cell disease and a history of vaso-occlusive events. with lyfgenia, the patient’s blood stem cells are genetically modified to produce hbat87q, a gene-therapy derived hemoglobin that functions similarly to hemoglobin a, which is the normal adult hemoglobin produced in persons not affected by sickle cell disease. red blood cells containing hbat87q have a lower risk of sickling and occluding blood flow. these modified stem cells are then delivered to the patient.

both products are made from the patients’ own blood stem cells, which are modified, and are given back as a one-time, single-dose infusion as part of a hematopoietic (blood) stem cell transplant. prior to treatment, a patients’ own stem cells are collected, and then the patient must undergo myeloablative conditioning (high-dose chemotherapy), a process that removes cells from the bone marrow so they can be replaced with the modified cells in casgevy and lyfgenia. patients who received casgevy or lyfgenia will be followed in a long-term study to evaluate each product’s safety and effectiveness.

“these approvals represent an important medical advance with the use of innovative cell-based gene therapies to target potentially devastating diseases and improve public health,” said peter marks, m.d., ph.d., director of the fda’s center for biologics evaluation and research. “today’s actions follow rigorous evaluations of the scientific and clinical data needed to support approval, reflecting the fda’s commitment to facilitating development of safe and effective treatments for conditions with severe impacts on human health.”

data supporting casgevy

the safety and effectiveness of casgevy were evaluated in an ongoing single-arm, multi-center trial in adult and adolescent patients with scd. patients had a history of at least two protocol-defined severe vocs during each of the two years prior to screening. the primary efficacy outcome was freedom from severe voc episodes for at least 12 consecutive months during the 24-month follow-up period. a total of 44 patients were treated with casgevy. of the 31 patients with sufficient follow-up time to be evaluable, 29 (93.5%) achieved this outcome. all treated patients achieved successful engraftment with no patients experiencing graft failure or graft rejection.

the most common side effects were low levels of platelets and white blood cells, mouth sores, nausea, musculoskeletal pain, abdominal pain, vomiting, febrile neutropenia (fever and low white blood cell count), headache and itching.

data supporting lyfgenia

the safety and effectiveness of lyfgenia is based on the analysis of data from a single-arm, 24-month multicenter study in patients with sickle cell disease and history of voes between the ages of 12- and 50- years old. effectiveness was evaluated based on complete resolution of voes (voe-cr) between 6 and 18 months after infusion with lyfgenia. twenty-eight (88%) of 32 patients achieved voe-cr during this time period.

the most common side effects included stomatitis (mouth sores of the lips, mouth, and throat), low levels of platelets, white blood cells, and red blood cells, and febrile neutropenia (fever and low white blood cell count), consistent with chemotherapy and underlying disease.

hematologic malignancy (blood cancer) has occurred in patients treated with lyfgenia. a black box warning is included in the label for lyfgenia with information regarding this risk. patients receiving this product should have lifelong monitoring for these malignancies.

the fda, an agency within the u.s. department of health and human services, protects the public health by assuring the safety, effectiveness, and security of human and veterinary drugs, vaccines and other biological products for human use, and medical devices. the agency also is responsible for the safety and security of our nation’s food supply, cosmetics, dietary supplements, radiation-emitting electronic products, and for regulating tobacco products.


["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

The global geek sports platform DoraHacks.io releases a new feature "Ideaism". This function is under the Idea section of the platform. Its artificial intelligence engine generates an entrepreneurial idea that solves a practical problem every minute and shares it with the community. Through ideation, DoraHacks will further encourage and accelerate the global community of hackers and open source developers to solve important problems and expand the scope of the global geek movement.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

2023 Oct. DoraHacks.io releases new feature "Ideaism"


My bookmarked articles on Yakihonne


Berlin, Germany, Aug. 22, 2023 (GLOBE NEWSWIRE) -- Chainflip Labs — the developer of the Chainflip protocol, a decentralised, trustless protocol that allows for seamless value transfer between any blockchain type — is working with OKX Web3 and DoraHacks in a further boost to the Chainflip ecosystem in advance of the protocol’s mainnet launch scheduled for Q4 2023.

As part of the OKX tie-up, the OKX Web3 wallet will be integrated into a front-end interface, enabling OKX Web3 users to connect seamlessly when swapping on Chainflip.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"!](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

The DoraHacks proposal will help to fuel the Chainflip ecosystem’s ongoing development. DoraHacks will reinvest proceeds from running validators back into the Chainflip ecosystem, to fund new projects and run hackathons in order to help continually improve the ecosystem.

The OKX Web3 and DoraHacks plans are the latest in a series of collaborations designed to add yet more functionality to the Chainflip experience. Squid, Axelar and OpenOcean are some of the names already joining forces to make cross-chain swaps more flexible, efficient and affordable for Web3 audiences.

Commenting on the tie-ups, Simon Harman, CEO and Founder of Chainflip Labs, highlighted how partnerships are a critical part of the protocol’s growth. “The support of such industry heavyweights as OKX Web3 and DoraHacks is a great boost to Chainflip as mainnet launch approaches in Q4,” said Simon.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"!](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

“Demand for cross-chain swaps is surging with Uniswap volumes regularly outpacing Coinbase and THORSwap volumes currently sitting at nine-month highs. Chainflip is bringing unique solutions to the market, and we’re excited for users to see for themselves how Chainflip’s infrastructure totally transforms the decentralised cross-chain swapping experience.

“There are plenty more integrations and collaborations in the pipeline to maximise the asset coverage available to users, liquidity in Chainflip pools and gas efficiency across chains, and leveraging these will be a central part of the protocol’s expansion.”

ABOUT CHAINFLIP

ChainFlip is a pioneering secure cross-chain AMM platform. Their Automated Market Maker allows users to swap native assets across any chains with extremely low slippage. Chainflip aims to become a network of networks, supporting increasingly specialised cross-chain liquidity
platforms at the most accessible rates.

[Exclusively authorized by DoraHacks, please indicate from when reprinting](www.yakihonne.com)

2023 Aug. DoraHacks continues partnership with OKX Web3 and Chainflip


Neo has announced the launch of the Polaris Launchpad’s Plus phase. Neo users will be able to vote for their favorite projects in the hackathon by using GAS in a quadratic voting mechanism. Community contributions will be matched by a Neo-allocated pool equal to US $101,300 in value.

Polaris Plus voting opened on June 8 on the DoraHacks website. The platform uses a quadratic funding mechanism implemented in an N3 smart contract to encourage a fair distribution of funds based on where the collective community finds value. Votes can be submitted until June 28, when community contributions will close and final results will be announced.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Quadratic funding is a voting approach that differs from typical “one-person-one-vote” or linear token payment voting models. The starting vote cost is 1 GAS. Users can vote any number of times and for any number of projects, but the cost of each extra vote for a given project is the vote number times the starting vote cost.

With a starting vote cost of 1 GAS, the second vote for the same project will cost 2 GAS, and the third will cost 3. The cost of three votes is therefore a total of 6 GAS.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

This increasing cost to a single “unit of influence” is designed to alter how users are incentivized to vote. It is better value for a contributor to place smaller numbers of votes across a greater number of projects.

After the community voting concludes, the contributions will be matched by a pool of GAS approximately $100,000 in value set aside by Neo. This system allows the Neo community to dictate distribution of funds from Neo for the Polaris projects.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

2022 Jun. Polaris Plus community voting goes live on DoraHacks


FOR IMMEDIATE RELEASE

SILICON VALLEY—May 24, 2022—O’Melveny represented DoraHacks, the world’s most active multi-chain Web3 developer incentive platform, in its US$20 million equity funding round.

The transaction was announced on May 18.

FTX Ventures and Liberty City Ventures led the funding round, joined by Circle Ventures, Gemini Frontier Fund, Sky9 Capital, Crypto.com Capital, and Amber Group.

With approximately 250,000 active users worldwide, DoraHacks is renowned for curating many of the world’s brightest Web3 startups via hackathons and grant programs. More than 2,000 startups and developer teams have raised US$25 million worth of grants from the DoraHacks platform. In addition, over 40 major Web3 ecosystems are currently using Dora infrastructures to fund their open source communities.

The O’Melveny team advising DoraHacks was led by M&A partner Wenting Yu, partner and Fintech Group Chair William K. Pao, and associate Thasos Athens.

About O’Melveny

It’s more than what you do: it’s how you do it. Across sectors and borders, in board rooms and courtrooms, we measure our success by yours. And in our interactions, we commit to making your O’Melveny experience as satisfying as the outcomes we help you achieve. Our greatest accomplishment is ensuring that you never have to choose between premier lawyering and exceptional service. So, tell us. What do you want to achieve? Visit us at www.omm.com, hear what our lawyers, staff, and clients have to say in Our DNA video series, or learn more in our firm at-a-glance, annual report, and on LinkedIn, Twitter, Facebook, Instagram, and YouTube. Visit The Boardroom for our insights on pressing issues facing global corporations.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

The global geek sports platform DoraHacks.io releases a new feature "Ideaism". This function is under the Idea section of the platform. Its artificial intelligence engine generates an entrepreneurial idea that solves a practical problem every minute and shares it with the community. Through ideation, DoraHacks will further encourage and accelerate the global community of hackers and open source developers to solve important problems and expand the scope of the global geek movement.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Singapore, May 18th, 2022 — DoraHacks, the global hacker movement and one of the most active Web3 developer incentive platforms, announced a $20 million Series B1 investment led by FTX Ventures and Liberty City Ventures. Circle Ventures, Gemini Frontier Fund, Sky9 Capital, Crypto.com Capital, and Amber Group joined the round.

According to the company, the funding will accelerate the launch of multiple cutting-edge initiatives, including Dora Grant DAO, a decentralized grant community powered by advanced governance technologies, and Dora Infinite Fund, a permanent venture funding disruptive ideas in frontier tech.

DoraHacks announced an $8 million strategic round last year, led by Binance Labs. Followed by the $20 million raise of Dora Factory, DoraHacks’ DAO-as-a-Service incubation, this additional funding brings the total amount invested in Dora core infrastructures over the past 18 months to nearly $50 million.

DoraHacks is most famous for curating many of the world’s brightest Web3 startups via hackathons and grant programs. Over 2000 startups and developer teams have raised $25 million worth of grants from the DoraHacks platform.

40+ Web3 ecosystems like Solana, Polygon, and Avalanche have adopted DoraHacks as a core partner in hackathons and community grant programs to access the global developer community.

DoraHacks has been driving critical research efforts in funding technology and decentralized governance infrastructures. After introducing quadratic voting and decentralized grants to multi-chain communities, DoraHacks has developed and implemented MACI (zero-knowledge, collusion-resistant voting) in ETHDenver 2022 and OpenSea hackathons.

“DoraHacks strives to provide the best infrastructure for open-source communities worldwide. Our mission is to create an everlasting hacker movement. With new strategic partners joining, we can better contribute to frontier tech’s startup community.” said Eric Zhang, founder of DoraHacks.

“Empowering multi-chain innovation has always been our mandate at FTX, ” said Adam Jin, Partner at FTX Ventures, “We believe DoraHacks will keep playing a crucial role in Web3, and FTX will work closely with the Dora team to support startup founders.”

DoraHacks launched Dora Grant DAO earlier this year. Having raised $5 million from 30+ partners, the company plans to provide grants to more post-hackathon-pre-investment stage projects. In addition, the company plans to set an evergreen venture, the Dora Infinite Fund, in motion via an NFT drop in 2022.

“DoraHacks is key to advancing the development of the infrastructure for Web3. At Liberty City Ventures, the focus has always been on groups building upon the promise of blockchain protocol and Web3 for real businesses and traditional industries. We expect increased engagement with our portfolio companies as the ecosystem grows.” said Emil Woods, Partner at Liberty City Ventures, Co-Founder of Paxos and Lukka, two blockchain unicorns.

Since late 2020, DoraHacks has invested in and incubated 20 projects, including DAO-as-a-Service Dora Factory, ZK infrastructure Zecrey, MOBA play-to-earn Thetan Arena, and Web3 tooling infrastructure ETHSign. DoraHacks is also the co-host of the Binance Labs incubation program.

“We’re excited to launch Dora Infinite Ventures. We will fund more frontier tech startups in Web3, quantum, and space. “So said Steve Ngok, Partner and Director of Business at DoraHacks.

About

DoraHacks is a global hacker movement and the world’s most active multi-chain Web3 developer incentive platform. More than 2000 projects from the DoraHacks community have received over $21.5 million in grants and hackathon prizes. DoraHacks.io has around 250,000 active users worldwide. The platform offers hackathons, bounty, quadratic funding, privacy voting, and other community governance/funding toolkits. In addition, over 40 major Web3 ecosystems are currently using Dora infrastructures to fund their open source communities.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

2022 May. O’Melveny Represents DoraHacks in US$20 Million Equity Funding


DESCRIPTION
【Details】

To jointly build BCH core development community and application developer community and maintain BCH.  DoraHacks&BCH find the best Hacker to start the 24 hours adventure journey. Use the most sophisticated block chain technology to develop the most intense brainstorming, and to use a convincing work to solve the latest and most urgent problems in all sectors of human society.
Global Recruitment
Global recruitment of top Hacker has the opportunity to engage in a battle with the best Hacker in the world.
 Recruitment Numbers
Only 100 Hacker admittance and then cycle screening. According to the order of registration, the title of the competition is continuously.  The 100 hackers who past the test will get the qualification.
Reward
You will have the opportunity to separate your own glory from the BCH prize pool equivalent to RMB 200000+, and the excellent Hacker can reimburse the round-trip fare.

【Rules】
Form of team:3-6 people.(team or on-site team)
Evaluation Criterion:
Practicality,Skill,Creativity.
24-Hour Increment
We are looking for:
Hackers who :
Understand the business model of the tokens economy and the blockchain;
Are familiar with the mainstream block chain source code;
Understand consensus protocol design.
Are application layer security and safety audit experts, such as wallets and smart contracts.
Understand blockchain protocol security and security audit experts.
Are IOS/Android/Web Development Engineer;
Blockchain engineer;
Products and UI designers

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

【Confirmed Judges include】
Fang Yuan
Dedao Chief Operating Officer
Fang Yuan once worked as fundamental operating officer in Cisco, Sina Weibo, and has spent over ten years developing back-end technology. Yuan is much experienced in communications, information, distributed storage and other fields. Among his various interest, Yuan mainly focuses on the application of coding languages, including Go/Java/Python, especially on the advanced application of cloud computing.

Tim Yang
Sina Weibo R&D Deputy Manager
Tim Yang has acquired much experience in software and Internet development. He joined Sina in 2008, when he was in charge of several large back-end system developments in communications. Since 2009 Time became the member of Sina Weibo technology operating team, who has witnessed the growth of Weibo from the start to a giant Internet system with millions of users. He mainly focuses on the core services of Weibo, including user relationship, comments, messages, open platforms etc.

Jiang Jiazhi
BCH Senior Developer
Community senior developer, Copermicus Project core developer, Bither Cold Wallet core developer. Jiang has a rich development experience of back-end technology and Internet over 10 years. He mainly focuses on the development of blockchain ground contracts, and high-performance system operation.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

【Topics】
BCH offers 6 topics on technical development
01
Micropayment
The characteristics of BCH, no borders, 0 confirmation, low fees, aiming to be the best currency in the world.
Content suggestion:
It can be a payment scenario, such as small-sum payments, cross-border payment business scenarios. At the same time, corresponding innovations on rapid payment are highly expected.

02
Smart contract scenario
Based on the payment system, certain smart contracts scenarios can be extended. Is more appropriate for UTXO models to do some stateless smart contracts.
Content suggestion:
(1) If we use oracle as a deposit, the system will make a scenario of automatic chargeback according to the result. More contract scenarios can be built as BCH opens up more opcodes.
(2) Newly opened opcodes can have some features of quiz games, without considering financial issues, atomic operations and smart contracts. Coins will be sent automatically based on the results. (Reference: https://github.com/fyookball/ChainBet)

03
Cross-chain business scenario
That is, based on the cross-chain implementation of the gateway, based on the value network and ecology of BCH, what kind of block chain can be built?
Content suggestion:
Atomic trading, or using BCH to call a contract directly. (Reference: https://www.rsk.co/)

04
Side chain
The use of a gateway in the sidechain to deliver the value of BCH. For example, RSK will also be implemented on the BCH soon.

05
Permanent storage of data
The opening of OP_RETURN allows data to be saved permanently, and even defines its own protocol, such as memo. These protocols and data are open.
Content suggestion:
What kind of applications will appear with permanent storage of data, open protocols and open data. (Reference: https://memo.cash/)

06
Big data analysis
There exists a lot of data, transactions, blocks, and nodes on the BCH network. If people handle well the data analysis and data visualization, it will be a global network.
Content suggestion:
Blockchain itself is a big data, on which people can do a lot of statistics, such as UTXO growth, statistics of mempool or address analysis. (Reference: https://blocks.wizb.it/)

【Schedule】
July 21 Saturday   09:30-10:30  Sign in, Networking
10:30-12:00  Openning Ceremony
12:30-13:30  Lunch Served
13:30-18:00  Pitching & Team Building then Hack!
18:00-19:00   Band Performance, Dinner
19:00-20:00   Hacking
20:00-21:00   Team Information collecting
21:00-24:00   Hack, Midnight Snack

July 22 Sunday    00:00-08:00  Overnight Hack(Or not)
08:00-08:30  Breakfast
08:45       Demo Submission Deadline
09:00-11:00  Demo fair, Voting
11:00-11:30  Closing Ceremony & Cash & Crypto Awards!
11:45-13:00  Group photo time

【FAQ】
What do I have to bring?
It's enough to take a computer and a charger. We pack you enough to eat and drink enough, and we will provide you with other Hack products.
Do I need to carry the equipment for the night?
We will provide a pillow, beanbag and sleeping bags. Of course, you can bring your used pillows, blankets and toiletries.
What is the cost of participating in the activities?
DoraHacks is completely free ，However, we need to receive a small deposit at the time of registration to confirm the entry list。Hackathon on the same day, we will refund all your deposit. Not only that, we will provide three meals a day, coffee, peripheral gifts and free Wi-Fi, so that you have the best Hack experience.
Is there a problem?
You can add naodongmao to WeChat. We will reply to you as soon as possible.

【About BCH&DoraHackers】
➤About BCH
BCH (Bitcoin Cash) is a B2B digital cash system. At 13h16 GMT on Tuesday 1 August 2017, the Bitcoin network forked and formed a new separate blockchain called BCH. Due to the recent scaling failure of the Bitcoin network, BCH has become one of the most useful form of money since it solves the problems of climbing fees and slow transaction speed. Nowadays, BCH is supported by 8 different developing teams and more exchanges are welcome to BCH.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

➤About DoraHacks
DoraHacksis a global hacker organization decentralized with the largest population of Hackers in China. In 2018 we’re branching out to global hubs including San Francisco, Paris, Tokyo, New York, Seoul, Boston, Berlin, Oslo and major cities in the world.
DoraHacks' mission is to connect the most talented hackers around the world to solve the greatest problems we face in different industries and to overcome practical issues from our diversiform society. In 2018, Hackers Fund was founded by DoraHacks and BA Capital. Since its founding, Hackers Fund has concentrate on supporting Hackers’ to explore better, prettier and more applicable solutions for current industries and future world.

➤About Hackathon
Hackathon is a technology that originated and became popular in innovative places like Silicon Valley in the US. In the 24-hour hackathon, you are free to solve any problem of your choice, or to participate in the prize-winning challenges.These challenges are provided by public chains which are supporting us during this event.

➤About Hackers Fund
Hackers Fund is a Venture Capital founded by DoraHacks and BA Capital. Since its founding, Hackers Fund has concentrate on supporting Hackers’ to explore better, prettier and more applicable solutions for current industries and future world. Outstanding hackteams once participated DoraHacks Hackathon and top hackers among Global Hacker Rank would be available to obtain investment and assistance from Hackers Fund.
Hackers Fund is recruiting project nodes and node partners. If you have interest and want to join, please send your CV to fund@dorahacks.com

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

2018 Jul. DORAHACKS X BCH GLOBAL TOP HACKERS HACKATHON


This vote will be deleted!


How to use proper risk management thread.

First i want to get a few things out of the way:
• There is no "best" way to do this.
• I will be explaining my experience and what works consistently for me.

Let's start!

There are a few steps that are, in my opinion, necessary to start off your trading adventure.

1. Define the portfolio size you will trade with.
2. Define your risk appetite.
3. What is your main trading style?
4. How do we determine position sizing?

Defining your portfolio size ✅

Personally, i found it very liberating to have my portfolio's split into a long term "hodl" portfolio and a trading portfolio.

I set aside some BTC at one point that is ONLY for trading and NOT for long term investing.

This way i don't have to worry about what my long term portfolio does while trading, since i don't plan on selling those positions anytime soon.

It's also easier to track your trading gains/losses within your trading portfolio if you don't have long term holds in the same portfolio.

Lastly, it is important to define how much you are willing to trade with. Let's say we trade with $1000 (0.085 BTC atm) for now.

Define your risk. ✅

It is important to define how much risk you're willing to take.

This means that if your trading portfolio is worth $1000, and you take 1% risk per trade, your risk in USD per trade will be 1000 * 0,01 = $10.

Or 0,085 * 0,01 = 0,00085 BTC per trade.

The risk percentage you take per trade is personal preference. I personally like using 1% as a standard and 2% when there is a strong trending market where it's usually easier to trade.

The higher the risk, the bigger the reward, but also the bigger the loss, obviously.

What is your main trading style? ✅

Your risk percentage can also be entirely dependent on the way you trade. If you're a scalper (Quick trades with tight SL's and big positions) you may do tens of trades A DAY.

If this is you, it might be smart to use a smaller risk %.

If, on the other hand you mostly do mid/longer term swing trades, you might be just fine with a higher risk percentage per trade. Since you don't take many trades and your SL is likely to be further out, therefore reducing the chance of many lost trades in quick succesion.

So how do we determine what position size we should take? ✅

You have to determine your entry, target and stop loss BEFORE buying into a position.

When you did so, you know the risk/reward ratio you're getting for that trade and if it's worth taking it.

Do you think the odds of your trade reaching it's target Vs hitting the stop loss is 50/50? But the target is twice as far away from your entry as your stop loss? (Risk/Reward Ratio of 2:1)

Then this will likely be a profitable trade in the long run.

To know what position size you should be taking i recommend using the "Long Position" and "Short Position" tools on Tradingview.

These can be found in your toolbar.

 When using these tools, you can enter exactly all the information we've just went through:

• Your account size (In BTC in the case of trading ETH/BTC)
• Your Risk Percentage
• Your Entry, Stop loss and Target.

You can also adjust these last three by moving the tool.

If you did all that, you get a nice overview of the risk/reward you get and the position sizing

First number being the difference from your entry to the current market price.

Second being the position sizing in ETH in this case. Being 0.34 ETH.

Third being the Risk/Reward.

In conclusion:

Using proper risk management helps you stay in the game. It saves you against inevitable loss streaks and reduces the drawdown your portfolio has immensely.

Find out what works well for you and stick with it if it's working.

I hope this has helped you and taught you the basics of risk management in case you were still struggling in this part of your trading.

Let me know if you have any questions and share this with others which you think this thread might be helpful for. 👍


I often use the term "Liquidity" in my analysis'.

I'll explain how it works and how I use it personally.

So what does "Liquidity" mean?

While all three definitions are obviously correct, the bottom one is most relevant for us.

The levels I map out are often important pivots  (reversal area's) with highs that haven't been touched in a while.

This means that there is most likely a lot of stop losses placed there. Because these are the most clear invalidation levels for most people.

In this case, price kept making lower highs so these highs are untouched.

We can likely conclude that above these highs, shorts have placed a lot of their stop losses.

That means that going ABOVE this level triggers these SL's and causes a lot of buying volume.

Why would we go to those levels?

This is because price often seems to search for liquidity.

If you would want to fill a lot of orders (into the hundreds of millions), it's easier to push price up into these area's where a lot of liquidity will be. Vice versa for longs.

If you'd for example push price up above these highs, you'd then see buying volume coming in from:

1. Short stops/liquidations being triggered.
2. Breakout traders buying the break of the previous lower high.

After that, either one of two things happen:

1. If the volume is very high, we often see a big short squeeze happening which can extend quite high and makes for a nice pump.

These short squeezes can cause a snowball-effect which makes price go higher at every break.

2. If the volume for continuation isn't there. Or price was deliberately pushed into these levels just to sell into the buying volume. We often see these highs taken out only to then reverse afterwards and end up in more downside.

We also call this a Swing Failure Pattern.

Whatever happens is very situational. For example when breaking the previous cycle's all time high at $20K. Price saw a huge short squeeze and never came back to even retest the level to this date. This was due to the huge amount of buying pressure on breaking that level.

Of course all of this can also happen in the opposite way.

Untouched lows? There's likely a lot of liquidity in terms of long position stop losses placed beneath there.

Expect selling pressure to come in whenever price clears that level.

I hope this cleared it all up a bit and gives you a good idea of how I work with these levels.

I think it gives you a good way to look at things from another perspective. Not seeing these levels as just as "A resistance or support". It's often a lot more than that.


EMURGO Ventures is part of a funding round joined by institutional investors Binance Labs, FTX Ventures, Circle Ventures, Gemini Frontier Fund, Crypto.com Capital, and Sky9 Capital.

SINGAPORE, Aug. 29, 2022 /PRNewswire/ -- EMURGO Ventures, the venture arm of EMURGO, one of the founding entities of Cardano blockchain, today announced an investment into DoraHacks, a global leading Web3 hackathon organizer and the world's most active multi-chain Web3 developer community with over 300,000 multi-chain developers and experts.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

As a founding entity of Cardano - the largest proof-of-stake blockchain by market cap with its community of over 3.8 million active ADA addresses - this funding will support EMURGO and DoraHacks to host global hackathons exclusively for Cardano's ecosystem and identify co-investment opportunities into high potential Web3 dApps displaying synergy with Cardano's blockchain via DoraFactory, DoraHacks' DAO-as-a-Service infrastructure which allows open-source projects to create decentralized autonomous organizations for their communities to govern and finance the projects.

DoraHacks' ecosystem aims to create the largest decentralized open-source Web3 developer community through its platform which hosts hackathons and decentralized funding mechanisms for its developer community as well as other known blockchain developer communities. DoraHacks has already funded over 2,000 startups and $25 million in grants and is also currently providing funding technology and decentralized governance infrastructure to 40+ Web3 ecosystems and their respective developer communities.

The global market for blockchain & Web3 VC funding surged from $3 billion in 2020 to more than $25 billion in 2021, a staggering growth of 713% and a clear indication of market acceptance for Web3 projects and a rapidly expanding pool of Web3 developer talent [1].

"EMURGO Ventures is thrilled to invest and partner with DoraHacks, a frontier tech leader in building and fostering a global Web3 developer community," said Kaimin Hu, Venture Partner at EMURGO Ventures. "We expect this investment to drive and scale Cardano's Web3 developer community through co-hosting hackathons, bring more funding and technological resources to Cardano's decentralized funding programs for Cardano devs, and ultimately accelerate Cardano's Web3 in the years to come."

"DoraHacks is pleased to team up with EMURGO Ventures to bring innovation to the Cardano ecosystem. This long-term partnership entails both parties to join forces on future hackathons, community grant programs, bounties, and curation of brilliant teams that will play crucial roles in the Cardano universe," said Steve Ngok, Partner at DoraHacks.

For exclusive interview requests, please refer to below.

For investment inquiries, please contact ventures@emurgo.io

About EMURGO Ventures
EMURGO Ventures is a wholly owned investment subsidiary of parent company EMURGO Ptd. Ltd. ("EMURGO") and invests in a variety of startups and middleware solutions companies to drive Cardano's Web3 adoption.

EMURGO has offices in Singapore, India, and Indonesia, the U.S., and a roster of global clients & partners. To connect and learn more, visit https://emurgo.io.

For interview requests and more information:
Albert Kim
Global PR Manager
+65-6978-5823
343411@email4pr.com

About DoraHacks
DoraHacks.io is a global hacker movement and the world's most active multi-chain Web3 developer incentive platform. More than 2500 projects from the DoraHacks community have received over $25 million in grants and hackathon prizes. DoraHacks.io has around 250,000 active users worldwide. The platform offers hackathons, bounty, quadratic funding, privacy voting, and other community governance/funding toolkits. In addition, over 40 major Web3 ecosystems are currently using Dora infrastructures to fund their open-source communities.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

EMURGO Ventures Invests in DoraHacks to Scale Cardano's Web3 Developer Pool and dApp Ecosystem


Participants of DoraHacks hackathons and grant programs will gain free access to Javelin, Validation Cloud's node API

ZUG, Switzerland and GEORGE TOWN, Cayman Islands, March 15, 2023 /PRNewswire/ -- Validation Cloud, a Web3 data streaming and infrastructure company, has announced a partnership with DoraHacks, a global leading hacker organization. As part of the partnership, developers participating in DoraHacks' hackathons, grant programs, and community events will have free access to Validation Cloud's Javelin, a high-performance global node API. This will enable developers to build their applications on leading networks such as Aptos, Ethereum, and Polygon.

"Validation Cloud is excited to partner with DoraHacks to provide developers with the best building experience on leading networks," said Michael Horowitz, CEO of Validation Cloud." Javelin's superior speed, scalability, and resilience will provide developers with the necessary tools to build Web3 applications with ease."

During the programs, all participants in DoraHacks' hackathons and grant programs will have access to Javelin, with winners receiving extended access to Validation Cloud's platform to continue building. Additionally, alumni of DoraHacks will be given preferred access to Validation Cloud's product suite.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Javelin's speed, scale, and resilience make it a major catalyst for next-generation Web3 applications, including full-stack zero-knowledge infrastructure, appchains, and faster blockchains. For developers, this means hyper-resilient connectivity, preventing network outages or unsustainable infrastructure. Further, Javelin's lightning-fast speed connects users to networks in just 20 milliseconds from anywhere in the world, eliminating a massive time burden for developers.

"DoraHacks is thrilled to include Validation Cloud as a hackathon and grant partner," added Steve Ngok, a partner at DoraHacks, "we believe access to Validation Cloud's best-in-breed API endpoints will offer an unprecedented experience to our developer community, enabling them to build even more creative, high-quality projects than ever before."

The partnership between Validation Cloud and DoraHacks is expected to provide a boost to the development of Web3 applications and drive innovation in the industry. Developers can connect to Javelin today at app.validationcloud.io and learn more about DoraHacks hackathons at dorahacks.io.

About Validation Cloud

Validation Cloud is a Web3 data streaming and infrastructure company that connects organizations into Web3 through a fast, scalable, and intelligent platform. Headquartered in Zug, Switzerland, Validation Cloud offers highly performant and customizable products in staking, node, and data-as-a-service. Learn more at Validationcloud.io | LinkedIn | Twitter  | Medium

Media Contact

Kelly Clark, Director of Communications, Validation Cloud | press@validationcloud.io

About DoraHacks

DoraHacks is a global hackathon organizer and one of the world's most active multi-chain Web3 developer platforms. It creates a global hacker movement and provides crypto native toolkits to help developers around the world team up and fund their ideas and BUIDLs via hackathons, bounties, grants, grant DAOs, and public good staking. By far, more than 4,000 projects from the DoraHacks community have received over $30 million in grants and other forms of contributions from supporters worldwide. A large number of open source communities, DAOs, and more than 40 major blockchain ecosystems are actively using Dora's infrastructure (DoraHacks.io) for open source funding and community governance.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

Validation Cloud Partners with DoraHacks to Provide Node API to Developers, Enabling New Web3 Applications


SINGAPORE and PALO ALTO, CA / ACCESSWIRE / January 12, 2023 / DoraHacks, a leading global hackathon organizer and open source incentive platform, and Cryptosat, which develops and launches crypto-satellites into space to enable novel cryptographic applications, announced today that they have successfully performed the first experiment to initiate a Zero-Knowledge (ZK) proof system in space.

This historic event took place on the International Space Station (ISS), an isolated platform in low Earth orbit where no human (except the seven astronauts currently aboard the station) and no hacker can physically access or modify the hardware running the experiment.

The experiment involved taking a set of pre-uploaded open source programs to the International Space Station, and outputting a file that contains the "Common Reference String." The Common Reference String is used in DoraHacks' Zero-Knowledge proof powered voting program that protects user privacy and offers collusion resistance in voting and governance.

The output of this experiment will be used to ensure security of the voting mechanism used in Dora Grant DAO, an open-community grant organization that supports multi-chain Web3 infrastructures and public goods. This paves the way for Cryptosat towards a satellite-based service that would enable a fast turnaround for initiation of ZK proof systems.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

"We are excited to unlock the possibility of running trusted setups for Zero-Knowledge schemes in space. The ability to perform a trusted setup in a completely isolated environment is key in making efficient SNARK schemes much more widely used, secure and easier to iterate on. By having Cryptosat participate in the ceremony, we guarantee there is at least one party out of this world making the ceremony more secure," said Cryptosat Co-founder Yonatan Winetraub.

Zero-knowledge proof systems, and SNARKs in particular, enable a vast range of possibilities, from rollups to collusion-resistant voting in DAOs. So far, the cryptographic ceremonies such as the "Powers of Tau" required to bootstrap a proof-system had either trust issues, or required bringing large numbers of participants which resulted in complex coordination with long turnaround times for commencing the ceremony.

Cryptosat's trusted compute environments in space provide the ultimate physical isolation and security, and will enable it to carry out instant cryptographic trusted-setups for ever-changing software. This experiment is a proof-of-concept that initiates cryptographic primitives in a space orbit, enabling DoraHacks to use the output Common Reference String in Zero-Knowledge proof powered applications.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

It's not without limitations, though. In its current state, the cryptographic scheme (called "Groth16") used in this experiment requires a new setup every time the voting program changes, so it works for only one application instead of general applications. Moreover, there are two steps of the trusted setup process, and this experiment only runs the second step. Its success opens up the gate for DoraHacks and Cryptosat to design further space missions to improve the process.

"Ultimately, we want to use an isolated computing environment in space to conduct a complete trusted setup for zero-knowledge proof applications, including an ‘in-space ceremony' that produces CRS for multiple proof systems, like PLONK. If we can achieve this goal, we can provide a public good for all zero-knowledge proof powered applications, as well as a new paradigm to initiate cryptographic protocols in general," said Eric Zhang, the Founder & CEO of DoraHacks.

The experiment was performed in collaboration with the Italy-based Nanoracks Europe exploiting the ICE Cubes Service in orbit.

About DoraHacks
DoraHacks is a global hackathon organizer and one of the world's most active multi-chain Web3 developer platforms. It creates a global hacker movement and provides crypto native toolkits to help developers around the world team up and fund their ideas and BUIDLs via hackathons, bounties, grants, grant DAOs, and public good staking. By far, more than 3000 projects from the DoraHacks community have received over $20 million in grants and other forms of contributions from supporters worldwide. A large number of open source communities, DAOs, and more than 40 major blockchain ecosystems are actively using Dora's infrastructure (DoraHacks.io) for open source funding and community governance.

["This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Media contact: Steve Ngok, Partner at DoraHacks, steve@dorahacks.com

For more information, visit: Website | Twitter | Discord

About Cryptosat
Cryptosat builds and launches satellites that power blockchain and cryptographic protocols. Satellites are physically inaccessible and can serve as the most secure root-of-trust that guarantees the confidentiality and integrity of sensitive computations and data. Such tamper-proof satellites can serve numerous use-cases including transaction signing, trusted setups for cryptographic schemes, a randomness oracle, time-oracle (VDF) and more.

Founded by Stanford PhD alumni and second time founders Yonatan Winetraub and Yan Michalevsky, Cryptosat's team has a background in aerospace engineering, applied security, and cryptography. In 2018, they published the SpaceTEE paper that first introduced the idea of using small satellites for protecting sensitive cryptographic operations and protocols. In May 2022, their first satellite, Crypto1, was launched into orbit. In March 2022, the team completed its first experiment onboard the International Space Station.

[Exclusively authorized by DoraHacks, please indicate from www.yakihonne.com when reprinting](yakihonne.com)

DoraHacks and Cryptosat Run the First Cryptographic Trusted-Setup for Zero-Knowledge in Space