atomicMatch for Opensea via etherscan?
Is it possible to complete an atomicMatch on Opensea via Etherscan?
Some of the argument inputs look like they are taking several arguments as one? For example it’s asking for "feeMethodsSidesKindsHowToCalls (uint8[8])" but this is feeMethods, Sides, Kinds, how would you format that?
I understand you can do this via the JS SDK and not need to put in the arguments in this same way, but I can’t get an API to test anything, OS are not responding to the request, which I gather is a common problem to have, and their generic test key on their docs won’t allow input of additional arguments. Talk about making things hard for us.
Use atomic matching for complex non-backtracking
You can sometimes improve the performance of your regular expression by preventing parts of it from backtracking when you know that might be useful. Item 38. Avoid unnecessary backtracking had many techniques for this, although it did not mention atomic matching (a feature added in v5.005).
An atomic match treats a subpattern as a single unit. That entire unit matches or it doesn’t and it doesn’t allow the regex engine to backtrack into it.
Consider a pattern that matches some text, some whitespace, and some more text, where I’m using the /x to spread out the pattern with insignificant whitespace ( Item 37. Make regular expressions readable. ):
Just looking at that, you can tell that the match will fail because there are no b characters in it. It takes awhile for the regex engine to figure out that.
- The pattern starts at the beginning of the string and matches the a
- After the a, the \s+ matches all of the tab characters.
- Next the pattern need to match a b. It doesn’t match that though.
When the b part fails, the engine backs up to the previous quantifier. In this example, it matched four characters, to the engine reduces that to matching three characters then tries again. That fails because the tab character is not a b. The quantifier give up another character, but the penultimate tab is also not a b. This continues until the quantifier cannot give up anything more since it has to match at least one tab.
The rxrx program from Regexp::Debugger helps you visualize this, with the caveat that it modifies your regex so it can probe it, so take that into account when rxrx reports these steps. It reports that it takes 33 steps before the regex engine gives up.
One way to get around this is to add the non-backtracking modifier to the + quantifier, making it the ++ :
This shaves off a few steps because the + quantifier doesn’t backtrack. It gives up everything it matched and starts again from the beginning of the pattern. The pattern moves over a character and tries the entire pattern again (a move that an anchor would solve, but that’s not the point here). This time it fails in 25 steps. Imagine all of these with much later patterns and many more tabs. The backtracking can be pathological.
Another way is the atomic match group, (?> . ) . This also prevents the regex engine from backtracking, although this time it fails in 30 steps:
But this is too simple for the atomic match because its grouping a single thing with a quantifier. It’s better when you want to group something that’s complex itself. Here’s a only-slightly less simple pattern that has two zero-or-more quantifiers, which fails very quickly:
The backtracking inside a sequence of zero-or-more constructs can quickly get out of hand. Imagine a target string with thousands of bs followed by thousands of cs, but with no d in the string:
The regex engine will backtrack repeatedly through those 2,000 characters.
Atomic match что это
Reddit and its partners use cookies and similar technologies to provide you with a better experience.
By accepting all cookies, you agree to our use of cookies to deliver and maintain our services and site, improve the quality of Reddit, personalize Reddit content and advertising, and measure the effectiveness of advertising.
By rejecting non-essential cookies, Reddit may still use certain cookies to ensure the proper functionality of our platform.
For more information, please see our Cookie Notice and our Privacy Policy .
Get the Reddit app
OpenSea is the first and largest NFT marketplace. Buy, sell, & create the world of NFTs: cryptoart, game items, domain names and more! Contact the mods if you'd like to do an AMA. OpenSea support will never DM you! Please open a support ticket if you need assistance: https://support.opensea.io/
A friend bought my NFT on OpenSea. Checking my ethereum address, there is no pending transaction in almost an hour later, and my friend's ethereum transaction says "Atomic Match_" under "method" in etherscan.io. What does this mean? Will the ethereum my friend spent for the NFT eventually appear in my MetaMask wallet? What does "Atomic Match_" mean?
I got an email from OpenSea saying my item has sold, but will the funds ever appear? It's been almost an hour since the transaction.
Econia has shipped
In Econia Labs’ inaugural post, “Setting the Stage for Econia: Markets, Computers, and Global Economics,” Econia was introduced within a global macroeconomic context. With humanity’s present financial system plagued by various organizational and technical inefficiencies, Econia represents an innovative solution to the outdated markets of the past. Built on decentralized technology and optimized for parallel execution, Econia leverages the underlying architecture of the Aptos blockchain to provide a set of crucial performance enhancements over earlier generations of decentralized exchanges (DEXs), ushering in a new era of unified global markets.
In particular, Econia is designed from the ground up around Aptos’ Block-STM execution engine, which uses optimistic concurrency methods to streamline transactional throughput. The result is a hyper-parallelized on-chain order book, enabling two key innovations that push performance to the extreme: paraqueues, and an atomic matching engine.
At first, of course, these two features were only theoretical possibilities, but as of this past Sunday, one is now a proven architecture — because Econia Labs just shipped the world’s first on-chain atomic matching engine to the Aptos devnet:
Here, atomicity refers to the compressed nature of Econia’s matching engine, which settles market orders in one execution step: when a user decides they want to buy or sell a digital asset at the best price offered by the market, Econia v1 matches their order against another market participant’s limit order (an ask or a bid), updates positions on the book, and routes assets between counterparties, all within a single transaction.
Compared with Serum, a leading on-chain order book protocol built on the pessimistic concurrency of the Solana blockchain, Econia’s atomic matching engine thus collapses a two-transaction process into a single transaction. Cutting in half the number of transactions previously required for an on-chain matching engine, Econia offers a performance enhancement that would not be possible without the optimistic concurrency of the Aptos blockchain. The result is a high-performance decentralized exchange with less overhead, more throughput, and less time waiting for trades to go through.
Moreover, Econia isolates different markets into separate regions of computer memory, achieving a condition known as non-overlapping state, so that orders can clear in parallel across separate markets:
Calling all builders
Econia’s v1 release is now live on the Aptos devnet, accompanied by comprehensive documentation at econia.dev, and an open-source code repository that has been public since inception. Armed with all of the tools necessary to integrate Econia into their decentralized finance (DeFi) protocols, several developer teams have already started building on top of Econia, and interest is growing each day. With a community-oriented Discord server designed to facilitate technical discussions, and a rapidly maturing Twitter profile geared toward product announcements and social engagement, Econia Labs is building up an unstoppable collaboration machine that will extend far beyond v1.
As developers across the Aptos ecosystem begin testing out Econia for themselves, discussions are already underway for Econia’s v2 feature set, with early adopters providing feedback on how to make the order book protocol integrate as seamlessly as possible with their respective products. Soon enough, there will be rich, user-facing front ends for a suite of applications, powered by a rapidly evolving back-end system that already has a breakthrough innovation at its core, Econia’s atomic matching engine.
The iterative build cycle has just begun, and after several iterations, once the community has converged on a set of core features, attention will then turn to performance optimizations, most notably in the form of paraqueues — Econia’s other major technical innovation. By horizontally scaling inputs to the atomic matching engine, paraqueues will further reduce bottlenecks on high-traffic markets, allowing multiple users to place orders at the same time, rather than forcing them to place orders one after another:
On top of the parallelism already offered across different markets, paraqueues will bring parallelism to each single market, railing performance to the extreme.
Build, ship, optimize, build, ship, optimize. That is what Econia Labs is here to do, and the economic engine of tomorrow is only getting started.