Showing preview only (951K chars total). Download the full file or copy to clipboard to get everything.
Repository: lens-protocol/momoka
Branch: master
Commit: b6e856ea7eb7
Files: 179
Total size: 892.2 KB
Directory structure:
gitextract_l8vcyy7p/
├── .github/
│ └── workflows/
│ └── dependency-review.yml
├── .gitignore
├── README.md
├── momoka-node/
│ ├── .dockerignore
│ ├── .eslintrc.js
│ ├── .nvmrc
│ ├── .prettierignore
│ ├── .prettierrc
│ ├── CHANGELOG.md
│ ├── Dockerfile
│ ├── Dockerfile.stable
│ ├── LICENSE.txt
│ ├── README.md
│ ├── client/
│ │ └── package.json
│ ├── codegen.yaml
│ ├── jest.config.js
│ ├── package.json
│ ├── playground-browser/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── config-overrides.js
│ │ ├── package.json
│ │ ├── public/
│ │ │ ├── index.html
│ │ │ ├── manifest.json
│ │ │ └── robots.txt
│ │ ├── src/
│ │ │ ├── App.css
│ │ │ ├── App.test.tsx
│ │ │ ├── App.tsx
│ │ │ ├── index.css
│ │ │ ├── index.tsx
│ │ │ ├── react-app-env.d.ts
│ │ │ ├── reportWebVitals.ts
│ │ │ └── setupTests.ts
│ │ └── tsconfig.json
│ ├── pnpm-workspace.yaml
│ ├── render.yaml
│ ├── src/
│ │ ├── __TESTS__/
│ │ │ ├── comment.e2e.test.ts
│ │ │ ├── config/
│ │ │ │ └── jest.setup.js
│ │ │ ├── db.test.ts
│ │ │ ├── mirror.e2e.test.ts
│ │ │ ├── mocks/
│ │ │ │ ├── comment/
│ │ │ │ │ ├── comment-created-delegate-arweave-response.mock.ts
│ │ │ │ │ └── comment-created-without-delegate-arweave-response.mock.ts
│ │ │ │ ├── mirror/
│ │ │ │ │ ├── mirror-created-delegate-comment-arweave-response.mock.ts
│ │ │ │ │ ├── mirror-created-delegate-post-arweave-response.mock.ts
│ │ │ │ │ ├── mirror-created-without-delegate-comment-arweave-response.mock.ts
│ │ │ │ │ └── mirror-created-without-delegate-post-arweave-response.mock.ts
│ │ │ │ ├── post/
│ │ │ │ │ ├── post-created-delegate-arweave-response.mock.ts
│ │ │ │ │ └── post-created-without-delegate-arweave-response.mock.ts
│ │ │ │ └── shared.mock.ts
│ │ │ ├── post.e2e.test.ts
│ │ │ ├── publications/
│ │ │ │ └── publication.base.test.ts
│ │ │ ├── random.test.ts
│ │ │ └── submitters.test.ts
│ │ ├── bin/
│ │ │ └── cli.ts
│ │ ├── client/
│ │ │ ├── axios-provider.ts
│ │ │ ├── check-da-proof-client.ts
│ │ │ ├── client-da-proof-gateway.ts
│ │ │ ├── client-da-proof-verifier.ts
│ │ │ └── index.ts
│ │ ├── common/
│ │ │ ├── environment.ts
│ │ │ ├── helpers.ts
│ │ │ ├── in-memory-store.ts
│ │ │ └── logger.ts
│ │ ├── data-availability-models/
│ │ │ ├── da-result.ts
│ │ │ ├── data-availability-action-types.ts
│ │ │ ├── data-availability-provider.ts
│ │ │ ├── data-availability-structure-base.ts
│ │ │ ├── data-availability-timestamp-proofs.ts
│ │ │ ├── data-availability-typed-data.ts
│ │ │ ├── publications/
│ │ │ │ ├── data-availability-publication-typed-data.ts
│ │ │ │ ├── data-availability-structure-publication.ts
│ │ │ │ └── data-availability-structure-publications-events.ts
│ │ │ └── validator-errors.ts
│ │ ├── evm/
│ │ │ ├── abi-types/
│ │ │ │ ├── LensHubV1.ts
│ │ │ │ ├── LensHubV1Events.ts
│ │ │ │ ├── LensHubV2.ts
│ │ │ │ └── LensHubV2Events.ts
│ │ │ ├── anvil.ts
│ │ │ ├── contract-lens/
│ │ │ │ ├── lens-hub-v1-contract-abi.ts
│ │ │ │ └── lens-hub-v2-contract-abi.ts
│ │ │ ├── ethereum.ts
│ │ │ ├── gateway/
│ │ │ │ ├── LensHubV1Gateway.ts
│ │ │ │ └── LensHubV2Gateway.ts
│ │ │ └── jsonrpc-methods.ts
│ │ ├── graphql/
│ │ │ ├── data-availability-transactions.graphql
│ │ │ ├── generated.ts
│ │ │ └── urql.client.ts
│ │ ├── index.ts
│ │ ├── input-output/
│ │ │ ├── arweave/
│ │ │ │ └── get-arweave-by-id.api.ts
│ │ │ ├── bundlr/
│ │ │ │ ├── bundlr-config.ts
│ │ │ │ ├── get-bundlr-bulk-txs.api.ts
│ │ │ │ ├── get-bundlr-by-id.api.ts
│ │ │ │ ├── get-data-availability-transactions.api.ts
│ │ │ │ └── get-owner-of-transaction.api.ts
│ │ │ ├── common.ts
│ │ │ ├── db.ts
│ │ │ ├── fetch-with-timeout.ts
│ │ │ ├── json-rpc-with-timeout.ts
│ │ │ ├── lib-curl-provider.ts
│ │ │ ├── paths.ts
│ │ │ ├── post-with-timeout.ts
│ │ │ └── tx-validated-results.ts
│ │ ├── proofs/
│ │ │ ├── check-da-proof.ts
│ │ │ ├── check-da-proofs-batch.ts
│ │ │ ├── da-proof-checker.ts
│ │ │ ├── da-proof-gateway.ts
│ │ │ ├── da-proof-verifier.ts
│ │ │ ├── models/
│ │ │ │ └── check-da-submisson-options.ts
│ │ │ ├── publications/
│ │ │ │ ├── comment/
│ │ │ │ │ ├── da-comment-verifier-v1.ts
│ │ │ │ │ ├── da-comment-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── create-da-publication-verifier.ts
│ │ │ │ ├── da-publication-verifier-v1.ts
│ │ │ │ ├── da-publication-verifier-v2.ts
│ │ │ │ ├── mirror/
│ │ │ │ │ ├── da-mirror-verifier-v1.ts
│ │ │ │ │ ├── da-mirror-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── post/
│ │ │ │ │ ├── da-post-verifier-v1.ts
│ │ │ │ │ ├── da-post-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── publication.base.ts
│ │ │ │ └── quote/
│ │ │ │ ├── da-quote-verifier-v2.ts
│ │ │ │ └── index.ts
│ │ │ └── utils.ts
│ │ ├── queue/
│ │ │ ├── base.queue.ts
│ │ │ ├── known.queue.ts
│ │ │ ├── process-failed-da-proof.queue.ts
│ │ │ ├── process-retry-check-da-proofs.queue.ts
│ │ │ └── startup.queue.ts
│ │ ├── runnable/
│ │ │ ├── da-verifier-node.runnable.ts
│ │ │ ├── ethereum-node-instance.ts
│ │ │ └── failed-submissons.runnable.ts
│ │ ├── submitters.ts
│ │ ├── utils/
│ │ │ ├── arrays-equal.ts
│ │ │ ├── invariant.ts
│ │ │ └── number-to-hex.ts
│ │ ├── watchers/
│ │ │ ├── failed-submissons.watcher.ts
│ │ │ ├── models/
│ │ │ │ ├── start-da-verifier-node-options.ts
│ │ │ │ └── stream.type.ts
│ │ │ ├── trusting-indexing.watcher.ts
│ │ │ └── verifier.watcher.ts
│ │ └── workers/
│ │ ├── handler-communication.worker.ts
│ │ ├── message-handlers/
│ │ │ ├── bundlr-verify-receipt.worker.ts
│ │ │ ├── evm-verify-message.worker.ts
│ │ │ └── index.ts
│ │ └── worker-pool.ts
│ └── tsconfig.json
└── momoka-rs/
├── Cargo.toml
├── README.md
└── src/
├── abi/
│ └── lens_hub_contract_abi.json
├── bundlr/
│ ├── api.rs
│ ├── mod.rs
│ └── verify.rs
├── cache.rs
├── contracts/
│ ├── lens_hub.rs
│ └── mod.rs
├── environment.rs
├── evm.rs
├── http.rs
├── logger.rs
├── main.rs
├── submitter/
│ ├── mod.rs
│ └── state.rs
├── types/
│ ├── chain_proofs.rs
│ ├── eip721.rs
│ ├── evm_event.rs
│ ├── hex.rs
│ ├── mod.rs
│ ├── profile_id.rs
│ ├── publication_id.rs
│ ├── transaction.rs
│ └── verifier_error.rs
├── utils.rs
└── verifier/
├── mod.rs
├── proof.rs
└── transactions/
├── comment.rs
├── common.rs
├── mirror.rs
├── mod.rs
└── post.rs
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/dependency-review.yml
================================================
name: Dependency Review
on:
- pull_request
permissions:
contents: read
pull-requests: write
jobs:
dependency-review:
runs-on: ubuntu-latest
steps:
- name: Checkout Repository
uses: actions/checkout@v5
- name: Dependency Review
uses: actions/dependency-review-action@v4
with:
comment-summary-in-pr: on-failure
fail-on-severity: moderate
license-check: false
================================================
FILE: .gitignore
================================================
momoka-node/node_modules
momoka-node/.env
momoka-node/coverage
momoka-node/coverage.json
momoka-node/lib/
momoka-node/database/*
momoka-node/da-verifier-database/*
.DS_Store
momoka-node/cache/*
momoka-node/src/__PLAYGROUND__/*
momoka-node/lens__da/*
.vscode
.idea
momoka-node/.env.test
momoka-rs/target/*
================================================
FILE: README.md
================================================
# Momoka
<img src="./images/logo.png" />
Not supported anymore but be our guest to fork.
## Disclaimer
We would like to emphasize that this project is currently in its beta phase and incorporates new, innovative technology. As with any cutting-edge solution, there may be potential challenges or undiscovered issues that could arise during its initial stages. We are committed to continually refining and improving our offering, and we appreciate your understanding and patience as we work diligently to perfect this technology. Please feel free to provide feedback or report any issues, as your input is invaluable in helping us enhance the user experience and overall functionality of our project.
# Momoka explorer
You can explore all momoka transactions on the explorer [here](https://momoka.lens.xyz). It is also open-source https://github.com/lens-protocol/momoka-explorer.
<img src="./images/momoka-explorer.jpg" />
# Momoka Verifier
The Momoka Verifier enables you to operate a trustless verifier node that validates LENS DA publications in real-time. Additionally, it can serve as an indexer, allowing you to stream and index the data yourself. This open-source solution relies exclusively on software that you can run independently, without any dependency on LENS. This ensures that even if LENS were to cease operation, you would retain access to your content, maintain proof of ownership, and continue to utilize it, all thanks to a decentralized data availability storage layer.
For information on how to run this software, please refer to the [Technical code and how to run a verifier](#technical-code-and-how-to-run-a-verifier) section.
## What is DA?
DA stands for Data Availability. It refers to the concept of storing data in a decentralized availability layer, which is more cost-effective than storing it on an EVM chain. The DA has no latency, meaning the data is produced and queryable instantly, in contrast to IPFS and EVM chains, which always have latency until they are considered complete. We utilize Arweave and Bundlr for this purpose. Arweave is a decentralized, permanent storage network with over 100 nodes in operation (as writing this documentation); it is being increasingly adopted by various NFT projects. Bundlr enhances Arweave's scalability while providing DA guarantees, enabling the use of EVM wallets to save DA logic and serving as a tool to rapidly push data to Arweave. DA can be used to store actions like posts, comments, mirrors, and more; initially, we are focusing on publications. The goal is to keep the DA layer affordable and scalable while still verifying transactions on Polygon using EVM simulations. DA requires a one-time payment for data storage and is backed by mathematical and hardware history guarantees.
Using this software, you can verify that a particular action would have been executed on-chain. The approach involves performing the same signing actions as you would on an EVM chain, but without actually sending the transaction (which consumes gas to store in the EVM state). Instead, you create a DA standard and save it on a DA layer, complete with proofs and all the required information. This enables ANYONE to cross-check the data, providing 100% proof that the action must have been performed by someone capable of creating the transaction signature and submitting it. This can be demonstrated by simulating the transaction. This approach allows LENS to scale while maintaining the core values of "ownership" and "trust" provided by the blockchain.
## Why do we need to use DA?
EVM can store state indefinitely, but at a cost; blockchains were designed for trustless transactional systems. EVM is secured by the network and mined into the chain; the data on-chain is immutable and verifiable at any time, ensuring trust. However, storing data on-chain is expensive, and EVM machines can only process a limited number of transactions per block based on maximum gas limits. Polygon is a shared block space; and at the moment has challenges scaling beyond 50-100 TPS. With 2-second block times, some latency is unavoidable, and max gas limits per block make scaling challenging, if not impossible. For context, Twitter experiences peak rates of 25,000 TPS; while LENS may not require this level of capacity yet, scalability is a critical consideration. This is where DA layers come in; they offer a more affordable solution for storing data with a one-time payment, backed by mathematical guarantees and a history of decreasing hardware costs over time. Moreover, these DA layers are decentralized, preserving this aspect of the system. DA enables scalability beyond 25,000 TPS, and even more; if we aim to revolutionize the world of core social ownership, we must be able to scale accordingly.
## What are transactions on EVM machines?
A transaction on an EVM machine alters some form of state; it is signed by the wallet's private key and then transmitted to the network. The network verifies the signature and executes the transaction, which contains logic that can either succeed or revert. If the transaction reverts, it is not included in the new block; if it succeeds, it is incorporated into the new block and confirmed by other miners. Miners are incentivized to perform these confirmations. This process ensures that transactions cannot be "faked," as they require a valid signature from a trusted key. Furthermore, a transaction can only succeed or revert—nothing more, nothing less. As the EVM progresses block by block and updates the state each time, it raises the question: what if you performed all steps of a transaction, except actually sending it, for actions that don't involve transferring funds or trustless executions?
## How can DA and EVM work together?
LENS is deployed on Polygon, an EVM-based platform. All actions—such as posts, comments, mirrors, follows, and collects are transactions that are built, signed, and sent to be stored on the EVM machine. In the new system, transactions are still built and require a signature from a wallet that would pass the state on-chain, but they are not actually sent. Instead, the transaction signature and typed data are used to create DA metadata, which is then transmitted to a DA layer containing information such as block number, signed typed data, transaction signature, and other crucial details. This data is structured in a way that can be fully verified with just having an archive node.
EVM machines function as large state machines. The EVM JSON-RPC methods allow you to simulate transactions using `eth_call`, determining the outcome of a transaction without actually sending it. You can specify a block number to run the simulation and use the signed typed data transaction with the typed data. This can be done with every `withSig` method on the LENS contracts. With just a Polygon node, anyone can verify that the data on the DA layer is accurate and would have been valid at that point in time. Since the typed data contains expiry times and nonces, it can be proven in a secure manner and can not be submitted by anyone else, edge cases around this are huge reorg ranges which we cover below.
The advantage of this approach is that the data is stored on a decentralized layer, meaning that no centralized entity controls the content. Users retain ownership of their publications, and if any part of LENS were to disappear, all the data would remain verifiable, accessible, and usable by anyone. This demonstrates the power of decentralization, ensuring that users' data cannot be taken away from them.
## What does this mean?
This approach allows LENS to scale to a lot higher TPS, which is currently unattainable with an EVM chain, while also providing a more cost-effective solution. This can be achieved without compromising the core ownership of the social graph, and the indexing process remains familiar for app developers. Using this system is optional; those who prefer can continue to store everything on Polygon. However, if a publication doesn't require the power of a trustless execution layer, there's no need to use the EVM state.
## Momoka vs polygon side by side
Here are diagrams that show how a transaction would look like on Polygon versus a transaction using the DA layer. These diagrams are meant to provide a simplified high-level overview of how the transactions work, while more detailed information is provided below with all the necessary technical details.
### Polygon
<img src="./images/current-polygon-flow.jpg" />
### Momoka
<img src="./images/momoka-flow.jpg" />
## Comparison
<img src="./images/tech-comparison.jpg" />
The reason momoka security is medium and not high is that in theory a submitter could refuse to process transactions from certain users even though validators could do this as well as we only have 1 for now the fix is more. As we increase more submitters this comes down, also the bad submitters could in theory flood the system without any slashing mechanism. This is a problem that will be solved in the future.
We'd like to emphasize that while using Momoka, you can enjoy the benefits of finality, scalability, and cost-effectiveness. However, there is a slight tradeoff in terms of security, especially until we have many verifiers and submitters in the network. This is similar to what would happen to Ethereum's security if it lost all its validators. It's a tradeoff we're willing to make for now during our beta phase. We firmly believe that the advantages of the DA outweigh the disadvantages, even though we cannot start fully decentralized. Nevertheless, we're committed to working towards that goal with momoka.
## Hyperscale
<img src="./images/hyperscale-for-data.jpg" />
## Momoka Submitters
To maintain trust, submitters must be held accountable for their actions and face potential penalties for misconduct. Initially, the submitter whitelist will consist of a single address owned by LENS. As the approach is proven, the system can be expanded to allow anyone to become a submitter, with incentives for good behavior and penalties for bad actors. If submitters have nothing to lose, they could flood the system with invalid submissions, overwhelming verifiers and causing delays. During the beta phase, LENS will be responsible for correcting any errors, with bug bounties planned for the post-beta period. Ultimately, the goal is to have multiple submitters contributing to the system. It's important to note that certain errors, such as `UNKNOWN`, `CAN_NOT_CONNECT_TO_BUNDLR`, `BLOCK_CANT_BE_READ_FROM_NODE`, `DATA_CANT_BE_READ_FROM_NODE`, and `SIMULATION_NODE_COULD_NOT_RUN`, `POTENTIAL_REORG` are related to third-party software issues and not considered critical verifier errors. The verifier will retry these errors later to see if they still pass. Over time, the entire system could become decentralized. For now, this beta approach represents the first attempt at scaling using a hybrid module model.
### Momoka Submitters' responsibilities
Submitters are responsible for validating, building up DA metadata, and submitting it to Arweave/Bundlr. After generating proofs with the DA submission, the data is uploaded to Arweave via Bundlr, with an instantaneous response. The submitter must provide proofs that anyone can contest. Verifier software listens for DA publications sent from whitelisted submitter addresses and verifies their validity.
### Momoka Submitter flow
The flow diagram shows the submitter flows in detail; the first submitter will be within the LENS API to allow for easy integration for all.
<img src="./images/submitter-flow.jpg" />
### Momoka Future of decentralised submitters
This is a rough look at how this could work in the future in a trustless manner. This is not the final solution but a rough idea of how it could work on a very high-level vision.
<img src="./images/decentralized-submitters.jpg" />
## Momoka Verifiers
Verifiers are tasked with monitoring DA publications from submitters and confirming their validity. They must follow specific criteria when evaluating incoming publications, with the primary goal of ensuring the submitter is truthful. Anyone can run a verifier using open-source software and a few commands. The verifier utilizes LevelDB for quick storage of passed results. The code has the capability to use a forked archive node with Foundry's `anvil` for local machine execution. However, for optimal speed, it is recommended to use an archive node directly (Alchemy is suggested but not required). All that's needed to run a verifier is an archive node.
## Momoka Current limitations with DA publications
- DA publications must use the `RevertCollectModule` and no `ReferenceModule`. This will be addressed in a future release.
- For now, DA comments can only be added to other DA publications; they cannot be mixed. This limitation will be explored after the v1 launch.
- DA mirrors can only mirror DA publications, not Polygon publications. This issue will be addressed post-v1 launch.
- While it's not possible to prove DA publications on other DA publications on Polygon (as they are not on-chain), it's still possible to verify the signatures and transactions as valid. However, simulations cannot be executed in this scenario.
- When verifying a submission, the pointer is checked as well. Only the first pointer is checked, not unlimited pointers, as the other verifications would have been done by the verifier.
## Compatibility with signature-free transactions
A top-class UX is essential for LENS users. DA publications work with the dispatcher, which can post, mirror, or comment on users' behalf. If enabled, this will pass state checks. The LENS contract logic states that if the dispatcher signs on behalf of the user, it will result in a valid transaction. Users who don't want to trust the dispatcher can still sign the typed data with their wallet and submit it through the submitter. This process is similar to the current flow, but the transaction is sent to a submitter instead of a Polygon node.
## Gasless transactions
DA operations don't require gas, making them free to use. The app still needs to upload the contentURI to a resolvable location, the submitter pays for storage of DA metadata on Arweave/Bundlr, which is significantly cheaper than EVM gas prices (up to 1000x cheaper).
## Timestamp proofs for picking the block number
You might be concerned that a submitter could deceive about which block to submit on, but that's where Bundlr timestamp proofs come into play. In addition, each signature has a deadline that corresponds to the timestamp of an already mined block, rendering the signature invalid if sent. Bundlr enables you to request a timestamp proof that returns the current timestamp while storing it, allowing anyone to verify that the time was generated by them. This becomes our source of truth for determining the appropriate block number to use; we should use the block number closest to the timestamp generated by Bundlr. It's important to note that latency will inevitably occur due to node software, so if it selects a block number and, upon verification, it is one behind, we consider this an acceptable threshold.
## Handling reorgs
A reorg on the EVM chain occurs when the blockchain structure changes, often due to a consensus failure or attack. This can lead to previously confirmed transactions becoming unconfirmed, and vice versa. It has significant security implications, making it crucial to be aware of the potential for reorgs and take measures to mitigate their impact. Developers at Polygon and other organizations working on EVM software are striving to reduce the frequency and depth of reorgs, making the issue less concerning. As a general precaution, waiting before considering a transaction final, much like how centralized exchanges operate, is the safest approach - the longer the wait, the lower the risk of a reorg affecting the transaction. In Momoka's first beta version, users cannot mix DA actions with EVM on-chain actions, which was implemented intentionally to simplify handling reorgs.
Currently, the validator doesn't recheck proofs once they are validated, as its primary objective is to validate as quickly as possible for the initial proof. However, as we start integrating DA actions with EVM on-chain actions, we will need to incorporate reorg handling and enable the verifier to recheck intelligently.
For now, any reorg handling or rechecking must be performed outside of the validator software. For example, the LENS API also monitors reorgs and re-validates proofs if a reorg affects any DA actions.
If a transaction is part of a reorg and ends up in a different block or not included at all, the proofs should be re-validated using the new blockchain state, ensuring their validity despite the reorg.
As we are not mixing and matching actions we remove a lot of the issues but not all, the edge cases that could cause issues are situations where for example someone sets a dispatcher and then straight away performs an DA action that has the dispatcher sign on their behalf, and then a reorg follows. If the transaction which adds the dispatcher to the profile is not resubmitted or is resubmitted at a higher block number, the proofs would fail. In that case, rerunning the proofs would return a `POTENTIAL_REORG` error which is not "bad" in terms of a submitter doing wrong as they could not of predicted it, you can handle this then as needed. Once we start integrating the cross actions, we will handle such cases within the validator.
A reorg of the blockchain can potentially affect the signing expiry of transactions. In the unlikely scenario of a severe reorg where time goes backwards on a block, it's conceivable that a transaction could be submitted to the chain that you never intended to. While this is a highly improbable edge case, it's essential to be aware of the possibility. As we embark on building the on-chain publications and DA publication connection, we'll delve deeper into these complex topics.
## Future of Momoka
As we said above this is very much in BETA and as we learn, shape and grow the solution we envision the architecture will end up looking something like this, with decentralised submitters and verifiers.
<img src="./images/momoka-network.jpg" />
## DA publication metadata
Momoka verifier supports both v1 and v2 publications.
We will show you a few examples of the `DA` metadata and then explain each field.
### Post v1 example
```js
{
signature:'0x87866d620636f62aa3930d8c48be37dac77f96f30a9e06748491934fef75e7884a193d59fc486da3ea35f991bbd37a04ea4997e47f191d626ad2b601e3cc57a71c',
dataAvailabilityId: '951a2a24-46fd-4306-8c31-46a8318a905e',
type: MomokaActionTypes.POST_CREATED,
timestampProofs: {
type: MomokaProvider.BUNDLR,
hashPrefix: '1',
response: {
id: 'f7_YMkEqiALN9PCtK5LXxFDlc3EEi20-DWl57KxDMbw',
timestamp: 1674736509185,
version: '1.0.0',
public:
'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature:
'Requv25_byuhK_k0JPz2tjKLhmqUv1XGt4My88utf8AHpl8awJKPMUQV3LJIQABMXf9ZsM2RZNiPhKEilkefGD-fTqkZZI5ybHooP8hc-lx2mAdM0XfCw-SC-yhdDU3OoOat7bwVy0HvOJm8xc6HpqgdbnTotX3LuPAo_xEV5GxrB5giK1IY8ZBJEsIjZw6okSzEStfmm94zAG44SmtTDXJk0IpeBpQiiZks63quZkPETGR9nfYl9-5D4UjQZHsx1eqV_9Pa4vYMOnTXD5LB8ysi2C576QjJAFICEZtRF2rXyZm1yfWBY8ODrnoZx-RBB5pqAwqrwA4DBI_UBHmbB7lL_3DK4911bZbC03T1KUw5QZn6eWjnoyxIv_UG9B3Bht0UDPIgGXA2tKeUsdrrh2JPAImZIYXEhC5ZWqn-K4TZa586sGwpQVfHFvCuCA-9X6GspXKDqlqbys6sZk70OOhM4827JIs9dw_Hw8rwsPsGIJjP99x2iOnyH8FQynbW8TCnGQcsO7Xevj-1PGnIAsXqQO6E9_NkYAf8LSfsilY63ZhVNPgLnSS2BAR-28SpHW4GjXtN_nVzE1CoLmL3nczMqHTiZ-xalo_enYg0Ydx-ZqHF7cPrB5rQmR_uB_7zPKK5WgStxwVjHRBJ8MLxmW0Sylzf9K6IwwFy50klQHY',
deadlineHeight: 1106524,
block: 1106524,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature:
'0xa3a969bd1ecdf7ca416340b513fd751df446b922809bd05f25509a98223b69594e4d0e5c27ce01111f80dd2df8ffd5f1af75bd6d663f55c4186ef773da2168ac1c',
signedByDelegate: false,
signatureDeadline: 1674736509,
typedData: {
types: {
PostWithSig: [
{
name: 'profileId',
type: 'uint256',
},
{
name: 'contentURI',
type: 'string',
},
{
name: 'collectModule',
type: 'address',
},
{
name: 'collectModuleInitData',
type: 'bytes',
},
{
name: 'referenceModule',
type: 'address',
},
{
name: 'referenceModuleInitData',
type: 'bytes',
},
{
name: 'nonce',
type: 'uint256',
},
{
name: 'deadline',
type: 'uint256',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '1',
chainId: 80001,
verifyingContract: '0x60Ae865ee4C725cd04353b5AAb364553f56ceF82',
},
value: {
profileId: '0x18',
contentURI: 'ar://NKrOBI6zMU4mnptAGYvirARSvBAU-nkCITQ5-LZkEco',
collectModule: '0x5E70fFD2C6D04d65C3abeBa64E93082cfA348dF8',
collectModuleInitData: '0x',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
nonce: 243,
deadline: 1674736509,
},
},
blockHash: '0x43f670549e740c8b2b7b56967b8a24a546b734c83e05ba20a515faddddc7c345',
blockNumber: 31429670,
blockTimestamp: 1674736509,
},
pointer: null,
},
publicationId: '0x18-0x3a-DA-951a2a24',
event: {
profileId: '0x18',
pubId: '0x3a',
contentURI: 'ar://NKrOBI6zMU4mnptAGYvirARSvBAU-nkCITQ5-LZkEco',
collectModule: '0x5E70fFD2C6D04d65C3abeBa64E93082cfA348dF8',
collectModuleReturnData: '0x',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleReturnData: '0x',
timestamp: 1674736509,
}
}
```
### Post v2 example
```js
{
signature: '0x255da3b710d96789ab4873919739fca75dbf439df42b6f4d46d25629910f6b561b3aba11533a46dc09cb577c65ecf1ac7d11cb7b5c12b002a2234ff0f7de01561b',
dataAvailabilityId: '43a4436d-a14f-4121-97ad-ba9f7ee43ae0',
type: 'POST_CREATED',
timestampProofs: {
type: 'BUNDLR',
hashPrefix: '1',
response: {
id: 'PIdmqKf3QKmFHkyATwEUSavyInNCFdZKL7RARgGRQoI',
timestamp: 1702891714460,
version: '1.0.0',
public: 'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature: 'Ab2bHqzPmgaVPZumC1la7N7xyH6KHYh017afzJn-dUDvVE-VenvpzBTO199BslAb0-hXj7TSRHy0GXW34qzxlich9pxqdQhgwjAy_whKPkTt2ZU7i89-9sm7FOEirkxYvpqo8c2rPHKmF0nkM1aMEKbYpXAxWJp-CCdMdBQDWzKrh2fhl9BNL8wTvPjDw5QHH-kCOXrnrptbO1KZrV3n30utnjMPhyoa2_Kgr96FgrFLvNfDNBoHoOcr_Nv4VHxPjkR3Ph70dFe_U4nzdSllJgyA12EgrAh2XIqZ4qnDBRxw5CBvY5XYoK0zvj-ikTotrFxUoazva6MoBJxlLEgpKbyF-ztEcvx8xQvFEqhGtJcQVmGvpR5RlGZdliozwt2N1VX9y8-NdGDPzfyhu9c_VBgzJQAThBvVDTNUcmHTygLipkc2YjYyD0I_etXRFhPtJqgY5Z9DSohAydqZ3IUSr-QoefLtypWe_DiJJleFGRliSpU5kgUqOaIH6D82iZctmYBS7oVsPkBp-37qjBHXB5u7t6gfpA9eWyJ-UCOoGpgy-I9YqhitSosMa24JgmTDIwx8Ab9AGhJcge-qpaXvNQbEwfMEHd5awMY4BRCLKm8kH8HBsHyWZllTrqLZzP25Lly-B3mM3NodybMTAXRyeca9uWqmlgZjrhE7cvy79Ns',
deadlineHeight: 1328843,
block: 1328843,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature: '0xf4c37eda3f8ea409b6fa51f53ff2db1fe778e9000e2ebc9e0bb9a5426f6617671194e5d4069c6c868dea9c6826173184b56d4730bd18dbbf3f7037f9e2dbbfc31c',
signedByDelegate: true,
signatureDeadline: 1702891712,
typedData: {
types: {
Post: [{
type: 'uint256',
name: 'profileId',
},
{
type: 'string',
name: 'contentURI',
},
{
type: 'address[]',
name: 'actionModules',
},
{
type: 'bytes[]',
name: 'actionModulesInitDatas',
},
{
type: 'address',
name: 'referenceModule',
},
{
type: 'bytes',
name: 'referenceModuleInitData',
},
{
type: 'uint256',
name: 'nonce',
},
{
type: 'uint256',
name: 'deadline',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '2',
chainId: 137,
verifyingContract: '0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d',
},
value: {
profileId: '0x010ba2',
contentURI: 'https://data.lens.phaver.com/api/lens/posts/09e32dc3-280c-41b6-84af-adfe00b1518b',
actionModules: [],
actionModulesInitDatas: [],
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
nonce: 0,
deadline: 1702891712,
},
},
blockHash: '0x345881b9a7e9450b0d7a6a393f7d0eeaab76c638ddf1b73911bd895d904acf0f',
blockNumber: 51266720,
blockTimestamp: 1702891712,
},
pointer: null,
},
publicationId: '0x010ba2-0x0753-DA-43a4436d',
event: {
postParams: {
profileId: '0x010ba2',
contentURI: 'https://data.lens.phaver.com/api/lens/posts/09e32dc3-280c-41b6-84af-adfe00b1518b',
actionModules: [],
actionModulesInitDatas: [],
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
},
pubId: '0x0753',
actionModulesInitReturnDatas: [],
referenceModuleInitReturnData: '0x',
transactionExecutor: '0xbb8d9991542baC0c77bF8f8E650CAb7B873c3C6D',
timestamp: 1702891712,
}
}
```
### Comment v1 example
```js
{
signature:
'0xcd9824d89bd3b237ed1230cf914630d756cae83904d835a1e85d37c11dbfab5e42c1f02042469ab29a3ccbd428c9a64576ad77f5876130b9c2bd49e0a83e9b7c1c',
dataAvailabilityId: '9a0b1d2b-e36e-48fc-87b4-b5f3f509b494',
type: MomokaActionTypes.COMMENT_CREATED,
timestampProofs: {
type: MomokaProvider.BUNDLR,
hashPrefix: '1',
response: {
id: 'xtVsUj5j1T4T86IQlJk2u-KubGD5oKIXOJQlU3KyGR0',
timestamp: 1674747795383,
version: '1.0.0',
public:
'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature:
'TZh1F7z14pbuHq7IBlHqnhT4PXEa2dQngiL-iHEXot3-w_ScVLyN9naCeuHvAP4mialS62YPucToy4o1UQlMEtTYS2i6C0rPap32xGi2yDA6AtzURf-xELI33em-mr9QIEuOph34t0yRLn3_Bl0n-AV4jyjVSgHdYjUT0vNZx3TbRkBi_v0PgJHDYkyezP_NrZgTomEe_VZmBgozc0J9zzK6atbIdsPnHYDbY3qzTujJEwogVQa311lNZvVe2ND6MR_0EUyVVW0esin6dyYEIPPCrjlFwMMgaoW4vBbGd1d11cRGopYgNvcX_0EuwAWYGwi8XW_GNGyrk4Df14VnOXAuP4NKd5oia820Be1vqwuAs3ubWX0OQ7CttOgohO9ns7CjYg9DVIwY5-AuJd2wAK6eI09fot-lTNVwtMVBvyxQ4GWaYspMcqkpysOY-5ow0wFp7K4Ad1FI4NO71cbEZQWD8ou08_A5Gd2a6qZF2fb7IJKka0aim26N858faf1nqViZfL-aym-AW60ydNav8inrTxVTMXml61WeG4KwlQXDrdoWkEquLB-1mJ-_519ozgy0QjSbyctp4LjpDpdp-yiJvzfweMFVRIKxarVB9Vvc0NFhyllE8sZud8zLBZ7wo7GG_1wijCJaICo-iD_FK97ZegnhotGLzeDC-KqY2vQ',
deadlineHeight: 1106619,
block: 1106619,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature:
'0x5156c7e636be61a305373df811d8444b7715448e2bde3fe69d388f301270d83d72796c5ef58283c1a9d32b37033a6b567a32addb78aedef0957fbf56956cd2351b',
signedByDelegate: false,
signatureDeadline: 1674747793,
typedData: {
types: {
CommentWithSig: [
{
name: 'profileId',
type: 'uint256',
},
{
name: 'contentURI',
type: 'string',
},
{
name: 'profileIdPointed',
type: 'uint256',
},
{
name: 'pubIdPointed',
type: 'uint256',
},
{
name: 'referenceModuleData',
type: 'bytes',
},
{
name: 'collectModule',
type: 'address',
},
{
name: 'collectModuleInitData',
type: 'bytes',
},
{
name: 'referenceModule',
type: 'address',
},
{
name: 'referenceModuleInitData',
type: 'bytes',
},
{
name: 'nonce',
type: 'uint256',
},
{
name: 'deadline',
type: 'uint256',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '1',
chainId: 80001,
verifyingContract: '0x60Ae865ee4C725cd04353b5AAb364553f56ceF82',
},
value: {
profileId: '0x18',
profileIdPointed: '0x18',
pubIdPointed: '0x3a',
contentURI: 'ar://5JNO_BIyW7sD8crn1PPt3SrCZUKF9t-f8Rs13Zh1w1Q',
referenceModule: '0x0000000000000000000000000000000000000000',
collectModule: '0x5E70fFD2C6D04d65C3abeBa64E93082cfA348dF8',
collectModuleInitData: '0x',
referenceModuleInitData: '0x',
referenceModuleData: '0x',
nonce: 243,
deadline: 1674747793,
},
},
blockHash: '0x11b2e5b1b7fa87c3a30d10d6f0416f5cb540c30ac7ae4b1be5058d9b5031e172',
blockNumber: 31434975,
blockTimestamp: 1674747793,
},
pointer: {
location: 'ar://TEoFkgD0m-LLQkfViuCTKfCLK_xpSxzPUNoMjBLnvlI',
type: DAPublicationPointerType.ON_DA,
},
},
publicationId: '0x18-0x3a-DA-9a0b1d2b',
event: {
profileId: '0x18',
pubId: '0x3a',
contentURI: 'ar://5JNO_BIyW7sD8crn1PPt3SrCZUKF9t-f8Rs13Zh1w1Q',
profileIdPointed: '0x18',
pubIdPointed: '0x3a',
referenceModuleData: '0x',
collectModule: '0x5E70fFD2C6D04d65C3abeBa64E93082cfA348dF8',
collectModuleReturnData: '0x',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleReturnData: '0x',
timestamp: 1674747793,
}
}
```
### Comment v2 example
```js
{
signature: '0x6e0e55679ca0b42dcb8fd82f8c5837088785c41de23ee3932577f5322741ebe72bc7af941aa775c86b1738ba36c904a4768806794443d9900c5274c7d156ac3c1c',
dataAvailabilityId: '78851796-9590-4822-97de-ceb265510b5d',
type: 'COMMENT_CREATED',
timestampProofs: {
type: 'BUNDLR',
hashPrefix: '1',
response: {
id: 'RQ8mCXnYCluZIop4Lw5oEkEGiZo3QnxJX0vJtHY0pN8',
timestamp: 1702891713472,
version: '1.0.0',
public: 'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature: 'U-EnE5GqBWl9FRhckT8NO5ESjoSoGPVyysZMEKB6cciWc-3YsOUm1syC-JjKNZHqk5FhlDOChs6vpzBWFksxTxXL_dGeifWN1Vd3Adc-lPueHWsY4wi00AZPb9fkHZAJ1PTZyzNvO0sCtfIUF1KYsCU75Vq_-Eul0lfCgaHjbO91EYFeGiJmBgtqcFmCaABEcIPCgqo3B8FnzXei5FopqXaa8yEDe6mcA146SatnNRX5GB0QH7g7PFEkExizcOcKc9ELSuja84np41ouEyoInhTOVHipcuSASRTf20NgUHtZwImQF33YcjXpX9PPFVecxdslrqA83O_K0R6Y-J0mZb0ZRMdQ85DC6febn6LaMGn1-OagAisuALFrGyGcdH-1gagdsGQ9K86vE0T8n0PZapqB81qDSz7sPpGik-uqdXXJT1fGXYJzHy7QcnzLkt8RAADEmwaJfdzxECr-OpqkRxLovVuDB6C29ZrsVaXQ4iDx8FKbLjUbHrYFsOnRTLKi4b3Q-ImjvVNKm2Jur-cx3NSsC2zhdH-MWiR8D7bfVALNayU6QC0IeXGo_S0di70AqaFsjGwjv9hFIRhzxNnhR2VBGWCIuh9cD_icfabB1c6xKDaYLM4gim6q9foksHQ4bz7CEya40yKq8K2O18pA-MwLSDAzCNjj96FF-NBqeuo',
deadlineHeight: 1328843,
block: 1328843,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature: '0x5965cb73b4437e31820fc3e62fadc96b0fe885da77131b14e9d5265b1aee9cbf128dd60e36e9798640ee81c04d908d03b0d11d2114687b545bc778adba05ca1f1b',
signedByDelegate: true,
signatureDeadline: 1702891712,
typedData: {
types: {
Comment: [{
type: 'uint256',
name: 'profileId',
},
{
type: 'string',
name: 'contentURI',
},
{
type: 'uint256',
name: 'pointedProfileId',
},
{
type: 'uint256',
name: 'pointedPubId',
},
{
type: 'uint256[]',
name: 'referrerProfileIds',
},
{
type: 'uint256[]',
name: 'referrerPubIds',
},
{
type: 'bytes',
name: 'referenceModuleData',
},
{
type: 'address[]',
name: 'actionModules',
},
{
type: 'bytes[]',
name: 'actionModulesInitDatas',
},
{
type: 'address',
name: 'referenceModule',
},
{
type: 'bytes',
name: 'referenceModuleInitData',
},
{
type: 'uint256',
name: 'nonce',
},
{
type: 'uint256',
name: 'deadline',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '2',
chainId: 137,
verifyingContract: '0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d',
},
value: {
actionModules: [],
actionModulesInitDatas: [],
contentURI: 'https://data.lens.phaver.com/api/lens/comments/28a020f6-d3ed-40e9-86ae-9fd65e0ff762',
deadline: 1702891712,
nonce: 0,
pointedProfileId: '0x01e949',
pointedPubId: '0x02',
profileId: '0x8780',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleData: '0x',
referenceModuleInitData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
},
},
blockHash: '0x345881b9a7e9450b0d7a6a393f7d0eeaab76c638ddf1b73911bd895d904acf0f',
blockNumber: 51266720,
blockTimestamp: 1702891712,
},
pointer: {
location: 'ar://KsFdzdb71cxbBCvO_yUpTAZylNjdjVXXHTl1RU0Kv_k',
type: 'ON_DA',
},
},
publicationId: '0x8780-0x0187-DA-78851796',
event: {
commentParams: {
profileId: '0x8780',
contentURI: 'https://data.lens.phaver.com/api/lens/comments/28a020f6-d3ed-40e9-86ae-9fd65e0ff762',
actionModules: [],
actionModulesInitDatas: [],
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
referenceModuleData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
pointedProfileId: '0x01e949',
pointedPubId: '0x02',
},
pubId: '0x0187',
actionModulesInitReturnDatas: [],
referenceModuleReturnData: '0x',
referenceModuleInitReturnData: '0x',
transactionExecutor: '0x6FB0974523bE06231516Ee7CCEdad7e1897e8942',
timestamp: 1702891712,
}
}
```
### Mirror v1 example
```js
{
signature:
'0x1683ef107f09a291ebbe8f4bfc4f628ff9be10f661d0d18048c31a8b1ca981d948ef12c591e5d762e952bc287e57838b031a6451f2b8a58cfc5cedb565c742661b',
dataAvailabilityId: '538ca9c4-682b-41d2-9b8a-52ede43728d7',
type: MomokaActionTypes.MIRROR_CREATED,
timestampProofs: {
type: MomokaProvider.BUNDLR,
hashPrefix: '1',
response: {
id: 'zdkCXuVzawg3KipWCRVK2fo-yIUoj5IMuIYyFPGA55o',
timestamp: 1674748125246,
version: '1.0.0',
public:
'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature:
'IJjhzO0D4ioq9Gc0mghnxvOIkrZdmrqkc_UpMkL9R-qulzvkZ_LY4QRQxP-rNAm-ZIoN3Jep9zefjTaRRvU6mhc6hKZaMWC4XvWW_IXl5TZH1eOfq0JENjoRoZ75IdwicJXtc9c7obeNs84hXqlNHJXUoQfC2mEjkqiRpK_Vz43Hxn-3ZkrNvNEM1cpbl5hJU3UP0iCQnJQPiTgiojnhTBgRoIEpLQBFdoF1IRXUH4J4TBCMoX5MzG5PUj_FJkJiYX_SM0iaiDi0y-6-IsvOu1o32UWVgmDa-PbTrd6kGuDdd3Ys4HHyjGbS4NGkbu-coMW7RdkCegowgrXvzDoVxG0pVKoMK7ndOfZJJlud3jonqcDDI0vESSVdt_DDMOjkqdHiyWdVWcDlS0TnToIdwuOgaHDgpoqFjPUd5GwE40QFix6QflbxfcFqleru9eDY4_hufxMYEWK3DiSN6QIe6jQg6-9ZLFvD4Chr_bxL48UkfwDx-Y7EZo5tb6uzwzEqAfXEb5ITyzVrEgo1sXEDKKkkNQ7C5Hq2mryWKRXHUtXkKErI1P_bNRp2GXumO30uwZfpsMcAtFPCsPMnm1j4aqhFjcpVk9HpFPa6DcCuX6U8T3MODbJbNPxFc_Pdt5wcLo6EcLEnnQTIvQEIj_aQvh__rh79d6XHckI1TL-9gAM',
deadlineHeight: 1106621,
block: 1106621,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature:
'0x59cb0d34ef20e93e4073cadec0d05eb8ef9a6af4b55d7ddea099666f83509d193e554c4149856ddb36ac3a4601c7f4e12fc413e016b6d4b314846eb3222b2e9b1b',
signedByDelegate: false,
signatureDeadline: 1674748123,
typedData: {
domain: {
name: 'Lens Protocol Profiles',
version: '1',
chainId: 80001,
verifyingContract: '0x60Ae865ee4C725cd04353b5AAb364553f56ceF82',
},
types: {
MirrorWithSig: [
{
name: 'profileId',
type: 'uint256',
},
{
name: 'profileIdPointed',
type: 'uint256',
},
{
name: 'pubIdPointed',
type: 'uint256',
},
{
name: 'referenceModuleData',
type: 'bytes',
},
{
name: 'referenceModule',
type: 'address',
},
{
name: 'referenceModuleInitData',
type: 'bytes',
},
{
name: 'nonce',
type: 'uint256',
},
{
name: 'deadline',
type: 'uint256',
},
],
},
value: {
profileId: '0x18',
profileIdPointed: '0x18',
pubIdPointed: '0x3a',
referenceModuleData: '0x',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
deadline: 1674748123,
nonce: 243,
},
},
blockHash: '0x0fb258841acaf93b998028bfc7296b840a80cdc76ffd999d5101bc72cf2daf78',
blockNumber: 31435129,
blockTimestamp: 1674748123,
},
pointer: {
location: 'ar://ff9CtLecXt1HBFBR-SoRz8tLjPjBo8gxbmy7kmFpJl4',
type: DAPublicationPointerType.ON_DA,
},
},
publicationId: '0x18-0x3a-DA-538ca9c4',
event: {
profileId: '0x18',
pubId: '0x3a',
profileIdPointed: '0x18',
pubIdPointed: '0x3a',
referenceModuleData: '0x',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleReturnData: '0x',
timestamp: 1674748123,
}
}
```
### Mirror v2 example
```js
{
signature: '0x4c0a44fe4b176994c8f08b1140925dc798d964924d8ef0ee2ef106ee7becfc16106a6291b2a8c5348df434a61f776c7426cce72827a997db2cad6e689f889af81b',
dataAvailabilityId: '07e11c4b-f941-41fa-886e-0ce80abe5ee6',
type: 'MIRROR_CREATED',
timestampProofs: {
type: 'BUNDLR',
hashPrefix: '1',
response: {
id: 'z6xdw5Z6etMF11TubShsFlcY-sVgyJDFwfnka7aZdwo',
timestamp: 1702891817115,
version: '1.0.0',
public: 'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature: 'oaiXw1bYhNKnc7yDocvm6C0MCesIOLKDpBwxgDqvoLZsqA9JXuk1XZ44iQjvFYzGwAhkJWkwq1TV4NhKRaeZV3NK_IA54DSWikze1PiJ2ag7O9fvyO_NIdZNeFOoQLuKuh1ZxueaccttO0KGCxXgWBY4YGW1i-UttXDmVr9RxaQQJ_ul-vFSdjnACm8S8OzxXrc5kHRujxjnzFpcQtOD4YgWvKJ6kRgyxQIxL62bDc-Ubjwr-3Upz0wEvI2nfPlvDpZfpJVaLuSD_qd7k26ZgQjMfWKhXXVyyuszS8MElWB42YkOZQnJKPeMEdAQPrpbz3wjqNOv3uP_Y57RAIFYw1ZQIQz0cNw_L_apCuFJS5Hbv7slMkyC-6AOnZVGVsbjv0Wsk7KPWj3-UMACndw25ta2nOWewt1ubHRqvY9pWpTh0O6Y5oeCxy2H4sDw8QLMlkPC6tU4q5L_TjAkBp-SXt6wx6M8C1Ra9hLe0uN4xPG8rZdsSQEm5ueyHLV6tLiIEqsq2Vj5chJuycLHRqIqPEkeptKA4aR-JHmLn_4d2qLniDMun1n_oTjVBgypHOYvBAuPWFN4CrBHu6V8e6rf1UqSS_UB720z2NQhlZxUwbf5jjLzeAgap2v-Il9AMhH7Gleh3cQrrmM1NLr0yihR7PiCKROTFK4cqldDyi7r7Mk',
deadlineHeight: 1328843,
block: 1328843,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature: '0xc83854f2711e805a6cd761a50436a45d2ecde7ae37d4e96dd624bd44cb4daf434c7456cb90f2a5be5913f68cd9b40c3997f5aa1c676b903a3ea7c2590d24852a1b',
signedByDelegate: true,
signatureDeadline: 1702891816,
typedData: {
types: {
Mirror: [{
type: 'uint256',
name: 'profileId',
},
{
type: 'string',
name: 'metadataURI',
},
{
type: 'uint256',
name: 'pointedProfileId',
},
{
type: 'uint256',
name: 'pointedPubId',
},
{
type: 'uint256[]',
name: 'referrerProfileIds',
},
{
type: 'uint256[]',
name: 'referrerPubIds',
},
{
type: 'bytes',
name: 'referenceModuleData',
},
{
type: 'uint256',
name: 'nonce',
},
{
type: 'uint256',
name: 'deadline',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '2',
chainId: 137,
verifyingContract: '0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d',
},
value: {
deadline: 1702891816,
metadataURI: '',
nonce: 0,
pointedProfileId: '0x01dd85',
pointedPubId: '0x010d',
profileId: '0x73b1',
referenceModuleData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
},
},
blockHash: '0xf55674ae4a179088bcbe0aa7ac340a42098fc6ed8a941d38294585408b062c69',
blockNumber: 51266755,
blockTimestamp: 1702891816,
},
pointer: {
location: 'ar://FnKDUBDZTGiwDR3X8isbLxMyII93jDSbLDXdiG1jElU',
type: 'ON_DA',
},
},
publicationId: '0x73b1-0x44d6-DA-07e11c4b',
event: {
mirrorParams: {
profileId: '0x73b1',
metadataURI: '',
referenceModuleData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
pointedProfileId: '0x01dd85',
pointedPubId: '0x010d',
},
pubId: '0x44d6',
referenceModuleReturnData: '0x',
transactionExecutor: '0x3D5e9077ef8F9C6B0e10D6c62C1A022a49675Cc3',
timestamp: 1702891816,
},
}
```
### Quote v1 metadata
Quote was not supported in v1.
### Quote v2 metadata
```js
{
signature: '0x1509b8efdaa96410fc975eaaa0f2f2cf587440c5fe6c08212d7ee2f3812adab018be0d29f4913f21f797b58b25d98e5c0b2f7aa517bade28de07c1a119a361dc1c',
dataAvailabilityId: 'ff75b024-8d38-4265-bfb6-75de3594696c',
type: 'QUOTE_CREATED',
timestampProofs: {
type: 'BUNDLR',
hashPrefix: '1',
response: {
id: '_s1fhwtNOc0rHtXuW5H1gybe3yKveNcDzDSqvRyHF2s',
timestamp: 1702892441416,
version: '1.0.0',
public: 'sq9JbppKLlAKtQwalfX5DagnGMlTirditXk7y4jgoeA7DEM0Z6cVPE5xMQ9kz_T9VppP6BFHtHyZCZODercEVWipzkr36tfQkR5EDGUQyLivdxUzbWgVkzw7D27PJEa4cd1Uy6r18rYLqERgbRvAZph5YJZmpSJk7r3MwnQquuktjvSpfCLFwSxP1w879-ss_JalM9ICzRi38henONio8gll6GV9-omrWwRMZer_15bspCK5txCwpY137nfKwKD5YBAuzxxcj424M7zlSHlsafBwaRwFbf8gHtW03iJER4lR4GxeY0WvnYaB3KDISHQp53a9nlbmiWO5WcHHYsR83OT2eJ0Pl3RWA-_imk_SNwGQTCjmA6tf_UVwL8HzYS2iyuu85b7iYK9ZQoh8nqbNC6qibICE4h9Fe3bN7AgitIe9XzCTOXDfMr4ahjC8kkqJ1z4zNAI6-Leei_Mgd8JtZh2vqFNZhXK0lSadFl_9Oh3AET7tUds2E7s-6zpRPd9oBZu6-kNuHDRJ6TQhZSwJ9ZO5HYsccb_G_1so72aXJymR9ggJgWr4J3bawAYYnqmvmzGklYOlE_5HVnMxf-UxpT7ztdsHbc9QEH6W2bzwxbpjTczEZs3JCCB3c-NewNHsj9PYM3b5tTlTNP9kNAwPZHWpt11t79LuNkNGt9LfOek',
signature: 'INzP87eVTYwFRZ7ujA2P9bhw87oA9TzDdOgofAxT1Nn1pQkcRlgEgNT36o0HzGCPhOszxJb74NZwNS-gFA7pKxf0DwJsPF-a3uL_hodhQXoJTsazxdl8sE5Y5bIa5R4jm2AvU_g9YDAnL9v4y7dYADhn997ozEniEt5ChVa4bxvMFQ5-cFx4tLDHQniSf-VNrUPoAFrVintbyoPCVDj_djDU2rOcfE86WNKiNg71pTBLGrJmF5xRVAbSKCDTlwzgJeIqID-IrhhcSHC2TdUXG2uBXhkt0GDsKJISuzeuFlH-atfEqqLyJcbkxWixuvJ5EpwzvNDnWq7-lFCi-yM_UbxRwwJqWgZK9abxk0Fa0LsnFUgOAkhsKqxKVzyjUuaXvryZHP61gUo6rtc6NfaKR48FTLFPNmOdzSb0gzCFRiym78S1cdL2LdmCBYNv3wft4QQ2d3RMTGie4QhC-hdsjMDqZlWIAVmTcR5TVEacW7pcC4Wrfa-dNHxIGT_bJwPeZIEXy-WUdCDMlVO4D0hh1SDvWkzFPI_0gDbxMhTPMUaf_EVSDZ7X7m3MT5gCZAzuL1Z-G9xwzupE-II8eTD_15xwmOEodpjgs_aVDsGaI1PFGgsLcOpN4xjOrQQgVOB4yFlTZvSE1Y0H4x8S4IMIdTYfMmm_Vlb0HDnX6geFHuk',
deadlineHeight: 1328851,
block: 1328851,
validatorSignatures: [],
},
},
chainProofs: {
thisPublication: {
signature: '0x56abf2084499f2cbca722894dabb3a1664f5fe4a2cabdfd2dc6a266177a3d3731acaa216869d61a1582db4165a76658af6eefce04d82bb6b2eef607bf11f4da91c',
signedByDelegate: true,
signatureDeadline: 1702892439,
typedData: {
types: {
Quote: [{
type: 'uint256',
name: 'profileId',
},
{
type: 'string',
name: 'contentURI',
},
{
type: 'uint256',
name: 'pointedProfileId',
},
{
type: 'uint256',
name: 'pointedPubId',
},
{
type: 'uint256[]',
name: 'referrerProfileIds',
},
{
type: 'uint256[]',
name: 'referrerPubIds',
},
{
type: 'bytes',
name: 'referenceModuleData',
},
{
type: 'address[]',
name: 'actionModules',
},
{
type: 'bytes[]',
name: 'actionModulesInitDatas',
},
{
type: 'address',
name: 'referenceModule',
},
{
type: 'bytes',
name: 'referenceModuleInitData',
},
{
type: 'uint256',
name: 'nonce',
},
{
type: 'uint256',
name: 'deadline',
},
],
},
domain: {
name: 'Lens Protocol Profiles',
version: '2',
chainId: 137,
verifyingContract: '0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d',
},
value: {
actionModules: [],
actionModulesInitDatas: [],
contentURI: 'ar://GbtyAwAME-RGiujxS3NLVhNQAiCbcSlZ26coVU4Kwqc',
deadline: 1702892439,
nonce: 0,
pointedProfileId: '0x0155a4',
pointedPubId: '0x0b24',
profileId: '0x0155a4',
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleData: '0x',
referenceModuleInitData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
},
},
blockHash: '0x31934ea8a4b44ab9eea34041a5d96eae9bb0dc2c41c6686afe0a8670701ac286',
blockNumber: 51267046,
blockTimestamp: 1702892439,
},
pointer: {
location: 'ar://H5mFMCkjaBMkoQTo6QNd0JYB5jDdxpOuHrNXkfoaaxo',
type: 'ON_DA',
},
},
publicationId: '0x0155a4-0x0b24-DA-ff75b024',
event: {
quoteParams: {
profileId: '0x0155a4',
contentURI: 'ar://GbtyAwAME-RGiujxS3NLVhNQAiCbcSlZ26coVU4Kwqc',
actionModules: [],
actionModulesInitDatas: [],
referenceModule: '0x0000000000000000000000000000000000000000',
referenceModuleInitData: '0x',
referenceModuleData: '0x',
referrerProfileIds: [],
referrerPubIds: [],
pointedProfileId: '0x0155a4',
pointedPubId: '0x0b24',
},
pubId: '0x0b24',
actionModulesInitReturnDatas: [],
referenceModuleReturnData: '0x',
referenceModuleInitReturnData: '0x',
transactionExecutor: '0x8D1a7BeEfCCCbaB825AB3B024A2aBf408e776100',
timestamp: 1702892439,
},
}
```
### Metadata breakdown
This will explain in json schema terms what a DA publication metadata holds.
#### POST_CREATED
Can hold either v1 or v2 post.
##### V1 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "The data availability layer schema",
"description": "The data availability layer schema",
"type": "object",
"properties": {
"dataAvailabilityId": {
"description": "The id of the publication on the data availability layer; it is just a GUID",
"type": "guid"
},
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "POST_CREATED"
},
"timestampProofs": {
"description": "Details for the timestamp proofs",
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"description": "The publication being submitted",
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"PostWithSig": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the publication",
"type": "string"
},
"contentURI": {
"description": "The content metadata URI",
"type": "string"
},
"collectModule": {
"description": "The collect module address - will always be a revert collect module at the moment",
"type": "string"
},
"collectModuleInitData": {
"description": "The collect module init data - will always be empty bytes for now",
"type": "string"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data will - will always be empty bytes for now",
"type": "string"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"contentURI",
"collectModule",
"collectModuleInitData",
"referenceModule",
"referenceModuleInitData",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
}
},
"required": ["thisPublication"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"type": "object",
"properties": {
"profileId": {
"description": "The profileId which did the publication",
"type": "string"
},
"pubId": {
"description": "The pubId for the publication",
"type": "string"
},
"contentURI": {
"description": "The contentURI aka metadata for the publication",
"type": "string"
},
"collectModule": {
"description": "The collect module, for now it will always be revert module",
"type": "string"
},
"collectModuleReturnData": {
"description": "The collect module return data, will always for now be empty byte",
"type": "string"
},
"referenceModule": {
"description": "The reference module, will always be address(0) for now",
"type": "string"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"profileId",
"pubId",
"contentURI",
"collectModule",
"collectModuleReturnData",
"referenceModule",
"referenceModuleReturnData",
"timestamp"
]
}
},
"required": [
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
##### V2 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"title": "Momoka schema for post v2",
"properties": {
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"dataAvailabilityId": {
"type": "string",
"description": "The id of the publication on the data availability layer; it is just a GUID"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "POST_CREATED"
},
"timestampProofs": {
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"Post": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the publication",
"type": "string"
},
"contentURI": {
"description": "The content metadata URI",
"type": "string"
},
"actionModules": {
"description": "The action modules - will always be empty for now",
"type": "array"
},
"actionModulesInitDatas": {
"description": "The action modules init datas - will always be empty for now",
"type": "array"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data will - will always be empty bytes for now",
"type": "string"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"contentURI",
"collectModule",
"collectModuleInitData",
"referenceModule",
"referenceModuleInitData",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
}
},
"required": ["thisPublication"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"type": "object",
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"properties": {
"postParams": {
"type": "object",
"properties": {
"profileId": {
"type": "string",
"description": "The profileId which did the publication"
},
"contentURI": {
"type": "string",
"description": "The contentURI aka metadata for the publication"
},
"actionModules": {
"type": "array",
"description": "The array of action modules, for now this will always be empty"
},
"actionModulesInitDatas": {
"type": "array",
"description": "The array of action modules init data, for now this will always be empty"
},
"referenceModule": {
"type": "string",
"description": "The reference module, will always be address(0) for now"
},
"referenceModuleInitData": {
"type": "string",
"description": "The reference module init data, will always for now be empty byte"
}
},
"required": [
"profileId",
"contentURI",
"actionModules",
"actionModulesInitDatas",
"referenceModule",
"referenceModuleInitData"
]
},
"pubId": {
"type": "string",
"description": "The pubId for the publication"
},
"actionModulesInitReturnDatas": {
"type": "array",
"description": "The action modules init return datas, will always be empty for now"
},
"referenceModuleInitReturnData": {
"type": "string",
"description": "The reference module init return data, will always for now be empty byte"
},
"transactionExecutor": {
"type": "string",
"description": "The address who executed transaction"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"postParams",
"pubId",
"actionModulesInitReturnDatas",
"referenceModuleInitReturnData",
"transactionExecutor",
"timestamp"
]
}
},
"required": [
"signature",
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
#### COMMENT_CREATED
This is a DA comment. Very similar to DA post minus the `type`, `typedData` and some `events` properties
##### V1 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "The data availability layer schema",
"description": "The data availability layer schema",
"type": "object",
"properties": {
"dataAvailabilityId": {
"description": "The id of the publication on the data availability layer; it is just a GUID",
"type": "guid"
},
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "COMMENT_CREATED"
},
"timestampProofs": {
"description": "Details for the timestamp proofs",
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"description": "The publication being submitted",
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"CommentWithSig": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the comment",
"type": "string"
},
"profileIdPointed": {
"description": "The profile id which the comment is being made on",
"type": "string"
},
"pubIdPointed": {
"description": "The publication id which the comment is being made on",
"type": "string"
},
"contentURI": {
"description": "The content metadata URI",
"type": "string"
},
"collectModule": {
"description": "The collect module address - will always be a revert collect module at the moment",
"type": "string"
},
"collectModuleInitData": {
"description": "The collect module init data - will always be empty bytes for now",
"type": "string"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty bytes for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data - will always be empty bytes for now",
"type": "string"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"profileIdPointed",
"pubIdPointed",
"contentURI",
"collectModule",
"collectModuleInitData",
"referenceModule",
"referenceModuleInitData",
"referenceModuleData",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
},
"pointer": {
"description": "The pointer this publication is referencing",
"type": "object",
"properties": {
"location": {
"description": "The location of the pointer publication proofs on the data availability layer",
"type": "string"
},
"type": {
"description": "the type of the publication on the data availability layer `ON_DA` or `ON_EVM_CHAIN` - for now you can not do a DA publication on a on-chain publication so will always be `ON_DA`",
"type": "string"
}
},
"required": ["location", "type"]
}
},
"required": ["thisPublication", "pointer"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"type": "object",
"properties": {
"profileId": {
"description": "The profileId which did the publication",
"type": "string"
},
"pubId": {
"description": "The pubId for the publication",
"type": "string"
},
"contentURI": {
"description": "The contentURI aka metadata for the publication",
"type": "string"
},
"profileIdPointed": {
"description": "The profile id of the comment is being made on",
"type": "string"
},
"pubIdPointed": {
"description": "The pub id which the comment is being made on",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty hex for now",
"type": "string"
},
"collectModule": {
"description": "The collect module, for now it will always be revert module",
"type": "string"
},
"collectModuleReturnData": {
"description": "The collect module return data, will always for now be empty byte",
"type": "string"
},
"referenceModule": {
"description": "The reference module, will always be address(0) for now",
"type": "string"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"profileId",
"pubId",
"contentURI",
"profileIdPointed",
"pubIdPointed",
"referenceModuleData",
"collectModule",
"collectModuleReturnData",
"referenceModule",
"referenceModuleReturnData",
"timestamp"
]
}
},
"required": [
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
##### V2 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"title": "Momoka schema for comment v2",
"properties": {
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"dataAvailabilityId": {
"type": "string",
"description": "The id of the publication on the data availability layer; it is just a GUID"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "COMMENT_CREATED"
},
"timestampProofs": {
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"Comment": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the publication",
"type": "string"
},
"pointedProfileId": {
"description": "The profile id which the comment is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The publication id which the comment is being made on",
"type": "string"
},
"contentURI": {
"description": "The content metadata URI",
"type": "string"
},
"actionModules": {
"description": "The action modules - will always be empty for now",
"type": "array"
},
"actionModulesInitDatas": {
"description": "The action modules init datas - will always be empty for now",
"type": "array"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty bytes for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data will - will always be empty bytes for now",
"type": "string"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"pointedProfileId",
"pointedPubId",
"contentURI",
"actionModules",
"actionModulesInitDatas",
"referenceModule",
"referenceModuleData",
"referenceModuleInitData",
"referrerProfileIds",
"referrerPubIds",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
}
},
"required": ["thisPublication"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"type": "object",
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"properties": {
"commentParams": {
"type": "object",
"properties": {
"profileId": {
"type": "string",
"description": "The profileId which did the publication"
},
"contentURI": {
"type": "string",
"description": "The contentURI aka metadata for the publication"
},
"actionModules": {
"type": "array",
"description": "The array of action modules, for now this will always be empty"
},
"actionModulesInitDatas": {
"type": "array",
"description": "The array of action modules init data, for now this will always be empty"
},
"referenceModule": {
"type": "string",
"description": "The reference module, will always be address(0) for now"
},
"referenceModuleInitData": {
"type": "string",
"description": "The reference module init data, will always for now be empty byte"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"pointedProfileId": {
"description": "The profile id of the comment is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "string"
}
},
"required": [
"profileId",
"contentURI",
"actionModules",
"actionModulesInitDatas",
"referenceModule",
"referenceModuleInitData",
"referrerProfileIds",
"referrerPubIds",
"pointedProfileId",
"pointedPubId"
]
},
"pubId": {
"type": "string",
"description": "The pubId for the publication"
},
"actionModulesInitReturnDatas": {
"type": "array",
"description": "The action modules init return datas, will always be empty for now"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"referenceModuleInitReturnData": {
"type": "string",
"description": "The reference module init return data, will always for now be empty byte"
},
"transactionExecutor": {
"type": "string",
"description": "The address who executed transaction"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"commentParams",
"pubId",
"actionModulesInitReturnDatas",
"referenceModuleReturnData",
"referenceModuleInitReturnData",
"transactionExecutor",
"timestamp"
]
}
},
"required": [
"signature",
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
#### MIRROR_CREATED
This is a DA mirror. Very similar to DA post/comment minus the `type`, `typedData` and some `events` properties
##### V1 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "The data availability layer schema",
"description": "The data availability layer schema",
"type": "object",
"properties": {
"dataAvailabilityId": {
"description": "The id of the publication on the data availability layer; it is just a GUID",
"type": "guid"
},
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "COMMENT_CREATED"
},
"timestampProofs": {
"description": "Details for the timestamp proofs",
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"description": "The publication being submitted",
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"MirrorWithSig": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the comment",
"type": "string"
},
"profileIdPointed": {
"description": "The profile id which the comment is being made on",
"type": "string"
},
"pubIdPointed": {
"description": "The publication id which the comment is being made on",
"type": "string"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty bytes for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data - will always be empty bytes for now",
"type": "string"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"profileIdPointed",
"pubIdPointed",
"referenceModule",
"referenceModuleInitData",
"referenceModuleData",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
},
"pointer": {
"description": "The pointer this publication is referencing",
"type": "object",
"properties": {
"location": {
"description": "The location of the pointer publication proofs on the data availability layer",
"type": "string"
},
"type": {
"description": "the type of the publication on the data availability layer `ON_DA` or `ON_EVM_CHAIN` - for now you can not do a DA publication on a on-chain publication so will always be `ON_DA`",
"type": "string"
}
},
"required": ["location", "type"]
}
},
"required": ["thisPublication", "pointer"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"type": "object",
"properties": {
"profileId": {
"description": "The profileId which did the mirror",
"type": "string"
},
"pubId": {
"description": "The pubId for the mirror",
"type": "string"
},
"profileIdPointed": {
"description": "The profile id of the mirror is being made on",
"type": "string"
},
"pubIdPointed": {
"description": "The pub id which the mirror is being made on",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty hex for now",
"type": "string"
},
"referenceModule": {
"description": "The reference module, will always be address(0) for now",
"type": "string"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"profileId",
"pubId",
"profileIdPointed",
"pubIdPointed",
"referenceModuleData",
"referenceModule",
"referenceModuleReturnData",
"timestamp"
]
}
},
"required": [
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
##### V2 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"title": "Momoka schema for mirror v2",
"properties": {
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"dataAvailabilityId": {
"type": "string",
"description": "The id of the publication on the data availability layer; it is just a GUID"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "MIRROR_CREATED"
},
"timestampProofs": {
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"Mirror": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"metadataURI": {
"description": "The metadata URI",
"type": "string"
},
"profileId": {
"description": "The profile id doing the publication",
"type": "string"
},
"pointedProfileId": {
"description": "The profile id which the publication is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The publication id which the publication is being made on",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty bytes for now",
"type": "string"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"pointedProfileId",
"pointedPubId",
"metadataURI",
"referenceModuleData",
"referrerProfileIds",
"referrerPubIds",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
}
},
"required": ["thisPublication"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"type": "object",
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"properties": {
"mirrorParams": {
"type": "object",
"properties": {
"profileId": {
"type": "string",
"description": "The profileId which did the publication"
},
"metadataURI": {
"type": "string",
"description": "The metadataURI aka metadata for the publication"
},
"referenceModuleData": {
"type": "string",
"description": "The reference module data, will always for now be empty byte"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"pointedProfileId": {
"description": "The profile id of the publication is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "string"
}
},
"required": [
"profileId",
"metadataURI",
"referenceModuleData",
"referrerProfileIds",
"referrerPubIds",
"pointedProfileId",
"pointedPubId"
]
},
"pubId": {
"type": "string",
"description": "The pubId for the publication"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"transactionExecutor": {
"type": "string",
"description": "The address who executed transaction"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"mirrorParams",
"pubId",
"actionModulesInitReturnDatas",
"referenceModuleReturnData",
"referenceModuleInitReturnData",
"transactionExecutor",
"timestamp"
]
}
},
"required": [
"signature",
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
#### QUOTE_CREATED
This is a DA mirror. It's very similar to the DA comment.
##### V1 metadata
Quote was not available in V1
##### V2 metadata
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"title": "Momoka schema for quote v2",
"properties": {
"signature": {
"description": "The signature of the entire payload signed by the submitter",
"type": "string"
},
"dataAvailabilityId": {
"type": "string",
"description": "The id of the publication on the data availability layer; it is just a GUID"
},
"type": {
"description": "`POST_CREATED`, `COMMENT_CREATED`, `MIRROR_CREATED` the DA action type which has been submitted",
"type": "QUOTE_CREATED"
},
"timestampProofs": {
"type": "object",
"properties": {
"type": {
"description": "`BUNDLR` - who has supplied us with the timestamp proofs",
"type": "string"
},
"hashPrefix": {
"description": "The timestamp proof hash prefix",
"type": "number"
},
"response": {
"description": "The response from the timestamp proof provider",
"type": "object",
"properties": {
"id": {
"description": "The id of the timestamp proof",
"type": "string"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
},
"version": {
"description": "The version of the timestamp proof",
"type": "string"
},
"public": {
"description": "The public key used sign for the timestamp proofs",
"type": "string"
},
"signature": {
"description": "The signature for the timestamp proofs",
"type": "string"
},
"deadlineHeight": {
"description": "Internal deadline height for the timestamp proof",
"type": "string"
},
"block": {
"description": "Internal block for the timestamp proof (this is not an evm block)",
"type": "number"
},
"validatorSignatures": {
"description": "Internal validator signatures for the timestamp proof (this will always be an empty array for now until Bundlr is decentralised)",
"type": "array",
"items": {
"type": "string"
}
}
},
"required": [
"id",
"timestamp",
"version",
"public",
"signature",
"deadlineHeight",
"block",
"validatorSignatures"
]
}
},
"required": ["type", "hashPrefix", "response"]
},
"chainProofs": {
"description": "The proofs",
"type": "object",
"properties": {
"thisPublication": {
"type": "object",
"properties": {
"signature": {
"description": "The transaction signature",
"type": "string"
},
"signedByDelegate": {
"description": "If the signature was signed by a delegate/dispatcher",
"type": "boolean"
},
"signatureDeadline": {
"description": "The deadline of the signature in unix form",
"type": "number"
},
"typedData": {
"description": "The typed data of the transaction; this uses the signed typed data spec",
"type": "object",
"properties": {
"types": {
"description": "The types of the signed typed data",
"type": "object",
"properties": {
"Quote": {
"description": "The properties of the typed data",
"type": "array",
"items": {
"description": "The name and type of the property",
"type": "object",
"properties": {
"name": {
"description": "The name of typed data",
"type": "string"
},
"type": {
"description": "The type typed data",
"type": "string"
}
},
"required": ["name", "type"]
}
}
},
"required": ["types"]
},
"domain": {
"description": "The domain of the signed typed data",
"type": "object",
"properties": {
"name": {
"description": "The name of the signed typed data",
"type": "string"
},
"version": {
"description": "The version of the signed typed data",
"type": "string"
},
"chainId": {
"description": "The chain id of the signed typed data",
"type": "number"
},
"verifyingContract": {
"description": "The verifying contract",
"type": "string"
}
},
"required": [
"name",
"version",
"chainId",
"verifyingContract"
]
},
"value": {
"description": "The value of the signed typed data",
"type": "object",
"properties": {
"profileId": {
"description": "The profile id doing the publication",
"type": "string"
},
"pointedProfileId": {
"description": "The profile id which the quote is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The publication id which the quote is being made on",
"type": "string"
},
"contentURI": {
"description": "The content metadata URI",
"type": "string"
},
"actionModules": {
"description": "The action modules - will always be empty for now",
"type": "array"
},
"actionModulesInitDatas": {
"description": "The action modules init datas - will always be empty for now",
"type": "array"
},
"referenceModule": {
"description": "The reference module will always be address(0) for now",
"type": "string"
},
"referenceModuleData": {
"description": "The reference module data - will always be empty bytes for now",
"type": "string"
},
"referenceModuleInitData": {
"description": "The reference module init data will - will always be empty bytes for now",
"type": "string"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"nonce": {
"description": "The signature nonce",
"type": "number"
},
"deadline": {
"description": "The signature deadline in unix form",
"type": "number"
}
},
"required": [
"profileId",
"pointedProfileId",
"pointedPubId",
"contentURI",
"actionModules",
"actionModulesInitDatas",
"referenceModule",
"referenceModuleData",
"referenceModuleInitData",
"referrerProfileIds",
"referrerPubIds",
"nonce",
"deadline"
]
}
},
"required": ["types", "domain", "value"]
},
"blockHash": {
"description": "The block hash the submitter simulated this transaction on",
"type": "string"
},
"blockNumber": {
"description": "The block number the submitter simulated this transaction on",
"type": "number"
},
"blockTimestamp": {
"description": "The block unix timestamp of the simulated transaction",
"type": "number"
}
},
"required": [
"signature",
"signedByDelegate",
"signatureDeadline",
"typedData",
"blockHash",
"blockNumber",
"blockTimestamp"
]
}
},
"required": ["thisPublication"]
},
"publicationId": {
"description": "The id of the publication, which is built up of the profileId + pubId + `DA` + first eight chars of the dataAvailabilityId (so it will always be unique)",
"type": "string"
},
"event": {
"type": "object",
"description": "This is trying to shape what you would get within an `EVM` event so you can easily parse it and understand it. This will always be identical to the EVM event data structure.",
"properties": {
"quoteParams": {
"type": "object",
"properties": {
"profileId": {
"type": "string",
"description": "The profileId which did the publication"
},
"contentURI": {
"type": "string",
"description": "The contentURI aka metadata for the publication"
},
"actionModules": {
"type": "array",
"description": "The array of action modules, for now this will always be empty"
},
"actionModulesInitDatas": {
"type": "array",
"description": "The array of action modules init data, for now this will always be empty"
},
"referenceModule": {
"type": "string",
"description": "The reference module, will always be address(0) for now"
},
"referenceModuleInitData": {
"type": "string",
"description": "The reference module init data, will always for now be empty byte"
},
"referrerProfileIds": {
"description": "The profile ids this publication references - will always be empty for now",
"type": "array"
},
"referrerPubIds": {
"description": "The pub ids this publication references - will always be empty for now",
"type": "array"
},
"pointedProfileId": {
"description": "The profile id of the quote is being made on",
"type": "string"
},
"pointedPubId": {
"description": "The pub ids this quote references - will always be empty for now",
"type": "string"
}
},
"required": [
"profileId",
"contentURI",
"actionModules",
"actionModulesInitDatas",
"referenceModule",
"referenceModuleInitData",
"referrerProfileIds",
"referrerPubIds",
"pointedProfileId",
"pointedPubId"
]
},
"pubId": {
"type": "string",
"description": "The pubId for the publication"
},
"actionModulesInitReturnDatas": {
"type": "array",
"description": "The action modules init return datas, will always be empty for now"
},
"referenceModuleReturnData": {
"description": "The reference module return data, will always for now be empty byte",
"type": "string"
},
"referenceModuleInitReturnData": {
"type": "string",
"description": "The reference module init return data, will always for now be empty byte"
},
"transactionExecutor": {
"type": "string",
"description": "The address who executed transaction"
},
"timestamp": {
"description": "The timestamp date in milliseconds",
"type": "number"
}
},
"required": [
"quoteParams",
"pubId",
"actionModulesInitReturnDatas",
"referenceModuleReturnData",
"referenceModuleInitReturnData",
"transactionExecutor",
"timestamp"
]
}
},
"required": [
"signature",
"dataAvailabilityId",
"type",
"timestampProofs",
"chainProofs",
"publicationId",
"event"
]
}
```
## Technical code and how to run a verifier
We have 2 implementations of momoka one in node which supports browsers also and one in rust:
- [momoka-node](./momoka-node/) - you can run the node verifier very easily and it also have indexer tools. Alongside this it has packages to run the verifier on the client side.
- [momoka-rust](./momoka-rs/) - this is currently only supported lens v1 and will be migrated to lens v2 soon. Rust is the beta client verifier and eventually we like the rust client to be the main client.
## Acknowledgements
### Bundlr
A special thank you to [Bundlr](https://bundlr.network/) for making this project possible with their cutting-edge technology. We are grateful to their exceptional team for their collaboration and support.
### Arweave
We also extend our gratitude to [Arweave](https://www.arweave.org/) for providing decentralized storage solutions for our data, contributing to the overall success of the DA project.
================================================
FILE: momoka-node/.dockerignore
================================================
.dockerignore
npm-debug.log
Dockerfile
.gitignore
jest.config.js
.git
node_modules
================================================
FILE: momoka-node/.eslintrc.js
================================================
module.exports = {
env: {
es2021: true,
node: true,
},
ignorePatterns: ['.eslintrc.js', '*.json', '*.test.ts', '*.mock.ts'],
extends: [
'eslint:recommended',
'plugin:@typescript-eslint/recommended',
'plugin:import/recommended',
'plugin:import/typescript',
'plugin:prettier/recommended',
],
parser: '@typescript-eslint/parser',
parserOptions: {
ecmaVersion: 12,
sourceType: 'module',
},
plugins: ['@typescript-eslint', 'prettier', 'prefer-arrow'],
settings: {
'import/resolver': {
typescript: true,
node: true,
},
'import/internal-regex': '^@lens/',
},
rules: {
'@typescript-eslint/comma-dangle': [
'error',
{
arrays: 'always-multiline',
objects: 'always-multiline',
imports: 'always-multiline',
exports: 'always-multiline',
enums: 'always-multiline',
functions: 'never',
},
],
'@typescript-eslint/ban-types': [
'error',
{ types: { Function: false, Boolean: false }, extendDefaults: true },
],
'@typescript-eslint/explicit-function-return-type': ['error', { allowExpressions: true }],
'@typescript-eslint/no-empty-interface': ['warn'],
'@typescript-eslint/no-empty-function': 'warn',
'@typescript-eslint/no-explicit-any': ['warn'],
'@typescript-eslint/no-shadow': ['error'],
'@typescript-eslint/no-namespace': 'off',
'@typescript-eslint/no-non-null-assertion': 'off',
'@typescript-eslint/no-unused-vars': [
'warn',
{
argsIgnorePattern: '^_',
},
],
'@typescript-eslint/no-var-requires': 'off',
'@typescript-eslint/ban-ts-comment': ['warn'],
// '@typescript-eslint/naming-convention': [
// 'error',
// {
// selector: 'default',
// format: ['camelCase', 'PascalCase'],
// leadingUnderscore: 'allow',
// },
// {
// selector: 'typeProperty',
// format: null,
// },
// {
// selector: ['interface', 'typeLike'],
// format: ['PascalCase'],
// },
// {
// selector: 'variable',
// modifiers: ['const'],
// format: ['camelCase', 'UPPER_CASE'],
// leadingUnderscore: 'allow',
// },
// {
// selector: 'enumMember',
// format: ['UPPER_CASE'],
// },
// ],
'require-await': ['error'],
'capitalized-comments': 'off',
'no-control-regex': 'off',
'no-empty': 'warn',
'no-shadow': 'off',
'prefer-arrow/prefer-arrow-functions': [
'warn',
{
disallowPrototype: true,
singleReturnOnly: false,
classPropertiesAllowed: false,
},
],
// 'array-element-newline': ['error', 'consistent'],
'arrow-body-style': 'off',
// 'max-len': [
// 'error',
// {
// code: 120,
// ignoreComments: true,
// ignorePattern: '^import .*$',
// ignoreStrings: true,
// ignoreTemplateLiterals: true,
// ignoreRegExpLiterals: true,
// },
// ],
'max-statements-per-line': 'error',
'no-case-declarations': 'off',
'no-constant-condition': 'warn',
},
};
================================================
FILE: momoka-node/.nvmrc
================================================
v18.12.1
================================================
FILE: momoka-node/.prettierignore
================================================
*.yml
*.yaml
*.md
================================================
FILE: momoka-node/.prettierrc
================================================
{
"printWidth": 100,
"singleQuote": true,
"trailingComma": "es5"
}
================================================
FILE: momoka-node/CHANGELOG.md
================================================
# unreleased - fill in any changes you do here!
## Features
## Bug fixes
## Breaking changes
###################################################################
# 2.0.0 - 18th December 2023
# Features
- feat: add support for lens v2 publications
- fix: export MomokaProvider and MomokaActionTypes
# 1.1.2 - 24th May 2023
## Bug fixes
- fix: uninstall lib-curl
# 1.1.1 - 24th May 2023
# Bug fixes
- fix: remove lib-curl and use axios instead on node server to avoid some OS issues
# 1.0.0>1.1.0 - 26th April 2023
## Features
- feat: Initial release 1.0.0
## Fix
- fix: Avoid installing `only-allow` during `preinstall` step
================================================
FILE: momoka-node/Dockerfile
================================================
FROM mcr.microsoft.com/devcontainers/typescript-node:18 as base
WORKDIR /usr/src/app
COPY package*.json ./
COPY tsconfig.json ./
COPY src ./src
COPY .env ./
# Enable corepack which would install correct version of pnpm
RUN corepack enable
# Install project dependencies using pnpm
RUN npx pnpm install
RUN chown -R node:node /usr/src/app
USER node
# Build the project
RUN npm run build
EXPOSE 3008
CMD ["npm", "run", "start"]
================================================
FILE: momoka-node/Dockerfile.stable
================================================
FROM node:18-alpine AS base
# Install pnpm through corepack
RUN apk update
RUN apk add --no-cache libc6-compat
RUN corepack enable
RUN corepack prepare pnpm@latest --activate
# Specify a path for pnpm global root
ENV PNPM_HOME=/usr/local/bin
FROM base as runtime
# Install stable version of momoka
RUN pnpm add -g @lens-protocol/momoka
# Run using the default shell, this is important to infer the environment variables
CMD ["sh", "-c", "momoka --node $NODE_URL --environment=$ENVIRONMENT --concurrency=$CONCURRENCY --fromHead=true"]
================================================
FILE: momoka-node/LICENSE.txt
================================================
Copyright (c) 2023 Aave companies
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: momoka-node/README.md
================================================
# Momoke-node
This package holds the node implementation of the momoka and also the ability to run it client side.
## Running
### Key information
To run the verifier, you MUST use an archive node. You can sign up with Alchemy and use one of their free nodes. Non-archive nodes do not retain state information beyond the previous 16-128 blocks. While this may be sufficient for immediate runtime calls after the DA publication is created, it will not work for past transactions beyond the 16-128 block range.
### Being as fast as possible - Concurrency
The verifier is designed for optimal speed, with performance determined by its configuration parameters. Achieving 10,000 TPS is not a problem, provided that the hardware and nodes can support these limits. When running the verifier, you have the option to set the CONCURRENCY, which divides the number of requests sent to the NODE_URL simultaneously. Higher concurrency values result in faster performance during resynchronization or when handling a large volume of transactions at once.
The default concurrency is 100, which typically requires a paid archive node. If you prefer using a free node, the verifier will be slower, but it will still work effectively. For a free node, you can set the concurrency between 1 and 3. For example, at LENS, we have set the concurrency at 120, which enables our verifier to run very quickly.
## Running straight out the box
Currently, you have two options to run it directly. Either by using the npm `momoka` package, or through Docker.
### Running from npm
You can install it globally:
```bash
$ npm i @lens-protocol/momoka -g
```
then you can just run:
```bash
$ momoka --node 'YOUR_NODE' --environment='MUMBAI|AMOY|POLYGON' --concurrency=20
```
you can also just run with npx:
```bash
$ npx @lens-protocol/momoka --node 'YOUR_NODE' --environment='MUMBAI|AMOY|POLYGON' --concurrency=20
```
By default it will not resync all the data, it just start verifying from this point onwards unless you add the parameter `--resync=true` which will start from block 0 and resync all the data.
### Running from Docker
You can use the `Dockerfile.stable` file to set up a container which will run the latest stable release on Momoka from `npm`. The Dockerfile assumes running on the `POLYGON` environment, and sets concurrency to 100. You can change those if necessary.
A few environment variables are required for it to work, which you can set however you'd like depending on how and where you're running the Docker container. Specifically, you need to set `NODE_URL`, `ENVIRONMENT`, and `CONCURRENCY` environment variables.
> NOTE: A `render.yaml` IaC blueprint is also provided which runs `Dockerfile.stable`. If you'd like to use [Render](https://render.com) for hosting your Momoka verifier, you can easily deploy it there by using the Render Blueprint. See their docs on [Infrastructure as Code](https://render.com/docs/infrastructure-as-code) to see how.
### Parameter meanings
- `--node` - this is the URI of the Polygon archive node you wish to connect to, this can be a free node or a paid node, it is recommended to use a paid node for the best performance. you can get up and running with a node using Alchemy, Infura, or any other similar infrastructure provider
- `--environment` - this is the environment you wish to run the verifier on, this can be `MUMBAI` `AMOY` or `POLYGON`
- `--concurrency` - this is the concurrency you wish to run the verifier on, which was talked in depth above
- `--resync` - this is a boolean value, which if set to true will start the verifier from the block 0 and resync all transactions from the past, if set to false it will start verifying from this moment onwards.
## Installing package
This is a written in node, and this means it can be run on the client as well as a server; it won't use the DB on the client but can mean you can run proof checks in runtime, which is super powerful. Also, you may which to monitor this on your server to index stuff as it comes in.
```bash
$ npm i @lens-protocol/momoka
```
<b>Do not use if you do not know what you are doing the basic config works for all production apps</b>
Please note if you wish to use a different deployment then `PRODUCTION` you will need to make sure you put `deployment: STAGING` or `deployment: LOCAL` in the `EthereumNode` object. This for most will not be the case.
### Client usage
The package exposes a separate entry point for the client usage (`'@lens-protocol/momoka/client'`) to make sure the bundle size is not affected by any polyfills or other node specific code.
Check the `playground-browser` folder for a working example of the client usage.
#### checkDAProof
The `checkDAProof` will return you a failure reason of the enum `MomokaValidatorError`, and if successful, you be returned the entire `DAStructurePublication`. This is a client specific version of the `checkDAProof` function that doesn't have any caching in place. For the server version, please see the server usage section.
```ts
import { checkDAProof, EthereumNode, Environment } from '@lens-protocol/momoka/client';
const ethereumNode: EthereumNode = {
environment: Environment.POLYGON,
nodeUrl: YOUR_NODE_URL,
};
const result = await checkDAProof(PROOF_ID, ethereumNode);
if (result.isSuccess()) {
console.log('proof valid', result.successResult);
return; // all is well!
}
// it failed!
console.error('proof invalid do something', result.failure);
```
### Server usage
#### checkDAProof
The `checkDAProof` will return you a failure reason of the enum `MomokaValidatorError`, and if successful, you be returned the entire `DAStructurePublication`. This is a server specific version of the `checkDAProof` function that has caching in place. For the client version, please see the client usage section.
```ts
import { checkDAProof, EthereumNode, Environment } from '@lens-protocol/momoka';
const ethereumNode: EthereumNode = {
environment: Environment.POLYGON,
nodeUrl: YOUR_NODE_URL,
};
const result = await checkDAProof(PROOF_ID, ethereumNode);
if (result.isSuccess()) {
console.log('proof valid', result.successResult);
return; // all is well!
}
// it failed!
console.error('proof invalid do something', result.failure);
```
#### startDAVerifierNode
This will start watching all the DA items coming in and logging it all out in your terminal. you can install the package and run it on your own server. By default it will not resync all the data, it just start verifying from this point onwards unless you add the parameter which is defined below.
```ts
import { startDAVerifierNode, EthereumNode } from '@lens-protocol/momoka';
const ethereumNode: EthereumNode = {
environment: Environment.POLYGON,
nodeUrl: YOUR_NODE_URL,
};
// you should read up on section "Being as fast as possible - Concurrency"
const concurrency = 100;
// it run forever and log out to the terminal
startDAVerifierNode(ethereumNode, concurrency);
```
#### startDAVerifierNode - Stream with proofs verified
If you wish to index the data yourself, you can use the `startDAVerifierNode` and stream the data out to your own DB using the `StreamCallback`. This will run the verifier node and check the proofs as every new one comes in. By default it will not resync all the data, it just start verifying from this point onwards unless you add the parameter which is defined below.
```ts
import { startDAVerifierNode, StreamResult, EthereumNode } from '@lens-protocol/momoka';
const stream = (result: StreamResult) => {
console.log('streamed publication', result);
if (result.success) {
// success - insert into your db here if you wish
console.log('success', result.dataAvailabilityResult);
} else {
// failure reason
console.log('reason', result.failureReason);
// this will expose the submisson if it could be read
console.log('submisson', result.dataAvailabilityResult);
}
};
const ethereumNode: EthereumNode = {
environment: Environment.POLYGON,
nodeUrl: YOUR_NODE_URL,
};
// you should read up on section "Being as fast as possible - Concurrency"
const concurrency = 100;
// it run forever and log out to the terminal
startDAVerifierNode(ethereumNode, concurrency, { stream });
```
#### Start verifier from block 0
You may wish to start the verifier and recheck from the first ever momoka transaction, You can do this by passing in the `resync` option.
```ts
import { startDAVerifierNode, StreamResult, EthereumNode } from '@lens-protocol/momoka';
const ethereumNode: EthereumNode = {
environment: Environment.POLYGON,
nodeUrl: YOUR_NODE_URL,
};
// you should read up on section "Being as fast as possible - Concurrency"
const concurrency = 100;
// it run forever and log out to the terminal
startDAVerifierNode(ethereumNode, concurrency, { resync: true });
```
#### startDATrustingIndexing
If you just want to get the data as fast as possible and do not wish to verify the proofs, you can use the `startDATrustingIndexing` function. This will stream out the data as fast as possible and will not check the proofs, so does not require an archive node.
```ts
import {
startDATrustingIndexing,
StreamResult,
StartDATrustingIndexingRequest,
} from '@lens-protocol/momoka';
const stream = (result: StreamResult) => {
console.log('streamed publication', result);
if (result.success) {
// success - insert into your db here if you wish
console.log('success', result.dataAvailabilityResult);
} else {
// failure reason
console.log('reason', result.failureReason);
// this will expose the submisson if it could be read
console.log('submisson', result.dataAvailabilityResult);
}
};
const request: StartDATrustingIndexingRequest = {
environment: Environment.POLYGON,
stream,
};
// it run forever and stream data as it comes in
startDATrustingIndexing(request);
```
### Running from this repo
#### Dependencies
This package has a few dependencies that need to be installed, these are:
- we use `pnpm` for this repo so please have it installed: https://pnpm.io/installation
- nvm is also used for node versioning:
If you wish to just run it on its own, you can just run:
```bash
$ nvm use
$ pnpm i
$ pnpm run start
```
To build its just:
```bash
$ pnpm build
```
### Tests
To run the tests:
create an `.env.test` file with the following (you need to add a AMOY node url)
```bash
ETHEREUM_NETWORK=AMOY
NODE_URL=AMOY_NODE_URL
DEPLOYMENT=PRODUCTION
CONCURRENCY=10
```
```bash
$ pnpm test
```
### Docker
Please note you need a `.env` setup for this to work.
To run the docker first build it:
```bash
$ docker build -t da-service .
```
Then run it:
```bash
$ docker run -d -p 3008:3008 da-service
```
This will return an docker id.
Then to listen to the logs you can:
```bash
docker logs <id>
```
## Validation checks flows
This is written in sudo `node` code to understand the current flow of the validation checks.
```ts
async function validateClaim() {
// 1. Fetch DA metadata from Bundlr
const metadata = await fetchMetadataFromBundlr();
// 2. Check if `signature` is defined
if (!signature) {
return MomokaValidatorError.NO_SIGNATURE_SUBMITTER;
}
// 3. Verify `signature` with `metadata`
if (!verifySignature(signature, metadata)) {
return MomokaValidatorError.INVALID_SIGNATURE_SUBMITTER;
}
// 4. Check timestamp proofs with Bundlr
if (!(await checkTimestampProofs())) {
return MomokaValidatorError.TIMESTAMP_PROOF_INVALID_SIGNATURE;
}
// 5. Check if timestamp proofs submitter is valid
if (!isValidTimestampProofsSubmitter()) {
return MomokaValidatorError.TIMESTAMP_PROOF_INVALID_SUBMITTER;
}
// 6. Check if event `timestamp` equals `blockTimestamp`
if (eventTimestamp !== blockTimestamp) {
return MomokaValidatorError.INVALID_EVENT_TIMESTAMP;
}
// 7. Check if block number is closest to timestamp proofs
if (!isClosestBlock()) {
return MomokaValidatorError.NOT_CLOSEST_BLOCK;
}
// 8. Check if chain signature has already been used
if (!chainSignatureAlreadyUsed()) {
return MomokaValidatorError.CHAIN_SIGNATURE_ALREADY_USED;
}
// 9. Check if pointer is defined
if (isPost() && pointer) {
return MomokaValidatorError.INVALID_POINTER_SET_NOT_NEEDED;
} else if (!pointer && (isMirror() || isComment())) {
return MomokaValidatorError.INVALID_POINTER_NOT_SET;
}
// 9.1. Check pointer type (if defined)
if (pointer && !isPointerTypeOnDA()) {
return PUBLICATION_NONE_DA;
}
// 10. Verify pointer (if defined) - follow steps from 1
const pointerStepError = await verifyPointer();
if (pointerStepError) {
return pointerStepError;
}
// 11. Check if formatted typed data is valid
if (!isValidFormattedTypedData()) {
return MomokaValidatorError.INVALID_FORMATTED_TYPED_DATA;
}
// 12a. If `POST`, simulate transaction using eth_call
if (isPost()) {
const simulationResult = await simulateTransaction();
if (simulationResult === 'nodeError') {
return MomokaValidatorError.SIMULATION_NODE_COULD_NOT_RUN;
} else if (simulationResult === 'failed') {
return MomokaValidatorError.SIMULATION_FAILED;
}
}
// 12b. If `COMMENT` or `MIRROR`, perform additional checks
else {
if (!isValidPublicationNonce()) {
return MomokaValidatorError.PUBLICATION_NONCE_INVALID;
}
if (!isPublicationSignerAllowed()) {
return MomokaValidatorError.PUBLICATION_SIGNER_NOT_ALLOWED;
}
}
// 13. Cross-check typed data values with `event`
if (!isEventMatchingTypedData()) {
return MomokaValidatorError.EVENT_MISMATCH;
}
// 14. Check if `publicationId` matches expected ID
if (!isPublicationIdMatch()) {
// 15. Check if it could of been a potential reorg
// if so:
return MomokaValidatorError.POTENTIAL_REORG;
// if not
return MomokaValidatorError.GENERATED_PUBLICATION_ID_MISMATCH;
}
// all validated!
}
```
At this point, you have done all the checks needed, and this is a valid submission! As you see, using signatures and EVM calls, we can verify the data is correct and the submitter is correct without any other third party.
### Validation error checks types and messages
The summary in the code should explain what is being checked for and what it would fail out if it doesn't match. Below is the full list of error cases
```ts
export enum MomokaValidatorError {
/**
* This means the main signature has not been attached to the payload
*/
NO_SIGNATURE_SUBMITTER = 'NO_SIGNATURE_SUBMITTER',
/**
* This means the main signature has not been signed by the same payload as the data itself
*/
INVALID_SIGNATURE_SUBMITTER = 'INVALID_SIGNATURE_SUBMITTER',
/**
* This means the submitted timestamp proof does not have a valid timestamp proof signature
*/
TIMESTAMP_PROOF_INVALID_SIGNATURE = 'TIMESTAMP_PROOF_INVALID_SIGNATURE',
/**
* This means the type in the timestamp proofs do not match
* timestamp proofs are not portable
*/
TIMESTAMP_PROOF_INVALID_TYPE = 'TIMESTAMP_PROOF_INVALID_TYPE',
/**
* This means the da id in the timestamp proofs do not match up
* timestamp proofs are not portable
*/
TIMESTAMP_PROOF_INVALID_DA_ID = 'TIMESTAMP_PROOF_INVALID_DA_ID',
/**
* This means the timestamp proof uploaded was not done by a valid submitter
*/
TIMESTAMP_PROOF_NOT_SUBMITTER = 'TIMESTAMP_PROOF_NOT_SUBMITTER',
/**
* We tried to call them 5 times and its errored out - this is not a bad proof but bundlr/arweave are having issues
*/
CAN_NOT_CONNECT_TO_BUNDLR = 'CAN_NOT_CONNECT_TO_BUNDLR',
/**
* The DA tx could not be found or invalid on the bundlr/arweave nodes
* can happened if pasted it in wrong
*/
INVALID_TX_ID = 'INVALID_TX_ID',
/**
* This the typed data format is invalid (aka a invalid address type etc)
*/
INVALID_FORMATTED_TYPED_DATA = 'INVALID_FORMATTED_TYPED_DATA',
/**
* This means it can not read the block from the node
*/
BLOCK_CANT_BE_READ_FROM_NODE = 'BLOCK_CANT_BE_READ_FROM_NODE',
/**
* This means it can not read the data from the node
*/
DATA_CANT_BE_READ_FROM_NODE = 'DATA_CANT_BE_READ_FROM_NODE',
/**
* This means the simulation was not able to be ran on the node, this does not mean
* that it would fail on chain, it means the nodes may of been down and needs rechecking
*/
SIMULATION_NODE_COULD_NOT_RUN = 'SIMULATION_NODE_COULD_NOT_RUN',
/**
* This means the simulation was not successful and got rejected on-chain
* or the result from the simulation did not match the expected result
*/
SIMULATION_FAILED = 'SIMULATION_FAILED',
/**
* This means the event emitted from the simulation does not match the expected event
*/
EVENT_MISMATCH = 'EVENT_MISMATCH',
/**
* This means the event timestamp passed into the emitted event does not match the signature timestamp
*/
INVALID_EVENT_TIMESTAMP = 'INVALID_EVENT_TIMESTAMP',
/**
* This means the deadline set in the typed data is not correct
*/
INVALID_TYPED_DATA_DEADLINE_TIMESTAMP = 'INVALID_TYPED_DATA_DEADLINE_TIMESTAMP',
/**
* This means the generated publication id for the generic id does not match
* what it should be
*/
GENERATED_PUBLICATION_ID_MISMATCH = 'GENERATED_PUBLICATION_ID_MISMATCH',
/**
* This means the pointer set in the chain proofs is not required but set anyway
*/
INVALID_POINTER_SET_NOT_NEEDED = 'INVALID_POINTER_SET_NOT_NEEDED',
/**
* This means the pointer has failed verification
*/
POINTER_FAILED_VERIFICATION = 'POINTER_FAILED_VERIFICATION',
/**
* This means the block processed against is not the closest block to the timestamp proofs
*/
NOT_CLOSEST_BLOCK = 'NOT_CLOSEST_BLOCK',
/**
* This means the timestamp proofs are not close enough to the block
*/
BLOCK_TOO_FAR = 'NOT_CLOSEST_BLOCK',
/**
* This means the publication submitted does not have a valid pointer
* and a pointer is required
*/
PUBLICATION_NO_POINTER = 'PUBLICATION_NO_POINTER',
/**
* Some publications (comment and mirror) for now can only be on another
* DA publication not on evm chain publications
*/
PUBLICATION_NONE_DA = 'PUBLICATION_NONE_DA',
/**
* This means the publication nonce is invalid at the time of submission
*/
PUBLICATION_NONCE_INVALID = 'PUBLICATION_NONCE_INVALID',
/**
* This means the publication submisson was signed by a wallet that is not allowed
*/
PUBLICATION_SIGNER_NOT_ALLOWED = 'PUBLICATION_SIGNER_NOT_ALLOWED',
/**
* This means the evm signature has already been used
*/
CHAIN_SIGNATURE_ALREADY_USED = 'CHAIN_SIGNATURE_ALREADY_USED',
/**
* This means the publication submisson could not pass potentional due to a reorg
*/
POTENTIAL_REORG = 'POTENTIAL_REORG',
/**
* unknown error should not happen but catch all
*/
UNKNOWN = 'UNKNOWN',
}
```
## Contributing
Any PRs are welcome and we will review them as soon as possible. Please make sure you have tests and they pass.
## Acknowledgements
### Bundlr
A special thank you to [Bundlr](https://bundlr.network/) for making this project possible with their cutting-edge technology. We are grateful to their exceptional team for their collaboration and support.
### Arweave
We also extend our gratitude to [Arweave](https://www.arweave.org/) for providing decentralized storage solutions for our data, contributing to the overall success of the DA project.
## Why node?
Our goal was to create a tool that could be verified both on the client and server side, and we found that Node.js was the most suitable option for this purpose. Additionally, we aimed to make it as understandable as possible, and Node.js is renowned for its ease of use and a big languaged used throughout web3 development. As per our roadmap, we plan to migrate a significant portion of this stack to Rust, a more low-level language, to achieve maximum speed once we need it.
================================================
FILE: momoka-node/client/package.json
================================================
{
"main": "../lib/client/index.js"
}
================================================
FILE: momoka-node/codegen.yaml
================================================
schema: https://lens.bundlr.network/graphql
documents: './src/graphql/*.graphql'
generates:
./src/graphql/generated.ts:
plugins:
- typescript
- typescript-operations
- typed-document-node
config:
fetcher: fetch
================================================
FILE: momoka-node/jest.config.js
================================================
/** @type {import('ts-jest').JestConfigWithTsJest} */
module.exports = {
preset: 'ts-jest',
testEnvironment: 'node',
collectCoverage: true,
coverageDirectory: 'coverage',
setupFiles: ['<rootDir>/src/__TESTS__/config/jest.setup.js'],
coveragePathIgnorePatterns: [
'node_modules',
'<rootDir>/src/__TESTS__',
'.mock.ts',
'<rootDir>/src/logger.ts',
'<rootDir>/src/arweave',
'<rootDir>/src/bundlr',
],
testPathIgnorePatterns: ['/node_modules/', '/lib/', '/playground-browser/'],
verbose: true,
};
================================================
FILE: momoka-node/package.json
================================================
{
"name": "@lens-protocol/momoka",
"version": "2.1.1",
"description": "Momoka node for the Lens protocol",
"main": "lib/index.js",
"types": "./lib/index.d.ts",
"exports": {
".": "./lib/index.js",
"./client": "./lib/client/index.js",
"./package.json": "./package.json"
},
"files": [
"lib/**/*",
"client/**/*",
"images/**/*",
"README.md"
],
"scripts": {
"build": "tsc",
"build:watch": "tsc --watch",
"eslint:fix": "eslint \"src/**/*.ts\" --quiet --fix",
"eslint": "eslint \"src/**/*.ts\" --quiet",
"start:fork": "REQ_TIMEOUT=100000 anvil --fork-url NODE_URL --silent",
"start": "env-cmd -f .env node lib/runnable/da-verifier-node.runnable.js",
"start:failed": "env-cmd -f .env ts-node src/failed-submissons.runnable.ts",
"debug:playground": "npm run build && env-cmd -f .env node lib/__PLAYGROUND__/index.js",
"generate": "graphql-codegen",
"test": "npm run build && env-cmd -f .env.test jest",
"lint": "pnpm run prettier && pnpm run tsc",
"lint:fix": "pnpm run prettier:fix && pnpm run eslint",
"prettier:fix": "prettier --write .",
"prettier": "prettier --check .",
"tsc": "tsc --noEmit",
"prepublishOnly": "pnpm run build",
"publish": "pnpm publish --access public"
},
"devDependencies": {
"@graphql-codegen/cli": "2.11.3",
"@graphql-codegen/typed-document-node": "2.3.2",
"@graphql-codegen/typescript": "2.7.2",
"@graphql-codegen/typescript-operations": "2.5.2",
"@types/bluebird": "^3.5.38",
"@types/jest": "^29.2.6",
"@types/yargs": "^17.0.22",
"@typescript-eslint/eslint-plugin": "^5.49.0",
"@typescript-eslint/parser": "^5.49.0",
"env-cmd": "^10.1.0",
"eslint": "^7.28.0",
"eslint-config-prettier": "^8.5.0",
"eslint-import-resolver-typescript": "^3.5.3",
"eslint-plugin-import": "npm:eslint-plugin-i@^2.26.0-2",
"eslint-plugin-prefer-arrow": "^1.2.3",
"eslint-plugin-prettier": "^3.4.0",
"ethereum-abi-types-generator": "^1.3.2",
"graphql-codegen": "^0.4.0",
"jest": "^29.4.0",
"ts-jest": "^29.0.5",
"ts-node": "10.9.1",
"typescript": "^4.6.4"
},
"dependencies": {
"@ethersproject/abstract-provider": "^5.7.0",
"@ethersproject/bytes": "^5.7.0",
"@graphql-typed-document-node/core": "^3.1.2",
"@urql/core": "^3.0.5",
"arweave": "^1.13.3",
"axios": "^1.3.4",
"bluebird": "^3.7.2",
"ethereum-multicall": "^2.24.0",
"ethers": "^5.7.2",
"graphql": "^16.6.0",
"level": "^8.0.0",
"yargs": "^17.7.1"
},
"license": "MIT",
"bin": {
"momoka": "./lib/bin/cli.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/lens-protocol/momoka.git"
},
"packageManager": "pnpm@8.4.0"
}
================================================
FILE: momoka-node/playground-browser/.gitignore
================================================
# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
# dependencies
/node_modules
/.pnp
.pnp.js
# testing
/coverage
# production
/build
# misc
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local
npm-debug.log*
yarn-debug.log*
yarn-error.log*
================================================
FILE: momoka-node/playground-browser/README.md
================================================
# Getting Started with Create React App
This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
## Available Scripts
In the project directory, you can run:
### `npm start`
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.
The page will reload if you make edits.\
You will also see any lint errors in the console.
### `npm test`
Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
### `npm run build`
Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.
The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
### `npm run eject`
**Note: this is a one-way operation. Once you `eject`, you can’t go back!**
If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.
You don’t have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.
## Learn More
You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
To learn React, check out the [React documentation](https://reactjs.org/).
================================================
FILE: momoka-node/playground-browser/config-overrides.js
================================================
module.exports = function override(config) {
// required to support .cjs extension which is used by axios inside the verifier library
// see https://github.com/facebook/create-react-app/pull/12021
// TODO: Build verifier client as a ES module
config.module.rules = config.module.rules.map((rule) => {
if (rule.oneOf instanceof Array) {
rule.oneOf[rule.oneOf.length - 1].exclude = [
/\.(js|mjs|jsx|cjs|ts|tsx)$/,
/\.html$/,
/\.json$/,
];
}
return rule;
});
return config;
};
================================================
FILE: momoka-node/playground-browser/package.json
================================================
{
"name": "playground-browser",
"version": "0.1.0",
"private": true,
"dependencies": {
"@testing-library/jest-dom": "^5.16.5",
"@testing-library/react": "^13.4.0",
"@testing-library/user-event": "^13.5.0",
"@types/jest": "^27.5.2",
"@types/node": "^16.18.16",
"@types/react": "^18.0.28",
"@types/react-dom": "^18.0.11",
"react": "^18.2.0",
"react-dom": "^18.2.0",
"react-scripts": "5.0.1",
"typescript": "^4.9.5",
"web-vitals": "^2.1.4"
},
"devDependencies": {
"react-app-rewired": "^2.2.1"
},
"scripts": {
"start": "react-app-rewired start",
"build": "react-app-rewired build",
"test": "react-app-rewired test",
"eject": "react-scripts eject"
},
"eslintConfig": {
"extends": [
"react-app",
"react-app/jest"
]
},
"browserslist": {
"production": [
">0.2%",
"not dead",
"not op_mini all"
],
"development": [
"last 1 chrome version",
"last 1 firefox version",
"last 1 safari version"
]
}
}
================================================
FILE: momoka-node/playground-browser/public/index.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name="theme-color" content="#000000" />
<meta name="description" content="Web site created using create-react-app" />
<link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
<!--
manifest.json provides metadata used when your web app is installed on a
user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
-->
<link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
<!--
Notice the use of %PUBLIC_URL% in the tags above.
It will be replaced with the URL of the `public` folder during the build.
Only files inside the `public` folder can be referenced from the HTML.
Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
work correctly both with client-side routing and a non-root public URL.
Learn how to configure a non-root public URL by running `npm run build`.
-->
<title>React App</title>
</head>
<body>
<noscript>You need to enable JavaScript to run this app.</noscript>
<div id="root"></div>
<!--
This HTML file is a template.
If you open it directly in the browser, you will see an empty page.
You can add webfonts, meta tags, or analytics to this file.
The build step will place the bundled scripts into the <body> tag.
To begin the development, run `npm start` or `yarn start`.
To create a production bundle, use `npm run build` or `yarn build`.
-->
</body>
</html>
================================================
FILE: momoka-node/playground-browser/public/manifest.json
================================================
{
"short_name": "React App",
"name": "Create React App Sample",
"icons": [
{
"src": "favicon.ico",
"sizes": "64x64 32x32 24x24 16x16",
"type": "image/x-icon"
},
{
"src": "logo192.png",
"type": "image/png",
"sizes": "192x192"
},
{
"src": "logo512.png",
"type": "image/png",
"sizes": "512x512"
}
],
"start_url": ".",
"display": "standalone",
"theme_color": "#000000",
"background_color": "#ffffff"
}
================================================
FILE: momoka-node/playground-browser/public/robots.txt
================================================
# https://www.robotstxt.org/robotstxt.html
User-agent: *
Disallow:
================================================
FILE: momoka-node/playground-browser/src/App.css
================================================
.App {
text-align: center;
}
.App-logo {
height: 40vmin;
pointer-events: none;
}
@media (prefers-reduced-motion: no-preference) {
.App-logo {
animation: App-logo-spin infinite 20s linear;
}
}
.App-header {
background-color: #282c34;
min-height: 100vh;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
font-size: calc(10px + 2vmin);
color: white;
}
.App-link {
color: #61dafb;
}
@keyframes App-logo-spin {
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
}
================================================
FILE: momoka-node/playground-browser/src/App.test.tsx
================================================
import React from 'react';
import { render, screen } from '@testing-library/react';
import App from './App';
test('renders learn react link', () => {
render(<App />);
const linkElement = screen.getByText(/learn react/i);
expect(linkElement).toBeInTheDocument();
});
================================================
FILE: momoka-node/playground-browser/src/App.tsx
================================================
import {
checkDAProof,
Deployment,
Environment,
EthereumNode,
} from '@lens-protocol/data-availability-verifier/client';
import './App.css';
const ethereumNode: EthereumNode = {
environment: Environment.AMOY,
nodeUrl: 'INSERT_NODE_URL_HERE',
deployment: Deployment.STAGING,
};
const check = async () => {
const result = await checkDAProof('VlPh9JdZ2SNcnWaqgHFRfycT8xpuoX2MR5LnI95f87w', ethereumNode);
if (result.isSuccess()) {
console.log('proof valid', result.successResult);
return;
}
// it failed!
console.error('proof invalid do something', result.failure);
console.log(ethereumNode);
};
check();
function App() {
return (
<div className="App">
<header className="App-header">
<p>
Edit <code>src/App.tsx</code> and save to reload.
</p>
<a
className="App-link"
href="https://reactjs.org"
target="_blank"
rel="noopener noreferrer"
>
Learn React
</a>
</header>
</div>
);
}
export default App;
================================================
FILE: momoka-node/playground-browser/src/index.css
================================================
body {
margin: 0;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
code {
font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
}
================================================
FILE: momoka-node/playground-browser/src/index.tsx
================================================
import React from 'react';
import ReactDOM from 'react-dom/client';
import './index.css';
import App from './App';
import reportWebVitals from './reportWebVitals';
const root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement);
root.render(
<React.StrictMode>
<App />
</React.StrictMode>
);
// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
reportWebVitals();
================================================
FILE: momoka-node/playground-browser/src/react-app-env.d.ts
================================================
/// <reference types="react-scripts" />
================================================
FILE: momoka-node/playground-browser/src/reportWebVitals.ts
================================================
import { ReportHandler } from 'web-vitals';
const reportWebVitals = (onPerfEntry?: ReportHandler) => {
if (onPerfEntry && onPerfEntry instanceof Function) {
import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
getCLS(onPerfEntry);
getFID(onPerfEntry);
getFCP(onPerfEntry);
getLCP(onPerfEntry);
getTTFB(onPerfEntry);
});
}
};
export default reportWebVitals;
================================================
FILE: momoka-node/playground-browser/src/setupTests.ts
================================================
// jest-dom adds custom jest matchers for asserting on DOM nodes.
// allows you to do things like:
// expect(element).toHaveTextContent(/react/i)
// learn more: https://github.com/testing-library/jest-dom
import '@testing-library/jest-dom';
================================================
FILE: momoka-node/playground-browser/tsconfig.json
================================================
{
"compilerOptions": {
"target": "es5",
"lib": ["dom", "dom.iterable", "esnext"],
"allowJs": true,
"skipLibCheck": true,
"esModuleInterop": true,
"allowSyntheticDefaultImports": true,
"strict": true,
"forceConsistentCasingInFileNames": true,
"noFallthroughCasesInSwitch": true,
"module": "esnext",
"moduleResolution": "node",
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react-jsx"
},
"include": ["src"]
}
================================================
FILE: momoka-node/pnpm-workspace.yaml
================================================
packages:
- 'src/**'
# if required, exclude some directories
- '!**/test/**'
================================================
FILE: momoka-node/render.yaml
================================================
services:
- type: worker
name: momoka
env: docker
dockerfilePath: ./Dockerfile.stable
================================================
FILE: momoka-node/src/__TESTS__/comment.e2e.test.ts
================================================
// apply mocks!
jest.setTimeout(3000);
jest.mock('../input-output/db');
jest.mock('../input-output/bundlr/get-bundlr-by-id.api');
jest.mock('../submitters');
import { MomokaValidatorError } from '..';
import { deepClone } from '../common/helpers';
import { DAPublicationPointerType } from '../data-availability-models/publications/data-availability-structure-publication';
import { commentCreatedDelegateArweaveResponse } from './mocks/comment/comment-created-delegate-arweave-response.mock';
import { commentCreatedWithoutDelegateArweaveResponse } from './mocks/comment/comment-created-without-delegate-arweave-response.mock';
import * as sharedMocks from './mocks/shared.mock';
import { mockTxValidationResult } from './mocks/shared.mock';
describe('comment', () => {
describe('with delegate', () => {
let baseMock = commentCreatedDelegateArweaveResponse;
beforeEach(() => {
baseMock = commentCreatedDelegateArweaveResponse;
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementation(async () =>
deepClone(commentCreatedDelegateArweaveResponse)
);
});
describe('should return success when', () => {
test('signed by delegate is true', async () => {
expect(baseMock.chainProofs.thisPublication.signedByDelegate).toBe(true);
});
test('txExists in the db already', async () => {
sharedMocks.mockGetTxDb.mockImplementationOnce(async () => null);
const result = await sharedMocks.callCheckDAProof();
expect(result.isSuccess()).toBe(true);
});
test('tx is valid and passes all the simulation checks', async () => {
const result = await sharedMocks.callCheckDAProof();
expect(result.isSuccess()).toBe(true);
});
});
describe('should return failure when', () => {
test('NO_SIGNATURE_SUBMITTER', async () => {
sharedMocks.mockImpl__NO_SIGNATURE_SUBMITTER(baseMock);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.NO_SIGNATURE_SUBMITTER);
});
xtest('INVALID_SIGNATURE_SUBMITTER', async () => {
sharedMocks.mockIsValidSubmitter.mockImplementationOnce(() => false);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.INVALID_SIGNATURE_SUBMITTER);
});
test('TIMESTAMP_PROOF_INVALID_SIGNATURE', async () => {
sharedMocks.mockImpl__TIMESTAMP_PROOF_INVALID_SIGNATURE(baseMock);
await sharedMocks.checkAndValidateDAProof(
MomokaValidatorError.TIMESTAMP_PROOF_INVALID_SIGNATURE
);
});
test('TIMESTAMP_PROOF_NOT_SUBMITTER', async () => {
sharedMocks.mockImpl__TIMESTAMP_PROOF_NOT_SUBMITTER();
await sharedMocks.checkAndValidateDAProof(
MomokaValidatorError.TIMESTAMP_PROOF_NOT_SUBMITTER
);
});
test('INVALID_EVENT_TIMESTAMP', async () => {
sharedMocks.mockImpl__INVALID_EVENT_TIMESTAMP(baseMock);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.INVALID_EVENT_TIMESTAMP);
});
xtest('NOT_CLOSEST_BLOCK', async () => {
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.NOT_CLOSEST_BLOCK);
});
test('PUBLICATION_NO_POINTER', async () => {
sharedMocks.mockImpl__INVALID_POINTER_SET(baseMock, null);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.PUBLICATION_NO_POINTER);
});
test('PUBLICATION_NONE_DA', async () => {
sharedMocks.mockImpl__INVALID_POINTER_SET(baseMock, {
type: DAPublicationPointerType.ON_EVM_CHAIN,
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.PUBLICATION_NONE_DA);
});
test('PUBLICATION_NONCE_INVALID', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
chainProofs: {
...baseMock.chainProofs,
thisPublication: {
...baseMock.chainProofs.thisPublication,
typedData: {
...baseMock.chainProofs.thisPublication.typedData,
value: {
...baseMock.chainProofs.thisPublication.typedData.value,
nonce: 13234452346523,
},
},
},
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.PUBLICATION_NONCE_INVALID);
});
xtest('PUBLICATION_SIGNER_NOT_ALLOWED', async () => {});
test('INVALID_FORMATTED_TYPED_DATA', async () => {
sharedMocks.mockImpl__INVALID_FORMATTED_TYPED_DATA(baseMock);
await sharedMocks.checkAndValidateDAProof(
MomokaValidatorError.INVALID_FORMATTED_TYPED_DATA
);
});
test('EVENT_MISMATCH - pub id does not match simulated result', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
pubId: '0x000000000000002',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - profile id does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
profileId: '0x02',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - contentURI does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
contentURI: '__mocked_content_uri__',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - profileIdPointed does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
profileIdPointed: '0x01',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - pubIdPointed does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
pubIdPointed: '0x01',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - collectModule does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
collectModule: '0x0000000000000000000000000000000000000',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - collectModuleReturnData is not empty bytes', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
collectModuleReturnData: 'not_empty_bytes',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - referenceModule does not match typed data', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
referenceModule: '0x0000000000000000000000000000000000001',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
test('EVENT_MISMATCH - referenceModuleReturnData is not empty bytes', async () => {
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementationOnce(async () => {
return {
...baseMock,
event: {
...baseMock.event,
referenceModuleReturnData: 'not_empty_bytes',
},
};
});
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.EVENT_MISMATCH);
});
xtest('SIMULATION_NODE_COULD_NOT_RUN', async () => {});
xtest('UNKNOWN', () => {});
});
});
describe('without delegate', () => {
let baseMock = commentCreatedWithoutDelegateArweaveResponse;
beforeEach(() => {
baseMock = commentCreatedWithoutDelegateArweaveResponse;
sharedMocks.mockGetDAPublicationByIdAPI.mockImplementation(async () =>
deepClone(commentCreatedWithoutDelegateArweaveResponse)
);
});
describe('should return success when', () => {
test('signed by delegate is false', async () => {
expect(baseMock.chainProofs.thisPublication.signedByDelegate).toBe(false);
});
test('txExists in the db already', async () => {
sharedMocks.mockGetTxDb.mockImplementationOnce(async () => mockTxValidationResult);
const result = await sharedMocks.callCheckDAProof();
expect(result.isSuccess()).toBe(true);
});
test('tx is valid and passes all the simulation checks', async () => {
const result = await sharedMocks.callCheckDAProof();
expect(result.isSuccess()).toBe(true);
});
});
describe('should return failure when', () => {
test('NO_SIGNATURE_SUBMITTER', async () => {
sharedMocks.mockImpl__NO_SIGNATURE_SUBMITTER(baseMock);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.NO_SIGNATURE_SUBMITTER);
});
xtest('INVALID_SIGNATURE_SUBMITTER', async () => {
sharedMocks.mockIsValidSubmitter.mockImplementationOnce(() => false);
await sharedMocks.checkAndValidateDAProof(MomokaValidatorError.INVALID_SIGNATURE_SUBMITTER);
});
test('TIMESTAMP_PROOF_INVALID_SIGNATURE', async () => {
sharedMocks.mockImpl__TIMESTAMP_PROOF_INVALID_SIGNATURE(baseMock);
await sharedMocks.checkAndValidateDAProof(
MomokaValidatorError.TIMESTAMP_PROOF_INVALID_SIGNATURE
);
});
test('TIMESTAMP_PROOF_NOT_SUBMITTER', async () => {
sharedMocks.mockImpl__TIMESTAMP_PROOF_NOT_SUBMI
gitextract_l8vcyy7p/
├── .github/
│ └── workflows/
│ └── dependency-review.yml
├── .gitignore
├── README.md
├── momoka-node/
│ ├── .dockerignore
│ ├── .eslintrc.js
│ ├── .nvmrc
│ ├── .prettierignore
│ ├── .prettierrc
│ ├── CHANGELOG.md
│ ├── Dockerfile
│ ├── Dockerfile.stable
│ ├── LICENSE.txt
│ ├── README.md
│ ├── client/
│ │ └── package.json
│ ├── codegen.yaml
│ ├── jest.config.js
│ ├── package.json
│ ├── playground-browser/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── config-overrides.js
│ │ ├── package.json
│ │ ├── public/
│ │ │ ├── index.html
│ │ │ ├── manifest.json
│ │ │ └── robots.txt
│ │ ├── src/
│ │ │ ├── App.css
│ │ │ ├── App.test.tsx
│ │ │ ├── App.tsx
│ │ │ ├── index.css
│ │ │ ├── index.tsx
│ │ │ ├── react-app-env.d.ts
│ │ │ ├── reportWebVitals.ts
│ │ │ └── setupTests.ts
│ │ └── tsconfig.json
│ ├── pnpm-workspace.yaml
│ ├── render.yaml
│ ├── src/
│ │ ├── __TESTS__/
│ │ │ ├── comment.e2e.test.ts
│ │ │ ├── config/
│ │ │ │ └── jest.setup.js
│ │ │ ├── db.test.ts
│ │ │ ├── mirror.e2e.test.ts
│ │ │ ├── mocks/
│ │ │ │ ├── comment/
│ │ │ │ │ ├── comment-created-delegate-arweave-response.mock.ts
│ │ │ │ │ └── comment-created-without-delegate-arweave-response.mock.ts
│ │ │ │ ├── mirror/
│ │ │ │ │ ├── mirror-created-delegate-comment-arweave-response.mock.ts
│ │ │ │ │ ├── mirror-created-delegate-post-arweave-response.mock.ts
│ │ │ │ │ ├── mirror-created-without-delegate-comment-arweave-response.mock.ts
│ │ │ │ │ └── mirror-created-without-delegate-post-arweave-response.mock.ts
│ │ │ │ ├── post/
│ │ │ │ │ ├── post-created-delegate-arweave-response.mock.ts
│ │ │ │ │ └── post-created-without-delegate-arweave-response.mock.ts
│ │ │ │ └── shared.mock.ts
│ │ │ ├── post.e2e.test.ts
│ │ │ ├── publications/
│ │ │ │ └── publication.base.test.ts
│ │ │ ├── random.test.ts
│ │ │ └── submitters.test.ts
│ │ ├── bin/
│ │ │ └── cli.ts
│ │ ├── client/
│ │ │ ├── axios-provider.ts
│ │ │ ├── check-da-proof-client.ts
│ │ │ ├── client-da-proof-gateway.ts
│ │ │ ├── client-da-proof-verifier.ts
│ │ │ └── index.ts
│ │ ├── common/
│ │ │ ├── environment.ts
│ │ │ ├── helpers.ts
│ │ │ ├── in-memory-store.ts
│ │ │ └── logger.ts
│ │ ├── data-availability-models/
│ │ │ ├── da-result.ts
│ │ │ ├── data-availability-action-types.ts
│ │ │ ├── data-availability-provider.ts
│ │ │ ├── data-availability-structure-base.ts
│ │ │ ├── data-availability-timestamp-proofs.ts
│ │ │ ├── data-availability-typed-data.ts
│ │ │ ├── publications/
│ │ │ │ ├── data-availability-publication-typed-data.ts
│ │ │ │ ├── data-availability-structure-publication.ts
│ │ │ │ └── data-availability-structure-publications-events.ts
│ │ │ └── validator-errors.ts
│ │ ├── evm/
│ │ │ ├── abi-types/
│ │ │ │ ├── LensHubV1.ts
│ │ │ │ ├── LensHubV1Events.ts
│ │ │ │ ├── LensHubV2.ts
│ │ │ │ └── LensHubV2Events.ts
│ │ │ ├── anvil.ts
│ │ │ ├── contract-lens/
│ │ │ │ ├── lens-hub-v1-contract-abi.ts
│ │ │ │ └── lens-hub-v2-contract-abi.ts
│ │ │ ├── ethereum.ts
│ │ │ ├── gateway/
│ │ │ │ ├── LensHubV1Gateway.ts
│ │ │ │ └── LensHubV2Gateway.ts
│ │ │ └── jsonrpc-methods.ts
│ │ ├── graphql/
│ │ │ ├── data-availability-transactions.graphql
│ │ │ ├── generated.ts
│ │ │ └── urql.client.ts
│ │ ├── index.ts
│ │ ├── input-output/
│ │ │ ├── arweave/
│ │ │ │ └── get-arweave-by-id.api.ts
│ │ │ ├── bundlr/
│ │ │ │ ├── bundlr-config.ts
│ │ │ │ ├── get-bundlr-bulk-txs.api.ts
│ │ │ │ ├── get-bundlr-by-id.api.ts
│ │ │ │ ├── get-data-availability-transactions.api.ts
│ │ │ │ └── get-owner-of-transaction.api.ts
│ │ │ ├── common.ts
│ │ │ ├── db.ts
│ │ │ ├── fetch-with-timeout.ts
│ │ │ ├── json-rpc-with-timeout.ts
│ │ │ ├── lib-curl-provider.ts
│ │ │ ├── paths.ts
│ │ │ ├── post-with-timeout.ts
│ │ │ └── tx-validated-results.ts
│ │ ├── proofs/
│ │ │ ├── check-da-proof.ts
│ │ │ ├── check-da-proofs-batch.ts
│ │ │ ├── da-proof-checker.ts
│ │ │ ├── da-proof-gateway.ts
│ │ │ ├── da-proof-verifier.ts
│ │ │ ├── models/
│ │ │ │ └── check-da-submisson-options.ts
│ │ │ ├── publications/
│ │ │ │ ├── comment/
│ │ │ │ │ ├── da-comment-verifier-v1.ts
│ │ │ │ │ ├── da-comment-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── create-da-publication-verifier.ts
│ │ │ │ ├── da-publication-verifier-v1.ts
│ │ │ │ ├── da-publication-verifier-v2.ts
│ │ │ │ ├── mirror/
│ │ │ │ │ ├── da-mirror-verifier-v1.ts
│ │ │ │ │ ├── da-mirror-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── post/
│ │ │ │ │ ├── da-post-verifier-v1.ts
│ │ │ │ │ ├── da-post-verifier-v2.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── publication.base.ts
│ │ │ │ └── quote/
│ │ │ │ ├── da-quote-verifier-v2.ts
│ │ │ │ └── index.ts
│ │ │ └── utils.ts
│ │ ├── queue/
│ │ │ ├── base.queue.ts
│ │ │ ├── known.queue.ts
│ │ │ ├── process-failed-da-proof.queue.ts
│ │ │ ├── process-retry-check-da-proofs.queue.ts
│ │ │ └── startup.queue.ts
│ │ ├── runnable/
│ │ │ ├── da-verifier-node.runnable.ts
│ │ │ ├── ethereum-node-instance.ts
│ │ │ └── failed-submissons.runnable.ts
│ │ ├── submitters.ts
│ │ ├── utils/
│ │ │ ├── arrays-equal.ts
│ │ │ ├── invariant.ts
│ │ │ └── number-to-hex.ts
│ │ ├── watchers/
│ │ │ ├── failed-submissons.watcher.ts
│ │ │ ├── models/
│ │ │ │ ├── start-da-verifier-node-options.ts
│ │ │ │ └── stream.type.ts
│ │ │ ├── trusting-indexing.watcher.ts
│ │ │ └── verifier.watcher.ts
│ │ └── workers/
│ │ ├── handler-communication.worker.ts
│ │ ├── message-handlers/
│ │ │ ├── bundlr-verify-receipt.worker.ts
│ │ │ ├── evm-verify-message.worker.ts
│ │ │ └── index.ts
│ │ └── worker-pool.ts
│ └── tsconfig.json
└── momoka-rs/
├── Cargo.toml
├── README.md
└── src/
├── abi/
│ └── lens_hub_contract_abi.json
├── bundlr/
│ ├── api.rs
│ ├── mod.rs
│ └── verify.rs
├── cache.rs
├── contracts/
│ ├── lens_hub.rs
│ └── mod.rs
├── environment.rs
├── evm.rs
├── http.rs
├── logger.rs
├── main.rs
├── submitter/
│ ├── mod.rs
│ └── state.rs
├── types/
│ ├── chain_proofs.rs
│ ├── eip721.rs
│ ├── evm_event.rs
│ ├── hex.rs
│ ├── mod.rs
│ ├── profile_id.rs
│ ├── publication_id.rs
│ ├── transaction.rs
│ └── verifier_error.rs
├── utils.rs
└── verifier/
├── mod.rs
├── proof.rs
└── transactions/
├── comment.rs
├── common.rs
├── mirror.rs
├── mod.rs
└── post.rs
SYMBOL INDEX (591 symbols across 93 files)
FILE: momoka-node/playground-browser/src/App.tsx
function App (line 30) | function App() {
FILE: momoka-node/src/bin/cli.ts
type ProgramOptions (line 10) | interface ProgramOptions {
FILE: momoka-node/src/client/axios-provider.ts
class AxiosProvider (line 4) | class AxiosProvider implements FetchProvider {
method get (line 5) | async get<TResponse>(url: string, { timeout }: { timeout: number }): P...
FILE: momoka-node/src/client/client-da-proof-gateway.ts
class ClientDaProofGateway (line 14) | class ClientDaProofGateway implements DAProofsGateway {
method getBlockRange (line 15) | public getBlockRange(blockNumbers: number[], ethereumNode: EthereumNod...
method getDaPublication (line 19) | public getDaPublication(
method getTimestampProofs (line 27) | public getTimestampProofs(
method getTxResultFromCache (line 36) | public getTxResultFromCache(): Promise<TxValidatedResult | null> {
method hasSignatureBeenUsedBefore (line 41) | public hasSignatureBeenUsedBefore(_signature: string): Promise<boolean> {
FILE: momoka-node/src/client/client-da-proof-verifier.ts
class ClientDaProofVerifier (line 21) | class ClientDaProofVerifier implements DAProofsVerifier {
method extractAddress (line 22) | extractAddress(
method verifyTimestampSignature (line 35) | verifyTimestampSignature(
method verifyTransactionSubmitter (line 46) | async verifyTransactionSubmitter(
FILE: momoka-node/src/common/environment.ts
type Environment (line 4) | enum Environment {
type Deployment (line 13) | enum Deployment {
FILE: momoka-node/src/common/helpers.ts
type AsyncFunction (line 114) | type AsyncFunction<T> = () => Promise<T>;
type RetryWithTimeoutOptions (line 116) | interface RetryWithTimeoutOptions {
FILE: momoka-node/src/common/in-memory-store.ts
class InMemoryStore (line 1) | class InMemoryStore {
method constructor (line 5) | constructor() {
method set (line 9) | public set<T>(key: string, value: T): void {
method get (line 13) | public get<TResponse>(key: string): TResponse | undefined {
method has (line 17) | public has(key: string): boolean {
method delete (line 21) | public delete(key: string): boolean {
method clear (line 25) | public clear(): void {
FILE: momoka-node/src/common/logger.ts
type LogFunctionType (line 1) | type LogFunctionType = (message: string, ...optionalParams: unknown[]) =...
type LoggerLevelColours (line 3) | enum LoggerLevelColours {
FILE: momoka-node/src/data-availability-models/da-result.ts
class Success (line 3) | class Success<TSuccess> {
method constructor (line 4) | public constructor(public readonly successResult: TSuccess) {}
method isSuccess (line 6) | public isSuccess(): this is Success<TSuccess> {
method isFailure (line 10) | public isFailure(): this is Failure<never, never> {
class Failure (line 15) | class Failure<TError, TContext = undefined> {
method constructor (line 16) | public constructor(public readonly failure: TError, public context?: T...
method isSuccess (line 18) | public isSuccess(): this is Success<never> {
method isFailure (line 22) | public isFailure(): this is Failure<TError, TContext> {
type DAResult (line 32) | type DAResult<TSuccessResult, TContext = undefined> =
type PromiseResult (line 40) | type PromiseResult<TSuccessResult = void> = Promise<DAResult<TSuccessRes...
type Result (line 46) | type Result<TSuccessResult = void> = DAResult<TSuccessResult>;
function success (line 57) | function success<T>(result: any = undefined): Success<T> {
type PromiseWithContextResult (line 74) | type PromiseWithContextResult<TSuccessResult, TContext> = Promise<
type PromiseWithContextResultOrNull (line 83) | type PromiseWithContextResultOrNull<TSuccessResult, TContext> = Promise<...
FILE: momoka-node/src/data-availability-models/data-availability-action-types.ts
type MomokaActionTypes (line 1) | enum MomokaActionTypes {
FILE: momoka-node/src/data-availability-models/data-availability-provider.ts
type MomokaProvider (line 1) | enum MomokaProvider {
FILE: momoka-node/src/data-availability-models/data-availability-structure-base.ts
type DAStructureBase (line 4) | interface DAStructureBase {
FILE: momoka-node/src/data-availability-models/data-availability-timestamp-proofs.ts
type DATimestampProofs (line 5) | type DATimestampProofs = BundlrTimestampProofs;
type BundlrUploadResponse (line 7) | interface BundlrUploadResponse {
type BundlrTimestampProofs (line 25) | interface BundlrTimestampProofs {
type DATimestampProofsResponse (line 41) | interface DATimestampProofsResponse {
type DAPublicationWithTimestampProofsBatchResult (line 46) | interface DAPublicationWithTimestampProofsBatchResult extends DAPublicat...
FILE: momoka-node/src/data-availability-models/data-availability-typed-data.ts
type TypedDataField (line 1) | interface TypedDataField {
type TypedDataDomain (line 6) | interface TypedDataDomain {
type EIP712TypedDataValueBase (line 13) | interface EIP712TypedDataValueBase {
FILE: momoka-node/src/data-availability-models/publications/data-availability-publication-typed-data.ts
type CreatePostV1EIP712TypedDataValue (line 7) | interface CreatePostV1EIP712TypedDataValue extends EIP712TypedDataValueB...
type CreatePostV2EIP712TypedDataValue (line 16) | interface CreatePostV2EIP712TypedDataValue extends EIP712TypedDataValueB...
type CreatePostV1EIP712TypedData (line 25) | interface CreatePostV1EIP712TypedData {
type CreatePostV2EIP712TypedData (line 33) | interface CreatePostV2EIP712TypedData {
type CreateCommentV1EIP712TypedDataValue (line 41) | interface CreateCommentV1EIP712TypedDataValue extends EIP712TypedDataVal...
type CreateCommentV2EIP712TypedDataValue (line 53) | interface CreateCommentV2EIP712TypedDataValue extends EIP712TypedDataVal...
type CreateCommentV1EIP712TypedData (line 67) | interface CreateCommentV1EIP712TypedData {
type CreateCommentV2EIP712TypedData (line 75) | interface CreateCommentV2EIP712TypedData {
type CreateMirrorV1EIP712TypedDataValue (line 83) | interface CreateMirrorV1EIP712TypedDataValue extends EIP712TypedDataValu...
type CreateMirrorV2EIP712TypedDataValue (line 92) | interface CreateMirrorV2EIP712TypedDataValue extends EIP712TypedDataValu...
type CreateMirrorV1EIP712TypedData (line 102) | interface CreateMirrorV1EIP712TypedData {
type CreateMirrorV2EIP712TypedData (line 110) | interface CreateMirrorV2EIP712TypedData {
type CreatQuoteV2EIP712TypedDataValue (line 118) | interface CreatQuoteV2EIP712TypedDataValue extends EIP712TypedDataValueB...
type CreateQuoteV2EIP712TypedData (line 132) | interface CreateQuoteV2EIP712TypedData {
type PublicationV1TypedData (line 140) | type PublicationV1TypedData =
type PublicationV2TypedData (line 145) | type PublicationV2TypedData =
type PublicationTypedData (line 151) | type PublicationTypedData = PublicationV1TypedData | PublicationV2TypedD...
FILE: momoka-node/src/data-availability-models/publications/data-availability-structure-publication.ts
type DAPublicationPointerType (line 5) | enum DAPublicationPointerType {
type DAStructurePublicationProofs (line 10) | interface DAStructurePublicationProofs<TTypedData extends PublicationTyp...
type DAStructurePublication (line 64) | interface DAStructurePublication<
type DAPublicationsBatchResult (line 85) | interface DAPublicationsBatchResult {
FILE: momoka-node/src/data-availability-models/publications/data-availability-structure-publications-events.ts
type DAPostCreatedEventEmittedResponseV1 (line 14) | type DAPostCreatedEventEmittedResponseV1 = PostCreatedEventEmittedRespon...
type DAPostCreatedEventEmittedResponseV2 (line 15) | type DAPostCreatedEventEmittedResponseV2 = PostCreatedEventEmittedRespon...
type DAPostCreatedEventEmittedResponse (line 16) | type DAPostCreatedEventEmittedResponse =
type DACommentCreatedEventEmittedResponseV1 (line 20) | type DACommentCreatedEventEmittedResponseV1 = CommentCreatedEventEmitted...
type DACommentCreatedEventEmittedResponseV2 (line 21) | type DACommentCreatedEventEmittedResponseV2 = CommentCreatedEventEmitted...
type DACommentCreatedEventEmittedResponse (line 22) | type DACommentCreatedEventEmittedResponse =
type DAMirrorCreatedEventEmittedResponseV1 (line 26) | type DAMirrorCreatedEventEmittedResponseV1 = MirrorCreatedEventEmittedRe...
type DAMirrorCreatedEventEmittedResponseV2 (line 27) | type DAMirrorCreatedEventEmittedResponseV2 = MirrorCreatedEventEmittedRe...
type DAMirrorCreatedEventEmittedResponse (line 28) | type DAMirrorCreatedEventEmittedResponse =
type DAQuoteCreatedEventEmittedResponseV2 (line 32) | type DAQuoteCreatedEventEmittedResponseV2 = QuoteCreatedEventEmittedResp...
type DAQuoteCreatedEventEmittedResponse (line 33) | type DAQuoteCreatedEventEmittedResponse = DAQuoteCreatedEventEmittedResp...
type DAEventTypeV1 (line 35) | type DAEventTypeV1 =
type DAEventTypeV2 (line 40) | type DAEventTypeV2 =
type DAEventType (line 46) | type DAEventType = DAEventTypeV1 | DAEventTypeV2;
FILE: momoka-node/src/data-availability-models/validator-errors.ts
type MomokaValidatorError (line 4) | enum MomokaValidatorError {
FILE: momoka-node/src/evm/abi-types/LensHubV1.ts
type ContractContext (line 4) | type ContractContext = EthersContractContextV5<
type EventFilter (line 11) | type EventFilter = {
type ContractTransactionOverrides (line 18) | interface ContractTransactionOverrides {
type ContractCallOverrides (line 41) | interface ContractCallOverrides {
type LensHubEvents (line 56) | type LensHubEvents = 'Approval' | 'ApprovalForAll' | 'Transfer';
type LensHubEventsContext (line 57) | interface LensHubEventsContext {
type LensHubMethodNames (line 62) | type LensHubMethodNames =
type ApprovalEventEmittedResponse (line 146) | interface ApprovalEventEmittedResponse {
type ApprovalForAllEventEmittedResponse (line 151) | interface ApprovalForAllEventEmittedResponse {
type TransferEventEmittedResponse (line 156) | interface TransferEventEmittedResponse {
type BurnWithSigRequest (line 161) | interface BurnWithSigRequest {
type SigRequest (line 167) | interface SigRequest {
type CollectWithSigRequest (line 173) | interface CollectWithSigRequest {
type CommentRequest (line 180) | interface CommentRequest {
type CommentWithSigRequest (line 191) | interface CommentWithSigRequest {
type CommentWithSig_DispatcherRequest (line 203) | interface CommentWithSig_DispatcherRequest {
type CreateProfileRequest (line 215) | interface CreateProfileRequest {
type FollowWithSigRequest (line 223) | interface FollowWithSigRequest {
type ProfileResponse (line 229) | interface ProfileResponse {
type PublicationResponse (line 243) | interface PublicationResponse {
type GetPubPointerResponse (line 257) | interface GetPubPointerResponse {
type MirrorRequest (line 264) | interface MirrorRequest {
type MirrorWithSigRequest (line 272) | interface MirrorWithSigRequest {
type MirrorWithSig_DispatcherRequest (line 281) | interface MirrorWithSig_DispatcherRequest {
type PermitRequest (line 290) | interface PermitRequest {
type PermitForAllRequest (line 296) | interface PermitForAllRequest {
type PostRequest (line 302) | interface PostRequest {
type PostWithSigRequest (line 310) | interface PostWithSigRequest {
type PostWithSig_DispatcherRequest (line 319) | interface PostWithSig_DispatcherRequest {
type SetDefaultProfileWithSigRequest (line 328) | interface SetDefaultProfileWithSigRequest {
type SetDispatcherWithSigRequest (line 333) | interface SetDispatcherWithSigRequest {
type SetFollowModuleWithSigRequest (line 338) | interface SetFollowModuleWithSigRequest {
type SetFollowNFTURIWithSigRequest (line 344) | interface SetFollowNFTURIWithSigRequest {
type SetProfileImageURIWithSigRequest (line 349) | interface SetProfileImageURIWithSigRequest {
type TokendataResponse (line 354) | interface TokendataResponse {
type LensHubV1 (line 360) | interface LensHubV1 {
FILE: momoka-node/src/evm/abi-types/LensHubV1Events.ts
type ContractContext (line 4) | type ContractContext = EthersContractContextV5<
type EventFilter (line 11) | type EventFilter = {
type ContractTransactionOverrides (line 18) | interface ContractTransactionOverrides {
type ContractCallOverrides (line 41) | interface ContractCallOverrides {
type LensHubEventsEvents (line 51) | type LensHubEventsEvents =
type LensHubEventsEventsContext (line 87) | interface LensHubEventsEventsContext {
type LensHubEventsMethodNames (line 124) | type LensHubEventsMethodNames = undefined;
type BaseInitializedEventEmittedResponse (line 125) | interface BaseInitializedEventEmittedResponse {
type CollectModuleWhitelistedEventEmittedResponse (line 130) | interface CollectModuleWhitelistedEventEmittedResponse {
type CollectNFTDeployedEventEmittedResponse (line 135) | interface CollectNFTDeployedEventEmittedResponse {
type CollectNFTInitializedEventEmittedResponse (line 141) | interface CollectNFTInitializedEventEmittedResponse {
type CollectNFTTransferredEventEmittedResponse (line 146) | interface CollectNFTTransferredEventEmittedResponse {
type CollectedEventEmittedResponse (line 154) | interface CollectedEventEmittedResponse {
type CommentCreatedEventEmittedResponse (line 163) | interface CommentCreatedEventEmittedResponse {
type DefaultProfileSetEventEmittedResponse (line 176) | interface DefaultProfileSetEventEmittedResponse {
type DispatcherSetEventEmittedResponse (line 181) | interface DispatcherSetEventEmittedResponse {
type EmergencyAdminSetEventEmittedResponse (line 186) | interface EmergencyAdminSetEventEmittedResponse {
type FeeModuleBaseConstructedEventEmittedResponse (line 192) | interface FeeModuleBaseConstructedEventEmittedResponse {
type FollowModuleSetEventEmittedResponse (line 196) | interface FollowModuleSetEventEmittedResponse {
type FollowModuleWhitelistedEventEmittedResponse (line 202) | interface FollowModuleWhitelistedEventEmittedResponse {
type FollowNFTDelegatedPowerChangedEventEmittedResponse (line 207) | interface FollowNFTDelegatedPowerChangedEventEmittedResponse {
type FollowNFTDeployedEventEmittedResponse (line 212) | interface FollowNFTDeployedEventEmittedResponse {
type FollowNFTInitializedEventEmittedResponse (line 217) | interface FollowNFTInitializedEventEmittedResponse {
type FollowNFTTransferredEventEmittedResponse (line 221) | interface FollowNFTTransferredEventEmittedResponse {
type FollowNFTURISetEventEmittedResponse (line 228) | interface FollowNFTURISetEventEmittedResponse {
type FollowedEventEmittedResponse (line 233) | interface FollowedEventEmittedResponse {
type FollowsApprovedEventEmittedResponse (line 239) | interface FollowsApprovedEventEmittedResponse {
type FollowsToggledEventEmittedResponse (line 246) | interface FollowsToggledEventEmittedResponse {
type GovernanceSetEventEmittedResponse (line 252) | interface GovernanceSetEventEmittedResponse {
type MirrorCreatedEventEmittedResponse (line 258) | interface MirrorCreatedEventEmittedResponse {
type ModuleBaseConstructedEventEmittedResponse (line 268) | interface ModuleBaseConstructedEventEmittedResponse {
type ModuleGlobalsCurrencyWhitelistedEventEmittedResponse (line 272) | interface ModuleGlobalsCurrencyWhitelistedEventEmittedResponse {
type ModuleGlobalsGovernanceSetEventEmittedResponse (line 278) | interface ModuleGlobalsGovernanceSetEventEmittedResponse {
type ModuleGlobalsTreasuryFeeSetEventEmittedResponse (line 283) | interface ModuleGlobalsTreasuryFeeSetEventEmittedResponse {
type ModuleGlobalsTreasurySetEventEmittedResponse (line 288) | interface ModuleGlobalsTreasurySetEventEmittedResponse {
type PostCreatedEventEmittedResponse (line 293) | interface PostCreatedEventEmittedResponse {
type ProfileCreatedEventEmittedResponse (line 303) | interface ProfileCreatedEventEmittedResponse {
type ProfileCreatorWhitelistedEventEmittedResponse (line 314) | interface ProfileCreatorWhitelistedEventEmittedResponse {
type ProfileImageURISetEventEmittedResponse (line 319) | interface ProfileImageURISetEventEmittedResponse {
type ProfileMetadataSetEventEmittedResponse (line 324) | interface ProfileMetadataSetEventEmittedResponse {
type ReferenceModuleWhitelistedEventEmittedResponse (line 329) | interface ReferenceModuleWhitelistedEventEmittedResponse {
type StateSetEventEmittedResponse (line 334) | interface StateSetEventEmittedResponse {
type LensHubV1Events (line 340) | interface LensHubV1Events {}
FILE: momoka-node/src/evm/abi-types/LensHubV2.ts
type ContractContext (line 4) | type ContractContext = EthersContractContextV5<
type EventFilter (line 11) | interface EventFilter {
type ContractTransactionOverrides (line 18) | interface ContractTransactionOverrides {
type ContractCallOverrides (line 41) | interface ContractCallOverrides {
type LensHubEvents (line 55) | type LensHubEvents = 'Approval' | 'ApprovalForAll' | 'Transfer';
type LensHubEventsContext (line 56) | interface LensHubEventsContext {
type LensHubMethodNames (line 61) | type LensHubMethodNames =
type MigrationParamsRequest (line 147) | interface MigrationParamsRequest {
type ApprovalEventEmittedResponse (line 155) | interface ApprovalEventEmittedResponse {
type ApprovalForAllEventEmittedResponse (line 160) | interface ApprovalForAllEventEmittedResponse {
type TransferEventEmittedResponse (line 165) | interface TransferEventEmittedResponse {
type PublicationActionParamsRequest (line 170) | interface PublicationActionParamsRequest {
type SignatureRequest (line 179) | interface SignatureRequest {
type CollectParamsRequest (line 186) | interface CollectParamsRequest {
type CommentParamsRequest (line 194) | interface CommentParamsRequest {
type CreateProfileParamsRequest (line 207) | interface CreateProfileParamsRequest {
type ProfileResponse (line 212) | interface ProfileResponse {
type PublicationmemoryResponse (line 228) | interface PublicationmemoryResponse {
type GetTreasuryDataResponse (line 248) | interface GetTreasuryDataResponse {
type MirrorParamsRequest (line 255) | interface MirrorParamsRequest {
type PostParamsRequest (line 264) | interface PostParamsRequest {
type QuoteParamsRequest (line 272) | interface QuoteParamsRequest {
type RoyaltyInfoResponse (line 285) | interface RoyaltyInfoResponse {
type TokendataResponse (line 292) | interface TokendataResponse {
type LensHub (line 298) | interface LensHub {
FILE: momoka-node/src/evm/abi-types/LensHubV2Events.ts
type ContractContext (line 4) | type ContractContext = EthersContractContextV5<
type EventFilter (line 11) | interface EventFilter {
type ContractTransactionOverrides (line 18) | interface ContractTransactionOverrides {
type ContractCallOverrides (line 41) | interface ContractCallOverrides {
type LensHubEventsEvents (line 51) | type LensHubEventsEvents =
type LensHubEventsEventsContext (line 86) | interface LensHubEventsEventsContext {
type LensHubEventsMethodNames (line 122) | type LensHubEventsMethodNames = undefined;
type PublicationActionParamsEventEmittedResponse (line 123) | interface PublicationActionParamsEventEmittedResponse {
type ActedEventEmittedResponse (line 132) | interface ActedEventEmittedResponse {
type ActionModuleWhitelistedEventEmittedResponse (line 138) | interface ActionModuleWhitelistedEventEmittedResponse {
type BaseInitializedEventEmittedResponse (line 144) | interface BaseInitializedEventEmittedResponse {
type BlockedEventEmittedResponse (line 149) | interface BlockedEventEmittedResponse {
type CollectNFTDeployedEventEmittedResponse (line 155) | interface CollectNFTDeployedEventEmittedResponse {
type CollectNFTTransferredEventEmittedResponse (line 161) | interface CollectNFTTransferredEventEmittedResponse {
type CollectedEventEmittedResponse (line 169) | interface CollectedEventEmittedResponse {
type CommentParamsEventEmittedResponse (line 181) | interface CommentParamsEventEmittedResponse {
type CommentCreatedEventEmittedResponse (line 194) | interface CommentCreatedEventEmittedResponse {
type DelegatedExecutorsConfigAppliedEventEmittedResponse (line 203) | interface DelegatedExecutorsConfigAppliedEventEmittedResponse {
type DelegatedExecutorsConfigChangedEventEmittedResponse (line 208) | interface DelegatedExecutorsConfigChangedEventEmittedResponse {
type EmergencyAdminSetEventEmittedResponse (line 215) | interface EmergencyAdminSetEventEmittedResponse {
type FollowModuleSetEventEmittedResponse (line 221) | interface FollowModuleSetEventEmittedResponse {
type FollowModuleWhitelistedEventEmittedResponse (line 229) | interface FollowModuleWhitelistedEventEmittedResponse {
type FollowNFTDeployedEventEmittedResponse (line 234) | interface FollowNFTDeployedEventEmittedResponse {
type FollowedEventEmittedResponse (line 239) | interface FollowedEventEmittedResponse {
type GovernanceSetEventEmittedResponse (line 248) | interface GovernanceSetEventEmittedResponse {
type MirrorParamsEventEmittedResponse (line 254) | interface MirrorParamsEventEmittedResponse {
type MirrorCreatedEventEmittedResponse (line 263) | interface MirrorCreatedEventEmittedResponse {
type ModuleGlobalsCurrencyWhitelistedEventEmittedResponse (line 270) | interface ModuleGlobalsCurrencyWhitelistedEventEmittedResponse {
type ModuleGlobalsGovernanceSetEventEmittedResponse (line 276) | interface ModuleGlobalsGovernanceSetEventEmittedResponse {
type ModuleGlobalsTreasuryFeeSetEventEmittedResponse (line 281) | interface ModuleGlobalsTreasuryFeeSetEventEmittedResponse {
type ModuleGlobalsTreasurySetEventEmittedResponse (line 286) | interface ModuleGlobalsTreasurySetEventEmittedResponse {
type PostParamsEventEmittedResponse (line 291) | interface PostParamsEventEmittedResponse {
type PostCreatedEventEmittedResponse (line 299) | interface PostCreatedEventEmittedResponse {
type ProfileCreatedEventEmittedResponse (line 307) | interface ProfileCreatedEventEmittedResponse {
type ProfileCreatorWhitelistedEventEmittedResponse (line 313) | interface ProfileCreatorWhitelistedEventEmittedResponse {
type ProfileMetadataSetEventEmittedResponse (line 318) | interface ProfileMetadataSetEventEmittedResponse {
type QuoteParamsEventEmittedResponse (line 324) | interface QuoteParamsEventEmittedResponse {
type QuoteCreatedEventEmittedResponse (line 337) | interface QuoteCreatedEventEmittedResponse {
type ReferenceModuleWhitelistedEventEmittedResponse (line 346) | interface ReferenceModuleWhitelistedEventEmittedResponse {
type StateSetEventEmittedResponse (line 351) | interface StateSetEventEmittedResponse {
type TokenGuardianStateChangedEventEmittedResponse (line 357) | interface TokenGuardianStateChangedEventEmittedResponse {
type UnblockedEventEmittedResponse (line 363) | interface UnblockedEventEmittedResponse {
type UnfollowedEventEmittedResponse (line 369) | interface UnfollowedEventEmittedResponse {
type NonceUpdatedEventEmittedResponse (line 375) | interface NonceUpdatedEventEmittedResponse {
type LensUpgradeVersionEventEmittedResponse (line 380) | interface LensUpgradeVersionEventEmittedResponse {
type CollectedLegacyEventEmittedResponse (line 386) | interface CollectedLegacyEventEmittedResponse {
type LensHubEvents (line 398) | interface LensHubEvents {}
FILE: momoka-node/src/evm/anvil.ts
constant LOCAL_NODE_URL (line 23) | const LOCAL_NODE_URL = 'http://127.0.0.1:8545/';
FILE: momoka-node/src/evm/contract-lens/lens-hub-v1-contract-abi.ts
constant LENS_HUB_V1_ABI (line 1) | const LENS_HUB_V1_ABI = [
FILE: momoka-node/src/evm/contract-lens/lens-hub-v2-contract-abi.ts
constant LENS_HUB_V2_ABI (line 1) | const LENS_HUB_V2_ABI = [
FILE: momoka-node/src/evm/ethereum.ts
type EthereumNode (line 10) | interface EthereumNode {
constant EMPTY_BYTE (line 20) | const EMPTY_BYTE = '0x';
type BlockInfo (line 124) | interface BlockInfo {
FILE: momoka-node/src/evm/gateway/LensHubV1Gateway.ts
class LensHubV1Gateway (line 19) | class LensHubV1Gateway {
method constructor (line 20) | constructor(private readonly ethereumNode: EthereumNode) {}
method generatePostSimulationData (line 29) | generatePostSimulationData(
method getOnChainProfileDetails (line 52) | async getOnChainProfileDetails(
method getLensPubCount (line 161) | async getLensPubCount(profileId: string, blockNumber: number): Promise...
FILE: momoka-node/src/evm/gateway/LensHubV2Gateway.ts
class LensHubV2Gateway (line 19) | class LensHubV2Gateway {
method constructor (line 20) | constructor(private readonly ethereumNode: EthereumNode) {}
method generatePostSimulationData (line 29) | generatePostSimulationData(
method getOnChainProfileDetails (line 49) | async getOnChainProfileDetails(
method getLensPubCount (line 163) | async getLensPubCount(profileId: string, blockNumber: number): Promise...
FILE: momoka-node/src/evm/jsonrpc-methods.ts
type JSONRPCMethods (line 4) | enum JSONRPCMethods {
FILE: momoka-node/src/graphql/generated.ts
type Maybe (line 2) | type Maybe<T> = T | null;
type InputMaybe (line 3) | type InputMaybe<T> = Maybe<T>;
type Exact (line 4) | type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K...
type MakeOptional (line 5) | type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?:...
type MakeMaybe (line 6) | type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: May...
type Scalars (line 8) | type Scalars = {
type PageInfo (line 17) | type PageInfo = {
type Query (line 23) | type Query = {
type QueryTransactionsArgs (line 28) | type QueryTransactionsArgs = {
type Receipt (line 39) | type Receipt = {
type SortOrder (line 46) | enum SortOrder {
type Tag (line 51) | type Tag = {
type TagFilter (line 57) | type TagFilter = {
type Transaction (line 62) | type Transaction = {
type TransactionConnection (line 73) | type TransactionConnection = {
type TransactionEdge (line 79) | type TransactionEdge = {
type DataAvailabilityTransactionsQueryVariables (line 85) | type DataAvailabilityTransactionsQueryVariables = Exact<{
type DataAvailabilityTransactionsQuery (line 91) | type DataAvailabilityTransactionsQuery = {
FILE: momoka-node/src/input-output/bundlr/bundlr-config.ts
constant BUNDLR_NODE (line 4) | const BUNDLR_NODE = 'https://lens.bundlr.network/';
constant BUNDLR_NODE_GRAPHQL (line 9) | const BUNDLR_NODE_GRAPHQL = `${BUNDLR_NODE}graphql`;
constant BUNDLR_NODE_TX (line 14) | const BUNDLR_NODE_TX = `${BUNDLR_NODE}tx/`;
constant BUNDLR_GATEWAY (line 19) | const BUNDLR_GATEWAY = 'https://lens-gateway.bundlr.network/';
constant BUNDLR_GATEWAY_TX (line 24) | const BUNDLR_GATEWAY_TX = `${BUNDLR_GATEWAY}tx/`;
FILE: momoka-node/src/input-output/bundlr/get-bundlr-bulk-txs.api.ts
type BundlrBulkTxSuccess (line 9) | interface BundlrBulkTxSuccess {
type BundlrBulkTxsResponse (line 18) | interface BundlrBulkTxsResponse {
FILE: momoka-node/src/input-output/bundlr/get-data-availability-transactions.api.ts
type getDataAvailabilityTransactionsAPIResponse (line 9) | interface getDataAvailabilityTransactionsAPIResponse {
type DataAvailabilityTransactionsOrderTypes (line 23) | enum DataAvailabilityTransactionsOrderTypes {
FILE: momoka-node/src/input-output/bundlr/get-owner-of-transaction.api.ts
type BundlrTx (line 9) | interface BundlrTx {
FILE: momoka-node/src/input-output/common.ts
constant TIMEOUT_ERROR (line 1) | const TIMEOUT_ERROR = 'timeout';
type TimeoutError (line 2) | type TimeoutError = 'timeout';
FILE: momoka-node/src/input-output/db.ts
type DbReference (line 16) | enum DbReference {
FILE: momoka-node/src/input-output/fetch-with-timeout.ts
type FetchProvider (line 1) | interface FetchProvider {
FILE: momoka-node/src/input-output/json-rpc-with-timeout.ts
constant RATE_LIMIT_TIME (line 5) | const RATE_LIMIT_TIME = 1000;
FILE: momoka-node/src/input-output/paths.ts
type PathType (line 1) | type PathType = {
FILE: momoka-node/src/input-output/tx-validated-results.ts
type TxValidatedResult (line 8) | type TxValidatedResult = TxValidatedFailureResult | TxValidatedSuccessRe...
type TxValidatedResultBase (line 10) | interface TxValidatedResultBase<TSuccess extends boolean, TDAStructurePu...
type TxValidatedFailureResult (line 16) | interface TxValidatedFailureResult
type TxValidatedSuccessResult (line 26) | interface TxValidatedSuccessResult
FILE: momoka-node/src/proofs/check-da-proofs-batch.ts
type ProofResult (line 159) | interface ProofResult {
FILE: momoka-node/src/proofs/da-proof-checker.ts
type ValidType (line 34) | type ValidType = typeof validResult;
type DAProofsVerifier (line 36) | interface DAProofsVerifier {
type DAProofsGateway (line 60) | interface DAProofsGateway {
class DaProofChecker (line 71) | class DaProofChecker {
method constructor (line 72) | constructor(private verifier: DAProofsVerifier, private gateway: DAPro...
method validatesTimestampProof (line 298) | private async validatesTimestampProof(
method getBlockRange (line 339) | private async getBlockRange(
method validateChoosenBlock (line 360) | private async validateChoosenBlock(
method checkDAPublication (line 430) | private async checkDAPublication(
method txAlreadyChecked (line 495) | private async txAlreadyChecked(
FILE: momoka-node/src/proofs/da-proof-gateway.ts
class DaProofGateway (line 22) | class DaProofGateway implements DAProofsGateway {
method hasSignatureBeenUsedBefore (line 23) | public hasSignatureBeenUsedBefore(signature: string): Promise<boolean> {
method getTxResultFromCache (line 27) | public getTxResultFromCache(txId: string): Promise<TxValidatedResult |...
method getBlockRange (line 32) | public getBlockRange(blockNumbers: number[], ethereumNode: EthereumNod...
method getDaPublication (line 50) | public async getDaPublication(
method getTimestampProofs (line 62) | public async getTimestampProofs(
FILE: momoka-node/src/proofs/da-proof-verifier.ts
class DaProofVerifier (line 17) | class DaProofVerifier implements DAProofsVerifier {
method extractAddress (line 18) | public extractAddress(
method verifyTimestampSignature (line 37) | public verifyTimestampSignature(
method verifyTransactionSubmitter (line 48) | public async verifyTransactionSubmitter(
FILE: momoka-node/src/proofs/models/check-da-submisson-options.ts
type CheckDASubmissionOptions (line 3) | interface CheckDASubmissionOptions {
FILE: momoka-node/src/proofs/publications/comment/da-comment-verifier-v1.ts
type DACommentPublicationV1 (line 12) | type DACommentPublicationV1 = DAStructurePublication<
class DACommentVerifierV1 (line 26) | class DACommentVerifierV1 extends DAPublicationVerifierV1 {
method constructor (line 29) | constructor(
method verifyEventWithTypedData (line 37) | public verifyEventWithTypedData(pubCountAtBlock: string): PromiseResult {
FILE: momoka-node/src/proofs/publications/comment/da-comment-verifier-v2.ts
type DACommentPublicationV2 (line 14) | type DACommentPublicationV2 = DAStructurePublication<
class DACommentVerifierV2 (line 28) | class DACommentVerifierV2 extends DAPublicationVerifierV2 {
method constructor (line 31) | constructor(
method verifyPublicationIdMatches (line 39) | verifyPublicationIdMatches(): PromiseResult {
method verifyEventWithTypedData (line 55) | verifyEventWithTypedData(pubCountAtBlock: string): PromiseResult {
FILE: momoka-node/src/proofs/publications/create-da-publication-verifier.ts
type DAPublicationVerifier (line 15) | type DAPublicationVerifier =
FILE: momoka-node/src/proofs/publications/da-publication-verifier-v1.ts
method constructor (line 15) | constructor(
method verifyPublicationIdMatches (line 23) | public verifyPublicationIdMatches(): PromiseResult {
method verifySigner (line 39) | public async verifySigner(): PromiseResult<{
FILE: momoka-node/src/proofs/publications/da-publication-verifier-v2.ts
method constructor (line 14) | constructor(
method verifySigner (line 24) | public async verifySigner(): PromiseResult<{
FILE: momoka-node/src/proofs/publications/mirror/da-mirror-verifier-v1.ts
type DAMirrorPublicationV1 (line 12) | type DAMirrorPublicationV1 = DAStructurePublication<
class DAMirrorVerifierV1 (line 26) | class DAMirrorVerifierV1 extends DAPublicationVerifierV1 {
method constructor (line 29) | constructor(
method verifyEventWithTypedData (line 37) | verifyEventWithTypedData(pubCountAtBlock: string): PromiseResult {
FILE: momoka-node/src/proofs/publications/mirror/da-mirror-verifier-v2.ts
type DAMirrorPublicationV2 (line 14) | type DAMirrorPublicationV2 = DAStructurePublication<
class DAMirrorVerifierV2 (line 27) | class DAMirrorVerifierV2 extends DAPublicationVerifierV2 {
method constructor (line 30) | constructor(
method verifyPublicationIdMatches (line 38) | verifyPublicationIdMatches(): PromiseResult {
method verifyEventWithTypedData (line 54) | verifyEventWithTypedData(pubCountAtBlock: string): PromiseResult {
FILE: momoka-node/src/proofs/publications/post/da-post-verifier-v1.ts
type DAPostPublicationV1 (line 19) | type DAPostPublicationV1 = DAStructurePublication<
class DAPostVerifierV1 (line 32) | class DAPostVerifierV1 extends DAPublicationVerifierV1 {
method constructor (line 35) | constructor(
method verifySimulation (line 43) | async verifySimulation(): PromiseResult<string> {
method verifyEventWithTypedData (line 115) | verifyEventWithTypedData(simulatedPubResult: string): PromiseResult {
method getExpectedResult (line 148) | private async getExpectedResult(
FILE: momoka-node/src/proofs/publications/post/da-post-verifier-v2.ts
type DAPostPublicationV2 (line 22) | type DAPostPublicationV2 = DAStructurePublication<
class DAPostVerifierV2 (line 35) | class DAPostVerifierV2 extends DAPublicationVerifierV2 {
method constructor (line 38) | constructor(
method verifyPublicationIdMatches (line 46) | verifyPublicationIdMatches(): PromiseResult {
method verifySimulation (line 62) | async verifySimulation(): PromiseResult<string> {
method verifyEventWithTypedData (line 154) | verifyEventWithTypedData(simulatedPubResult: string): PromiseResult {
method getExpectedResult (line 190) | private async getExpectedResult(
FILE: momoka-node/src/proofs/publications/quote/da-quote-verifier-v2.ts
type DAQuotePublicationV2 (line 14) | type DAQuotePublicationV2 = DAStructurePublication<
class DAQuoteVerifierV2 (line 27) | class DAQuoteVerifierV2 extends DAPublicationVerifierV2 {
method constructor (line 30) | constructor(
method verifyPublicationIdMatches (line 38) | verifyPublicationIdMatches(): PromiseResult {
method verifyEventWithTypedData (line 54) | verifyEventWithTypedData(pubCountAtBlock: string): PromiseResult {
FILE: momoka-node/src/proofs/utils.ts
type Providers (line 70) | type Providers = {
FILE: momoka-node/src/queue/base.queue.ts
class Queue (line 6) | class Queue<T> {
method constructor (line 9) | constructor() {
method enqueue (line 13) | public enqueue(item: T): void {
method enqueueWithDelay (line 22) | public async enqueueWithDelay(item: T, delay: number): Promise<void> {
method dequeue (line 27) | public dequeue(): T | undefined {
method isEmpty (line 34) | public isEmpty(): boolean {
FILE: momoka-node/src/queue/process-failed-da-proof.queue.ts
type ProcessFailedProofQueueRequest (line 8) | interface ProcessFailedProofQueueRequest {
FILE: momoka-node/src/queue/process-retry-check-da-proofs.queue.ts
type ProcessRetryCheckDAProofsQueueRequest (line 9) | interface ProcessRetryCheckDAProofsQueueRequest {
FILE: momoka-node/src/utils/invariant.ts
class InvariantError (line 1) | class InvariantError extends Error {
method constructor (line 2) | constructor(message: string) {
type Invariant (line 7) | type Invariant = (condition: unknown, message: string) => asserts condit...
FILE: momoka-node/src/watchers/models/start-da-verifier-node-options.ts
type StartDAVerifierNodeOptions (line 6) | interface StartDAVerifierNodeOptions {
FILE: momoka-node/src/watchers/models/stream.type.ts
type StreamResult (line 3) | type StreamResult = TxValidatedResult;
type StreamCallback (line 4) | type StreamCallback = (result: StreamResult) => void;
FILE: momoka-node/src/watchers/trusting-indexing.watcher.ts
type StartDATrustingIndexingRequest (line 17) | interface StartDATrustingIndexingRequest {
FILE: momoka-node/src/watchers/verifier.watcher.ts
type BulkDataAvailabilityTransactionsResponse (line 86) | interface BulkDataAvailabilityTransactionsResponse {
FILE: momoka-node/src/workers/handler-communication.worker.ts
type EVMVerifyMessageHandlerWorkerRequest (line 9) | type EVMVerifyMessageHandlerWorkerRequest = HandlerWorkerRequest<
type BundlrVerifyReceiptHandlerWorkerRequest (line 14) | type BundlrVerifyReceiptHandlerWorkerRequest = HandlerWorkerRequest<
type HandlerWorkers (line 19) | enum HandlerWorkers {
type HandlerWorkerRequest (line 24) | interface HandlerWorkerRequest<THandlerWorkers extends HandlerWorkers, T> {
type HandlerWorkerData (line 29) | type HandlerWorkerData =
FILE: momoka-node/src/workers/message-handlers/bundlr-verify-receipt.worker.ts
type BundlrVerifyReceiptWorkerRequest (line 8) | interface BundlrVerifyReceiptWorkerRequest {
FILE: momoka-node/src/workers/message-handlers/evm-verify-message.worker.ts
type EVMVerifyMessageWorkerRequest (line 8) | interface EVMVerifyMessageWorkerRequest {
FILE: momoka-node/src/workers/worker-pool.ts
class WorkerPool (line 8) | class WorkerPool {
method constructor (line 12) | constructor() {
method execute (line 27) | public execute<T>(request: HandlerWorkerData): Promise<T> {
FILE: momoka-rs/src/bundlr/api.rs
type BundlrEndpoint (line 20) | enum BundlrEndpoint {
method url (line 31) | pub fn url(&self) -> &str {
type BundlrTransactions (line 43) | pub struct BundlrTransactions {
type BundlrTransactionEdge (line 56) | pub struct BundlrTransactionEdge {
type BundlrTransactionNode (line 68) | pub struct BundlrTransactionNode {
type BundlrTransactionPageInfo (line 81) | pub struct BundlrTransactionPageInfo {
type TransactionsAPIResponse (line 93) | pub struct TransactionsAPIResponse {
type TransactionOrder (line 99) | pub enum TransactionOrder {
function get_transactions_query (line 115) | fn get_transactions_query(
function get_transactions_api (line 163) | pub async fn get_transactions_api(
type BulkTransactionsIdsAPIResponse (line 184) | pub struct BulkTransactionsIdsAPIResponse {
function get_last_transaction_api (line 199) | pub async fn get_last_transaction_api(
function get_bulk_transactions_ids_api (line 241) | pub async fn get_bulk_transactions_ids_api(
type BundlrTransactionBase64 (line 290) | pub struct BundlrTransactionBase64 {
type BundlrBulkTransactionsResponse (line 298) | pub struct BundlrBulkTransactionsResponse<TSuccess> {
function get_bulk_transactions_base_64_api (line 331) | async fn get_bulk_transactions_base_64_api(
function from_base_64 (line 372) | async fn from_base_64<TResult>(
function transaction_builder (line 419) | fn transaction_builder(
function transaction_timestamp_proofs_builder (line 473) | fn transaction_timestamp_proofs_builder(
function get_transaction_api (line 505) | pub async fn get_transaction_api(
constant CHUNK_SIZE (line 518) | pub const CHUNK_SIZE: usize = 1000;
function get_bulk_transactions_api (line 555) | pub async fn get_bulk_transactions_api(
FILE: momoka-rs/src/bundlr/verify.rs
function verify_timestamp_proofs (line 35) | pub async fn verify_timestamp_proofs(
function test_verify_timestamp_proofs (line 63) | async fn test_verify_timestamp_proofs() {
FILE: momoka-rs/src/cache.rs
type TransactionCacheResult (line 7) | pub struct TransactionCacheResult {
function read_transaction_cache (line 26) | pub fn read_transaction_cache(key: &MomokaTxId) -> Option<Arc<Transactio...
function set_transaction_cache (line 36) | pub fn set_transaction_cache(key: MomokaTxId, value: TransactionCacheRes...
function read_signature_cache (line 50) | pub fn read_signature_cache(key: &str) -> Option<Arc<()>> {
function set_signature_cache (line 60) | pub fn set_signature_cache(key: String) {
FILE: momoka-rs/src/contracts/lens_hub.rs
function lens_hub_contract (line 30) | pub fn lens_hub_contract(
type LensProfileDetails (line 45) | pub struct LensProfileDetails {
function get_profile_details (line 82) | pub async fn get_profile_details(
FILE: momoka-rs/src/environment.rs
type Deployment (line 7) | pub enum Deployment {
type Err (line 14) | type Err = ();
method from_str (line 25) | fn from_str(s: &str) -> Result<Self, Self::Err> {
type EnvironmentInfo (line 37) | pub struct EnvironmentInfo {
type Environment (line 48) | pub enum Environment {
type Err (line 56) | type Err = ();
method from_str (line 67) | fn from_str(s: &str) -> Result<Self, Self::Err> {
function environment_to_chain_id (line 92) | pub fn environment_to_chain_id(environment: Environment) -> Result<u32, ...
function environment_to_lens_hub_contract (line 115) | pub fn environment_to_lens_hub_contract(
FILE: momoka-rs/src/evm.rs
type SigRequest (line 15) | pub struct SigRequest {
function parse_signature (line 51) | pub fn parse_signature(signature: &str, deadline: u64) -> Result<SigRequ...
type ProviderContext (line 69) | pub struct ProviderContext {
function evm_provider (line 87) | pub fn evm_provider(node_url: &str) -> Provider<RetryClient<Http>> {
FILE: momoka-rs/src/http.rs
constant MAX_RETRIES (line 7) | const MAX_RETRIES: i32 = 5;
function post_with_timeout (line 45) | pub async fn post_with_timeout<TResponse, TBody>(
function post_request (line 80) | async fn post_request<TResponse, TBody>(
FILE: momoka-rs/src/logger.rs
type Logger (line 4) | pub struct Logger;
method print_colored_message (line 8) | fn print_colored_message(&self, color_code: &str, content: &str) {
method error (line 22) | pub fn error(&self, content: &str) {
method warning (line 31) | pub fn warning(&self, content: &str) {
method info (line 40) | pub fn info(&self, content: &str) {
method success (line 49) | pub fn success(&self, content: &str) {
FILE: momoka-rs/src/main.rs
function create_provider_context (line 45) | pub fn create_provider_context(
type Cli (line 74) | struct Cli {
function main (line 97) | async fn main() {
FILE: momoka-rs/src/submitter/state.rs
function get_submitters (line 27) | pub fn get_submitters(environment: &Environment, deployment: &Deployment...
function is_valid_submitter (line 85) | pub fn is_valid_submitter(
FILE: momoka-rs/src/types/chain_proofs.rs
type ChainProofs (line 16) | pub struct ChainProofs<TTypedData, TPointer>
type ChainPublication (line 34) | pub struct ChainPublication<TTypedData>
FILE: momoka-rs/src/types/eip721.rs
type TypedDataDomain (line 11) | pub struct TypedDataDomain {
method to_ethers_type (line 22) | pub fn to_ethers_type(&self) -> EIP712Domain {
type EIP712TypedData (line 34) | pub struct EIP712TypedData<TTypes, TValue> {
type EIP712TypedDataValueBase (line 43) | pub struct EIP712TypedDataValueBase {
type CreatePostEIP712TypedDataValue (line 51) | pub struct CreatePostEIP712TypedDataValue {
type CreatePostEIP712Types (line 71) | pub struct CreatePostEIP712Types {
type CreatePostEIP712TypedData (line 76) | pub type CreatePostEIP712TypedData =
type CreateCommentEIP712TypedDataValue (line 81) | pub struct CreateCommentEIP712TypedDataValue {
type CreateCommentEIP712Types (line 107) | pub struct CreateCommentEIP712Types {
type CreateCommentEIP712TypedData (line 112) | pub type CreateCommentEIP712TypedData =
type CreateMirrorEIP712TypedDataValue (line 117) | pub struct CreateMirrorEIP712TypedDataValue {
type CreateMirrorEIP712Types (line 136) | pub struct CreateMirrorEIP712Types {
type CreateMirrorEIP712TypedData (line 141) | pub type CreateMirrorEIP712TypedData =
type TypedData (line 144) | pub trait TypedData {}
FILE: momoka-rs/src/types/evm_event.rs
type PostCreatedEventEmittedResponse (line 8) | pub struct PostCreatedEventEmittedResponse {
type CommentCreatedEventEmittedResponse (line 29) | pub struct CommentCreatedEventEmittedResponse {
type MirrorCreatedEventEmittedResponse (line 56) | pub struct MirrorCreatedEventEmittedResponse {
type EvmEvent (line 74) | pub trait EvmEvent {
method get_timestamp (line 75) | fn get_timestamp(&self) -> u64;
method get_timestamp (line 82) | fn get_timestamp(&self) -> u64 {
method get_timestamp (line 88) | fn get_timestamp(&self) -> u64 {
method get_timestamp (line 94) | fn get_timestamp(&self) -> u64 {
method get_timestamp (line 100) | fn get_timestamp(&self) -> u64 {
FILE: momoka-rs/src/types/hex.rs
type Hex (line 6) | pub struct Hex(Vec<u8>);
method new (line 10) | pub fn new(bytes: Vec<u8>) -> Self {
method empty (line 14) | pub fn empty() -> Self {
method as_bytes (line 18) | pub fn as_bytes(&self) -> &[u8] {
method is_empty (line 22) | pub fn is_empty(&self) -> bool {
method as_str (line 26) | pub fn as_str(&self) -> String {
method deserialize (line 32) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
method serialize (line 64) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
function from (line 74) | fn from(hex: Hex) -> Self {
method from (line 80) | fn from(hex: Hex) -> Self {
method from (line 86) | fn from(hex: &'a Hex) -> Self {
function from (line 92) | fn from(bytes: Hex) -> Self {
FILE: momoka-rs/src/types/profile_id.rs
type ProfileId (line 7) | pub struct ProfileId(U256);
method new (line 11) | pub fn new(value: U256) -> Self {
method into_inner (line 16) | pub fn into_inner(self) -> U256 {
method as_str (line 21) | pub fn as_str(&self) -> String {
method from (line 31) | fn from(value: U256) -> Self {
method deserialize (line 46) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
method fmt (line 58) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
method serialize (line 37) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
method from (line 64) | fn from(profile_id: ProfileId) -> Self {
method from (line 70) | fn from(profile_id: &'a ProfileId) -> Self {
type TestData (line 80) | struct TestData {
function get_test_data (line 85) | fn get_test_data() -> Vec<TestData> {
function test_new_profile_id (line 104) | fn test_new_profile_id() {
function test_serialize_deserialize_profile_id (line 113) | fn test_serialize_deserialize_profile_id() {
function test_display (line 127) | fn test_display() {
function test_from_profile_id_to_u256 (line 136) | fn test_from_profile_id_to_u256() {
function test_from_ref_profile_id_to_u256 (line 147) | fn test_from_ref_profile_id_to_u256() {
FILE: momoka-rs/src/types/publication_id.rs
type PublicationId (line 7) | pub struct PublicationId(U256);
method new (line 11) | pub fn new(value: U256) -> Self {
method into_inner (line 16) | pub fn into_inner(self) -> U256 {
method as_str (line 21) | pub fn as_str(&self) -> String {
method from (line 31) | fn from(value: U256) -> Self {
method deserialize (line 46) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
method fmt (line 58) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
method serialize (line 37) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
method from (line 64) | fn from(publication_id: PublicationId) -> Self {
method from (line 70) | fn from(publication_id: &'a PublicationId) -> Self {
function test_publication_id_new (line 80) | fn test_publication_id_new() {
function test_publication_id_into_inner (line 89) | fn test_publication_id_into_inner() {
function test_publication_id_as_str (line 98) | fn test_publication_id_as_str() {
function test_publication_id_from_u256 (line 107) | fn test_publication_id_from_u256() {
function test_publication_id_serde (line 116) | fn test_publication_id_serde() {
function test_publication_id_fmt (line 126) | fn test_publication_id_fmt() {
FILE: momoka-rs/src/types/transaction.rs
type MomokaTxId (line 31) | pub type MomokaTxId = String;
type TransactionAction (line 37) | pub enum TransactionAction {
type TransactionProvider (line 46) | pub enum TransactionProvider {
type TransactionPointerType (line 53) | pub enum TransactionPointerType {
type TransactionTimestampProofsValidatorSignature (line 60) | pub struct TransactionTimestampProofsValidatorSignature {
type TransactionTimestampProofsValidation (line 68) | pub struct TransactionTimestampProofsValidation {
type TimestampProofsSummary (line 96) | pub struct TimestampProofsSummary {
type TimestampProofsResponse (line 107) | pub struct TimestampProofsResponse {
type TransactionPointer (line 118) | pub struct TransactionPointer {
type BasePublication (line 130) | pub struct BasePublication<TEvent, TTypedData, TPointer>
type PostCreatedPublication (line 160) | pub type PostCreatedPublication = BasePublication<
method typed_data_value (line 167) | pub fn typed_data_value(&self) -> &CreatePostEIP712TypedDataValue {
method profile_id (line 171) | pub fn profile_id(&self) -> &ProfileId {
type CommentCreatedPublication (line 177) | pub type CommentCreatedPublication = BasePublication<
method typed_data (line 184) | pub fn typed_data(
method profile_id (line 190) | pub fn profile_id(&self) -> &ProfileId {
method signature (line 194) | pub fn signature(&self) -> &String {
method nonce (line 198) | pub fn nonce(&self) -> &u64 {
type MirrorCreatedPublication (line 204) | pub type MirrorCreatedPublication = BasePublication<
method typed_data (line 211) | pub fn typed_data(
method profile_id (line 217) | pub fn profile_id(&self) -> &ProfileId {
method signature (line 221) | pub fn signature(&self) -> &String {
method nonce (line 225) | pub fn nonce(&self) -> &u64 {
type MomokaTransaction (line 233) | pub enum MomokaTransaction {
method from_json (line 273) | pub fn from_json(
method get_timestamp_proofs (line 302) | pub fn get_timestamp_proofs(&self) -> Result<&TransactionTimestampProo...
method is_valid_event_timestamp (line 320) | pub fn is_valid_event_timestamp(&self) -> Result<bool, MomokaVerifierE...
method is_valid_typed_data_deadline_timestamp (line 343) | pub fn is_valid_typed_data_deadline_timestamp(&self) -> Result<bool, M...
method validate_transaction (line 371) | pub async fn validate_transaction(
method block_number (line 388) | pub fn block_number(&self) -> Result<&u64, MomokaVerifierError> {
method signature (line 416) | pub fn signature(&self) -> Result<&str, MomokaVerifierError> {
method third_party_proofs_timestamp (line 443) | pub fn third_party_proofs_timestamp(&self) -> Result<&u64, MomokaVerif...
method pointer (line 480) | pub fn pointer(&self) -> Result<&Option<TransactionPointer>, MomokaVer...
method format_publication_id (line 503) | fn format_publication_id(
method generate_publication_id (line 539) | fn generate_publication_id(&self) -> Result<String, MomokaVerifierErro...
method valid_publication_id (line 571) | pub fn valid_publication_id(&self) -> Result<bool, MomokaVerifierError> {
method verifying_contract (line 594) | pub fn verifying_contract(&self) -> Result<&Address, MomokaVerifierErr...
method transaction_type (line 624) | pub fn transaction_type(&self) -> Result<&TransactionAction, MomokaVer...
method data_availability_id (line 639) | pub fn data_availability_id(&self) -> Result<&Uuid, MomokaVerifierErro...
method typed_data_collect_module (line 709) | pub fn typed_data_collect_module(&self) -> Result<Option<&Address>, Mo...
method get_inner_object (line 730) | pub fn get_inner_object(&self) -> Result<JsonValue, MomokaVerifierErro...
type MomokaTransactionName (line 242) | pub enum MomokaTransactionName {
type Err (line 249) | type Err = ();
method from_str (line 251) | fn from_str(s: &str) -> Result<Self, Self::Err> {
type TransactionTimestampProofs (line 762) | pub struct TransactionTimestampProofs {
type TransactionSummary (line 776) | pub struct TransactionSummary {
method set_timestamp_proofs_response (line 791) | pub fn set_timestamp_proofs_response(&mut self, response: TimestampPro...
method set_pointer_transaction_summary (line 796) | pub fn set_pointer_transaction_summary(&mut self, response: Box<Transa...
type TransactionError (line 802) | pub struct TransactionError {
method new (line 808) | pub fn new(id: MomokaTxId, error: MomokaVerifierError) -> Self {
FILE: momoka-rs/src/types/verifier_error.rs
type MomokaVerifierError (line 9) | pub enum MomokaVerifierError {
method fmt (line 73) | fn fmt(&self, f: &mut Formatter<'_>) -> Result {
FILE: momoka-rs/src/utils.rs
function get_current_utc_string (line 10) | pub fn get_current_utc_string() -> String {
FILE: momoka-rs/src/verifier/proof.rs
function get_closest_block (line 85) | fn get_closest_block(blocks: &[Block<H256>; 3], target_timestamp: U256) ...
function get_blocks (line 123) | async fn get_blocks(
function is_valid_choosen_block (line 172) | async fn is_valid_choosen_block(
constant SIGNATURE_EXTRACT_PATTERN (line 219) | const SIGNATURE_EXTRACT_PATTERN: &str = r#""signature"\s*:\s*"0x[a-fA-F0...
function extract_address (line 235) | fn extract_address(transaction: &MomokaTransaction) -> Result<Address, M...
function verify_timestamp_proofs_match_transaction (line 292) | async fn verify_timestamp_proofs_match_transaction(
function process_proof (line 336) | async fn process_proof(
function cached_tx_id (line 405) | fn cached_tx_id(
function set_tx_cache (line 441) | fn set_tx_cache(
function cached_signature (line 469) | fn cached_signature(signature: &str) -> Result<bool, MomokaVerifierError> {
function process_proofs (line 495) | async fn process_proofs(
function check_proofs (line 631) | pub async fn check_proofs(
function check_proof (line 672) | pub async fn check_proof(
FILE: momoka-rs/src/verifier/transactions/comment.rs
function who_signed_typed_data (line 26) | fn who_signed_typed_data(
function cross_check_event (line 51) | fn cross_check_event(
function verifier_comment (line 110) | pub async fn verifier_comment(
FILE: momoka-rs/src/verifier/transactions/common.rs
function recovery_signed_typed_data (line 26) | pub fn recovery_signed_typed_data<TValue: Serialize>(
FILE: momoka-rs/src/verifier/transactions/mirror.rs
function who_signed_typed_data (line 26) | fn who_signed_typed_data(
function cross_check_event (line 51) | fn cross_check_event(
function verifier_mirror (line 104) | pub async fn verifier_mirror(
FILE: momoka-rs/src/verifier/transactions/post.rs
function simulate_transaction (line 45) | async fn simulate_transaction(
function get_expected_simulation_result (line 126) | async fn get_expected_simulation_result(
function cross_check_event (line 169) | fn cross_check_event(
function verifier_post (line 221) | pub async fn verifier_post(
Condensed preview — 179 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (967K chars).
[
{
"path": ".github/workflows/dependency-review.yml",
"chars": 441,
"preview": "name: Dependency Review\non:\n - pull_request\n\npermissions:\n contents: read\n pull-requests: write\n\njobs:\n dependency-r"
},
{
"path": ".gitignore",
"chars": 305,
"preview": "momoka-node/node_modules\nmomoka-node/.env\nmomoka-node/coverage\nmomoka-node/coverage.json\nmomoka-node/lib/\nmomoka-node/da"
},
{
"path": "README.md",
"chars": 143096,
"preview": "# Momoka\n\n<img src=\"./images/logo.png\" />\n\nNot supported anymore but be our guest to fork.\n\n## Disclaimer\n\nWe would like"
},
{
"path": "momoka-node/.dockerignore",
"chars": 83,
"preview": ".dockerignore\nnpm-debug.log\nDockerfile\n.gitignore\njest.config.js\n.git\nnode_modules\n"
},
{
"path": "momoka-node/.eslintrc.js",
"chars": 3187,
"preview": "module.exports = {\n env: {\n es2021: true,\n node: true,\n },\n ignorePatterns: ['.eslintrc.js', '*.json', '*.test."
},
{
"path": "momoka-node/.nvmrc",
"chars": 9,
"preview": "v18.12.1\n"
},
{
"path": "momoka-node/.prettierignore",
"chars": 18,
"preview": "*.yml\n*.yaml\n*.md\n"
},
{
"path": "momoka-node/.prettierrc",
"chars": 73,
"preview": "{\n \"printWidth\": 100,\n \"singleQuote\": true,\n \"trailingComma\": \"es5\"\n}\n"
},
{
"path": "momoka-node/CHANGELOG.md",
"chars": 641,
"preview": "# unreleased - fill in any changes you do here!\n\n## Features\n\n## Bug fixes\n\n## Breaking changes\n\n#######################"
},
{
"path": "momoka-node/Dockerfile",
"chars": 435,
"preview": "FROM mcr.microsoft.com/devcontainers/typescript-node:18 as base\n\nWORKDIR /usr/src/app\n\nCOPY package*.json ./\nCOPY tsconf"
},
{
"path": "momoka-node/Dockerfile.stable",
"chars": 555,
"preview": "FROM node:18-alpine AS base\r\n\r\n# Install pnpm through corepack\r\nRUN apk update\r\nRUN apk add --no-cache libc6-compat\r\nRUN"
},
{
"path": "momoka-node/LICENSE.txt",
"chars": 1057,
"preview": "Copyright (c) 2023 Aave companies\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this "
},
{
"path": "momoka-node/README.md",
"chars": 19970,
"preview": "# Momoke-node\n\nThis package holds the node implementation of the momoka and also the ability to run it client side.\n\n## "
},
{
"path": "momoka-node/client/package.json",
"chars": 39,
"preview": "{\n \"main\": \"../lib/client/index.js\"\n}\n"
},
{
"path": "momoka-node/codegen.yaml",
"chars": 244,
"preview": "schema: https://lens.bundlr.network/graphql\ndocuments: './src/graphql/*.graphql'\ngenerates:\n ./src/graphql/generated.ts"
},
{
"path": "momoka-node/jest.config.js",
"chars": 534,
"preview": "/** @type {import('ts-jest').JestConfigWithTsJest} */\nmodule.exports = {\n preset: 'ts-jest',\n testEnvironment: 'node',"
},
{
"path": "momoka-node/package.json",
"chars": 2771,
"preview": "{\n \"name\": \"@lens-protocol/momoka\",\n \"version\": \"2.1.1\",\n \"description\": \"Momoka node for the Lens protocol\",\n \"main"
},
{
"path": "momoka-node/playground-browser/.gitignore",
"chars": 310,
"preview": "# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.\n\n# dependencies\n/node_modules\n/.pn"
},
{
"path": "momoka-node/playground-browser/README.md",
"chars": 2103,
"preview": "# Getting Started with Create React App\n\nThis project was bootstrapped with [Create React App](https://github.com/facebo"
},
{
"path": "momoka-node/playground-browser/config-overrides.js",
"chars": 535,
"preview": "module.exports = function override(config) {\n // required to support .cjs extension which is used by axios inside the v"
},
{
"path": "momoka-node/playground-browser/package.json",
"chars": 1053,
"preview": "{\n \"name\": \"playground-browser\",\n \"version\": \"0.1.0\",\n \"private\": true,\n \"dependencies\": {\n \"@testing-library/jes"
},
{
"path": "momoka-node/playground-browser/public/index.html",
"chars": 1705,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\" />\n <link rel=\"icon\" href=\"%PUBLIC_URL%/favicon.i"
},
{
"path": "momoka-node/playground-browser/public/manifest.json",
"chars": 492,
"preview": "{\n \"short_name\": \"React App\",\n \"name\": \"Create React App Sample\",\n \"icons\": [\n {\n \"src\": \"favicon.ico\",\n "
},
{
"path": "momoka-node/playground-browser/public/robots.txt",
"chars": 67,
"preview": "# https://www.robotstxt.org/robotstxt.html\nUser-agent: *\nDisallow:\n"
},
{
"path": "momoka-node/playground-browser/src/App.css",
"chars": 564,
"preview": ".App {\n text-align: center;\n}\n\n.App-logo {\n height: 40vmin;\n pointer-events: none;\n}\n\n@media (prefers-reduced-motion:"
},
{
"path": "momoka-node/playground-browser/src/App.test.tsx",
"chars": 273,
"preview": "import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport App from './App';\n\ntest('rend"
},
{
"path": "momoka-node/playground-browser/src/App.tsx",
"chars": 1059,
"preview": "import {\n checkDAProof,\n Deployment,\n Environment,\n EthereumNode,\n} from '@lens-protocol/data-availability-verifier/"
},
{
"path": "momoka-node/playground-browser/src/index.css",
"chars": 358,
"preview": "body {\n margin: 0;\n font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',\n 'Can"
},
{
"path": "momoka-node/playground-browser/src/index.tsx",
"chars": 550,
"preview": "import React from 'react';\nimport ReactDOM from 'react-dom/client';\nimport './index.css';\nimport App from './App';\nimpor"
},
{
"path": "momoka-node/playground-browser/src/react-app-env.d.ts",
"chars": 40,
"preview": "/// <reference types=\"react-scripts\" />\n"
},
{
"path": "momoka-node/playground-browser/src/reportWebVitals.ts",
"chars": 425,
"preview": "import { ReportHandler } from 'web-vitals';\n\nconst reportWebVitals = (onPerfEntry?: ReportHandler) => {\n if (onPerfEntr"
},
{
"path": "momoka-node/playground-browser/src/setupTests.ts",
"chars": 241,
"preview": "// jest-dom adds custom jest matchers for asserting on DOM nodes.\n// allows you to do things like:\n// expect(element).to"
},
{
"path": "momoka-node/playground-browser/tsconfig.json",
"chars": 503,
"preview": "{\n \"compilerOptions\": {\n \"target\": \"es5\",\n \"lib\": [\"dom\", \"dom.iterable\", \"esnext\"],\n \"allowJs\": true,\n \"sk"
},
{
"path": "momoka-node/pnpm-workspace.yaml",
"chars": 82,
"preview": "packages:\n - 'src/**'\n # if required, exclude some directories\n - '!**/test/**'"
},
{
"path": "momoka-node/render.yaml",
"chars": 105,
"preview": "services:\r\n - type: worker\r\n name: momoka\r\n env: docker\r\n dockerfilePath: ./Dockerfile.stable\r\n"
},
{
"path": "momoka-node/src/__TESTS__/comment.e2e.test.ts",
"chars": 17393,
"preview": "// apply mocks!\njest.setTimeout(3000);\njest.mock('../input-output/db');\njest.mock('../input-output/bundlr/get-bundlr-by-"
},
{
"path": "momoka-node/src/__TESTS__/config/jest.setup.js",
"chars": 200,
"preview": "const crypto = require('crypto');\n\nObject.defineProperty(globalThis, 'crypto', {\n value: {\n subtle: crypto.webcrypto"
},
{
"path": "momoka-node/src/__TESTS__/db.test.ts",
"chars": 1714,
"preview": "import { MomokaValidatorError, TxValidatedResult } from '..';\nimport { getBlockDb, getTxDb, saveBlockDb, saveTxDb, start"
},
{
"path": "momoka-node/src/__TESTS__/mirror.e2e.test.ts",
"chars": 30563,
"preview": "// apply mocks!\njest.setTimeout(30000);\njest.mock('../input-output/db');\njest.mock('../input-output/bundlr/get-bundlr-by"
},
{
"path": "momoka-node/src/__TESTS__/mocks/comment/comment-created-delegate-arweave-response.mock.ts",
"chars": 5707,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/comment/comment-created-without-delegate-arweave-response.mock.ts",
"chars": 5717,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/mirror/mirror-created-delegate-comment-arweave-response.mock.ts",
"chars": 5062,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/mirror/mirror-created-delegate-post-arweave-response.mock.ts",
"chars": 5059,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/mirror/mirror-created-without-delegate-comment-arweave-response.mock.ts",
"chars": 5072,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/mirror/mirror-created-without-delegate-post-arweave-response.mock.ts",
"chars": 5069,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/post/post-created-delegate-arweave-response.mock.ts",
"chars": 5051,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/post/post-created-without-delegate-arweave-response.mock.ts",
"chars": 5061,
"preview": "import { MomokaActionTypes } from '../../../data-availability-models/data-availability-action-types';\nimport { MomokaPro"
},
{
"path": "momoka-node/src/__TESTS__/mocks/shared.mock.ts",
"chars": 5574,
"preview": "import {\n Deployment,\n Environment,\n EthereumNode,\n MomokaValidatorError,\n TxValidatedResult,\n} from '../..';\nimpor"
},
{
"path": "momoka-node/src/__TESTS__/post.e2e.test.ts",
"chars": 13850,
"preview": "// apply mocks!\njest.setTimeout(30000);\njest.mock('../input-output/db');\njest.mock('../input-output/bundlr/get-bundlr-by"
},
{
"path": "momoka-node/src/__TESTS__/publications/publication.base.test.ts",
"chars": 2578,
"preview": "import { whoSignedTypedData } from '../../proofs/publications/publication.base';\n\ndescribe('publication base', () => {\n "
},
{
"path": "momoka-node/src/__TESTS__/random.test.ts",
"chars": 361,
"preview": "import { getBundlrByIdAPI } from '../input-output/bundlr/get-bundlr-by-id.api';\nimport { LibCurlProvider } from '../inpu"
},
{
"path": "momoka-node/src/__TESTS__/submitters.test.ts",
"chars": 1279,
"preview": "import { Environment } from '../common/environment';\nimport { getParamOrExit } from '../common/helpers';\nimport { Ethere"
},
{
"path": "momoka-node/src/bin/cli.ts",
"chars": 1614,
"preview": "#!/usr/bin/env node\n\nimport yargs from 'yargs';\nimport { Deployment, Environment } from '../common/environment';\nimport "
},
{
"path": "momoka-node/src/client/axios-provider.ts",
"chars": 355,
"preview": "import axios from 'axios';\nimport { FetchProvider } from '../input-output/fetch-with-timeout';\n\nexport class AxiosProvid"
},
{
"path": "momoka-node/src/client/check-da-proof-client.ts",
"chars": 1142,
"preview": "import { EthereumNode } from '../evm/ethereum';\nimport {\n CheckDASubmissionOptions,\n getDefaultCheckDASubmissionOption"
},
{
"path": "momoka-node/src/client/client-da-proof-gateway.ts",
"chars": 1750,
"preview": "import { DATimestampProofsResponse } from '../data-availability-models/data-availability-timestamp-proofs';\nimport {\n D"
},
{
"path": "momoka-node/src/client/client-da-proof-verifier.ts",
"chars": 2224,
"preview": "import { utils } from 'ethers';\nimport Arweave from 'arweave/web';\nimport deepHash from 'arweave/web/lib/deepHash';\nimpo"
},
{
"path": "momoka-node/src/client/index.ts",
"chars": 552,
"preview": "export { Deployment, Environment } from '../common/environment';\nexport {\n DAEventType,\n DAStructurePublication,\n Pub"
},
{
"path": "momoka-node/src/common/environment.ts",
"chars": 1719,
"preview": "/**\n * Enum defining the supported Ethereum environments for the verifier node.\n */\nexport enum Environment {\n POLYGON "
},
{
"path": "momoka-node/src/common/helpers.ts",
"chars": 5821,
"preview": "/**\n * Creates a deep clone of the given object by converting it to a JSON string and then parsing it back to an object."
},
{
"path": "momoka-node/src/common/in-memory-store.ts",
"chars": 590,
"preview": "export class InMemoryStore {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n private state: Map<strin"
},
{
"path": "momoka-node/src/common/logger.ts",
"chars": 3229,
"preview": "export type LogFunctionType = (message: string, ...optionalParams: unknown[]) => void;\n\nexport enum LoggerLevelColours {"
},
{
"path": "momoka-node/src/data-availability-models/da-result.ts",
"chars": 3198,
"preview": "import { MomokaValidatorError } from './validator-errors';\n\nclass Success<TSuccess> {\n public constructor(public readon"
},
{
"path": "momoka-node/src/data-availability-models/data-availability-action-types.ts",
"chars": 178,
"preview": "export enum MomokaActionTypes {\n POST_CREATED = 'POST_CREATED',\n COMMENT_CREATED = 'COMMENT_CREATED',\n MIRROR_CREATED"
},
{
"path": "momoka-node/src/data-availability-models/data-availability-provider.ts",
"chars": 52,
"preview": "export enum MomokaProvider {\n BUNDLR = 'BUNDLR',\n}\n"
},
{
"path": "momoka-node/src/data-availability-models/data-availability-structure-base.ts",
"chars": 511,
"preview": "import { MomokaActionTypes } from './data-availability-action-types';\nimport { DATimestampProofs } from './data-availabi"
},
{
"path": "momoka-node/src/data-availability-models/data-availability-timestamp-proofs.ts",
"chars": 1532,
"preview": "import { MomokaActionTypes } from './data-availability-action-types';\nimport { MomokaProvider } from './data-availabilit"
},
{
"path": "momoka-node/src/data-availability-models/data-availability-typed-data.ts",
"chars": 273,
"preview": "export interface TypedDataField {\n name: string;\n type: string;\n}\n\nexport interface TypedDataDomain {\n name: string;\n"
},
{
"path": "momoka-node/src/data-availability-models/publications/data-availability-publication-typed-data.ts",
"chars": 3922,
"preview": "import {\n EIP712TypedDataValueBase,\n TypedDataDomain,\n TypedDataField,\n} from '../data-availability-typed-data';\n\nint"
},
{
"path": "momoka-node/src/data-availability-models/publications/data-availability-structure-publication.ts",
"chars": 2584,
"preview": "import { DAStructureBase } from '../data-availability-structure-base';\nimport { DAEventType } from './data-availability-"
},
{
"path": "momoka-node/src/data-availability-models/publications/data-availability-structure-publications-events.ts",
"chars": 2156,
"preview": "import {\n PostCreatedEventEmittedResponse as PostCreatedEventEmittedResponseV1,\n MirrorCreatedEventEmittedResponse as "
},
{
"path": "momoka-node/src/data-availability-models/validator-errors.ts",
"chars": 4913,
"preview": "/**\n * This is a list of all the errors that can be returned from the momoka validator\n */\nexport enum MomokaValidatorEr"
},
{
"path": "momoka-node/src/evm/abi-types/LensHubV1.ts",
"chars": 33560,
"preview": "import { EthersContractContextV5 } from 'ethereum-abi-types-generator';\nimport { BigNumber, BigNumberish, BytesLike as A"
},
{
"path": "momoka-node/src/evm/abi-types/LensHubV1Events.ts",
"chars": 10018,
"preview": "import { EthersContractContextV5 } from 'ethereum-abi-types-generator';\nimport { BigNumber, BigNumberish, BytesLike as A"
},
{
"path": "momoka-node/src/evm/abi-types/LensHubV2.ts",
"chars": 37334,
"preview": "import { ContractTransaction, BytesLike as Arrayish, BigNumber, BigNumberish } from 'ethers';\nimport { EthersContractCon"
},
{
"path": "momoka-node/src/evm/abi-types/LensHubV2Events.ts",
"chars": 12195,
"preview": "import { EthersContractContextV5 } from 'ethereum-abi-types-generator';\nimport { BytesLike as Arrayish, BigNumber, BigNu"
},
{
"path": "momoka-node/src/evm/anvil.ts",
"chars": 4670,
"preview": "import { BigNumber } from 'ethers';\nimport { consoleLogWithLensNodeFootprint } from '../common/logger';\nimport { JSONRPC"
},
{
"path": "momoka-node/src/evm/contract-lens/lens-hub-v1-contract-abi.ts",
"chars": 41000,
"preview": "export const LENS_HUB_V1_ABI = [\n {\n inputs: [\n { internalType: 'address', name: 'followNFTImpl', type: 'addres"
},
{
"path": "momoka-node/src/evm/contract-lens/lens-hub-v2-contract-abi.ts",
"chars": 60125,
"preview": "export const LENS_HUB_V2_ABI = [\n {\n inputs: [\n {\n internalType: 'address',\n name: 'followNFTImpl"
},
{
"path": "momoka-node/src/evm/ethereum.ts",
"chars": 4806,
"preview": "import { BigNumber, ethers } from 'ethers';\nimport { Deployment, Environment, environmentToLensHubContract } from '../co"
},
{
"path": "momoka-node/src/evm/gateway/LensHubV1Gateway.ts",
"chars": 7145,
"preview": "import { EthereumNode } from '../ethereum';\nimport { Interface } from 'ethers/lib/utils';\nimport { LENS_HUB_V1_ABI } fro"
},
{
"path": "momoka-node/src/evm/gateway/LensHubV2Gateway.ts",
"chars": 7374,
"preview": "import { EthereumNode } from '../ethereum';\nimport { Interface } from 'ethers/lib/utils';\nimport { retryWithTimeout } fr"
},
{
"path": "momoka-node/src/evm/jsonrpc-methods.ts",
"chars": 216,
"preview": "/**\n * JSON RPC methods we use\n */\nexport enum JSONRPCMethods {\n eth_getBlockByNumber = 'eth_getBlockByNumber',\n eth_c"
},
{
"path": "momoka-node/src/graphql/data-availability-transactions.graphql",
"chars": 346,
"preview": "query DataAvailabilityTransactions(\n $owners: [String!]\n $limit: Int\n $after: String\n $order: SortOrder\n) {\n transa"
},
{
"path": "momoka-node/src/graphql/generated.ts",
"chars": 6963,
"preview": "import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';\nexport type Maybe<T> = T | null;\n"
},
{
"path": "momoka-node/src/graphql/urql.client.ts",
"chars": 310,
"preview": "import { createClient } from '@urql/core';\nimport { BUNDLR_NODE_GRAPHQL } from '../input-output/bundlr/bundlr-config';\n\n"
},
{
"path": "momoka-node/src/index.ts",
"chars": 991,
"preview": "export { Deployment, Environment } from './common/environment';\nexport {\n DAEventType,\n DAStructurePublication,\n Publ"
},
{
"path": "momoka-node/src/input-output/arweave/get-arweave-by-id.api.ts",
"chars": 850,
"preview": "import { AxiosProvider } from '../../client/axios-provider';\nimport { TimeoutError } from '../common';\nimport { fetchWit"
},
{
"path": "momoka-node/src/input-output/bundlr/bundlr-config.ts",
"chars": 632,
"preview": "/**\n * The URL for the Lens Bundlr node.\n */\nexport const BUNDLR_NODE = 'https://lens.bundlr.network/';\n\n/**\n * The URL "
},
{
"path": "momoka-node/src/input-output/bundlr/get-bundlr-bulk-txs.api.ts",
"chars": 1283,
"preview": "import { retryWithTimeout } from '../../common/helpers';\nimport { TimeoutError, TIMEOUT_ERROR } from '../common';\nimport"
},
{
"path": "momoka-node/src/input-output/bundlr/get-bundlr-by-id.api.ts",
"chars": 1008,
"preview": "import { retryWithTimeout } from '../../common/helpers';\nimport { TIMEOUT_ERROR, TimeoutError } from '../common';\nimport"
},
{
"path": "momoka-node/src/input-output/bundlr/get-data-availability-transactions.api.ts",
"chars": 1971,
"preview": "import { Deployment, Environment } from '../../common/environment';\nimport { DataAvailabilityTransactionsDocument } from"
},
{
"path": "momoka-node/src/input-output/bundlr/get-owner-of-transaction.api.ts",
"chars": 1246,
"preview": "import { retryWithTimeout } from '../../common/helpers';\nimport { TimeoutError } from '../common';\nimport { FetchProvide"
},
{
"path": "momoka-node/src/input-output/common.ts",
"chars": 78,
"preview": "export const TIMEOUT_ERROR = 'timeout';\nexport type TimeoutError = 'timeout';\n"
},
{
"path": "momoka-node/src/input-output/db.ts",
"chars": 8628,
"preview": "import { existsSync, mkdirSync } from 'fs';\nimport { Level } from 'level';\nimport { DATimestampProofsResponse } from '.."
},
{
"path": "momoka-node/src/input-output/fetch-with-timeout.ts",
"chars": 320,
"preview": "export interface FetchProvider {\n get: <TResponse>(url: string, options: { timeout: number }) => Promise<TResponse>;\n}\n"
},
{
"path": "momoka-node/src/input-output/json-rpc-with-timeout.ts",
"chars": 661,
"preview": "import axios from 'axios';\nimport { JSONRPCMethods } from '../evm/jsonrpc-methods';\n\n// most RPC nodes rate limits is pe"
},
{
"path": "momoka-node/src/input-output/lib-curl-provider.ts",
"chars": 634,
"preview": "// import { curly } from 'node-libcurl';\n// import { FetchProvider } from './fetch-with-timeout';\n\n// export class LibCu"
},
{
"path": "momoka-node/src/input-output/paths.ts",
"chars": 920,
"preview": "export type PathType = {\n join(...paths: string[]): string;\n};\nlet _path: PathType | undefined;\nexport const pathResolv"
},
{
"path": "momoka-node/src/input-output/post-with-timeout.ts",
"chars": 420,
"preview": "import axios from 'axios';\n\nexport const postWithTimeout = async <TResponse, TBody>(\n url: string,\n body: TBody\n): Pro"
},
{
"path": "momoka-node/src/input-output/tx-validated-results.ts",
"chars": 961,
"preview": "import {\n DAEventType,\n DAStructurePublication,\n PublicationTypedData,\n} from '../data-availability-models/publicatio"
},
{
"path": "momoka-node/src/proofs/check-da-proof.ts",
"chars": 2943,
"preview": "import { EthereumNode } from '../evm/ethereum';\nimport {\n CheckDASubmissionOptions,\n getDefaultCheckDASubmissionOption"
},
{
"path": "momoka-node/src/proofs/check-da-proofs-batch.ts",
"chars": 11527,
"preview": "import { Promise as BluebirdPromise } from 'bluebird';\nimport {\n base64StringToJson,\n chunkArray,\n createTimeoutPromi"
},
{
"path": "momoka-node/src/proofs/da-proof-checker.ts",
"chars": 20003,
"preview": "import { Deployment, Environment } from '../common/environment';\nimport { LogFunctionType } from '../common/logger';\nimp"
},
{
"path": "momoka-node/src/proofs/da-proof-gateway.ts",
"chars": 2520,
"preview": "import { AxiosProvider } from '../client/axios-provider';\nimport { DATimestampProofsResponse } from '../data-availabilit"
},
{
"path": "momoka-node/src/proofs/da-proof-verifier.ts",
"chars": 2292,
"preview": "import { AxiosProvider } from '../client/axios-provider';\nimport { Deployment, Environment } from '../common/environment"
},
{
"path": "momoka-node/src/proofs/models/check-da-submisson-options.ts",
"chars": 381,
"preview": "import { LogFunctionType } from '../../common/logger';\n\nexport interface CheckDASubmissionOptions {\n verifyPointer: boo"
},
{
"path": "momoka-node/src/proofs/publications/comment/da-comment-verifier-v1.ts",
"chars": 3060,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/comment/da-comment-verifier-v2.ts",
"chars": 4145,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/comment/index.ts",
"chars": 2596,
"preview": "import { LogFunctionType } from '../../../common/logger';\nimport { failure, PromiseResult } from '../../../data-availabi"
},
{
"path": "momoka-node/src/proofs/publications/create-da-publication-verifier.ts",
"chars": 3771,
"preview": "import { DAStructurePublication } from '../../data-availability-models/publications/data-availability-structure-publicat"
},
{
"path": "momoka-node/src/proofs/publications/da-publication-verifier-v1.ts",
"chars": 3263,
"preview": "import { DAStructurePublication } from '../../data-availability-models/publications/data-availability-structure-publicat"
},
{
"path": "momoka-node/src/proofs/publications/da-publication-verifier-v2.ts",
"chars": 2732,
"preview": "import { failure, PromiseResult, success } from '../../data-availability-models/da-result';\nimport { DAEventTypeV2 } fro"
},
{
"path": "momoka-node/src/proofs/publications/mirror/da-mirror-verifier-v1.ts",
"chars": 2805,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/mirror/da-mirror-verifier-v2.ts",
"chars": 3611,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/mirror/index.ts",
"chars": 2688,
"preview": "import { LogFunctionType } from '../../../common/logger';\nimport { failure, PromiseResult } from '../../../data-availabi"
},
{
"path": "momoka-node/src/proofs/publications/post/da-post-verifier-v1.ts",
"chars": 6037,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/post/da-post-verifier-v2.ts",
"chars": 7451,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/post/index.ts",
"chars": 1446,
"preview": "import { LogFunctionType } from '../../../common/logger';\nimport { failure, PromiseResult } from '../../../data-availabi"
},
{
"path": "momoka-node/src/proofs/publications/publication.base.ts",
"chars": 1414,
"preview": "import { SignatureLike } from '@ethersproject/bytes';\nimport { utils } from 'ethers';\nimport { failure, PromiseResult, s"
},
{
"path": "momoka-node/src/proofs/publications/quote/da-quote-verifier-v2.ts",
"chars": 4095,
"preview": "import { DAStructurePublication } from '../../../data-availability-models/publications/data-availability-structure-publi"
},
{
"path": "momoka-node/src/proofs/publications/quote/index.ts",
"chars": 2494,
"preview": "import { LogFunctionType } from '../../../common/logger';\nimport { failure, PromiseResult } from '../../../data-availabi"
},
{
"path": "momoka-node/src/proofs/utils.ts",
"chars": 4001,
"preview": "import type CryptoInterface from 'arweave/node/lib/crypto/crypto-interface';\nimport { BlockInfo } from '../evm/ethereum'"
},
{
"path": "momoka-node/src/queue/base.queue.ts",
"chars": 765,
"preview": "import { sleep } from '../common/helpers';\n\n/**\n * A queue is a data structure that follows the FIFO (First In First Out"
},
{
"path": "momoka-node/src/queue/known.queue.ts",
"chars": 461,
"preview": "import { Queue } from './base.queue';\nimport { ProcessFailedProofQueueRequest } from './process-failed-da-proof.queue';\n"
},
{
"path": "momoka-node/src/queue/process-failed-da-proof.queue.ts",
"chars": 1677,
"preview": "import { existsSync, promises as fs } from 'fs';\nimport { runForever } from '../common/helpers';\nimport { MomokaValidato"
},
{
"path": "momoka-node/src/queue/process-retry-check-da-proofs.queue.ts",
"chars": 2175,
"preview": "import { runForever } from '../common/helpers';\nimport { MomokaValidatorError } from '../data-availability-models/valida"
},
{
"path": "momoka-node/src/queue/startup.queue.ts",
"chars": 461,
"preview": "import { failedDAProofQueue, retryCheckDAProofsQueue } from './known.queue';\nimport { processFailedDAProofQueue } from '"
},
{
"path": "momoka-node/src/runnable/da-verifier-node.runnable.ts",
"chars": 507,
"preview": "import { getParam, turnedOffExperimentalWarning } from '../common/helpers';\nimport { startDAVerifierNode } from '../watc"
},
{
"path": "momoka-node/src/runnable/ethereum-node-instance.ts",
"chars": 407,
"preview": "import { Deployment, Environment } from '../common/environment';\nimport { getParam, getParamOrExit } from '../common/hel"
},
{
"path": "momoka-node/src/runnable/failed-submissons.runnable.ts",
"chars": 337,
"preview": "import { verifierFailedSubmissionsWatcher } from '../watchers/failed-submissons.watcher';\n\n/**\n * Watches for failed sub"
},
{
"path": "momoka-node/src/submitters.ts",
"chars": 2523,
"preview": "import { Deployment, Environment } from './common/environment';\n\n/**\n * Returns the list of submitters based on the give"
},
{
"path": "momoka-node/src/utils/arrays-equal.ts",
"chars": 263,
"preview": "export const arraysEqual = <T>(array1: T[], array2: T[]): boolean => {\n if (array1.length !== array2.length) {\n retu"
},
{
"path": "momoka-node/src/utils/invariant.ts",
"chars": 512,
"preview": "export class InvariantError extends Error {\n constructor(message: string) {\n super(`InvariantError: ${message}`);\n "
},
{
"path": "momoka-node/src/utils/number-to-hex.ts",
"chars": 286,
"preview": "/**\n * Does this over ethers call as alchemy and some other providers dont like a padding hex number\n * - wont accept 0x"
},
{
"path": "momoka-node/src/watchers/failed-submissons.watcher.ts",
"chars": 1586,
"preview": "import { existsSync, promises as fs } from 'fs';\nimport path from 'path';\nimport { runForever } from '../common/helpers'"
},
{
"path": "momoka-node/src/watchers/models/start-da-verifier-node-options.ts",
"chars": 419,
"preview": "import { StreamCallback } from './stream.type';\n\n/**\n * Options for starting the verifier node\n */\nexport interface Star"
},
{
"path": "momoka-node/src/watchers/models/stream.type.ts",
"chars": 185,
"preview": "import { TxValidatedResult } from '../../input-output/tx-validated-results';\n\nexport type StreamResult = TxValidatedResu"
},
{
"path": "momoka-node/src/watchers/trusting-indexing.watcher.ts",
"chars": 2983,
"preview": "import { Deployment, Environment } from '../common/environment';\nimport { runForever, sleep } from '../common/helpers';\n"
},
{
"path": "momoka-node/src/watchers/verifier.watcher.ts",
"chars": 11068,
"preview": "import { Deployment, Environment } from '../common/environment';\nimport { runForever, sleep } from '../common/helpers';\n"
},
{
"path": "momoka-node/src/workers/handler-communication.worker.ts",
"chars": 1579,
"preview": "import { parentPort } from 'worker_threads';\nimport {\n bundlrVerifyReceiptWorker,\n BundlrVerifyReceiptWorkerRequest,\n "
},
{
"path": "momoka-node/src/workers/message-handlers/bundlr-verify-receipt.worker.ts",
"chars": 817,
"preview": "import deepHash from 'arweave/node/lib/deepHash';\nimport Arweave from 'arweave/node';\nimport { b64UrlToBuffer } from 'ar"
},
{
"path": "momoka-node/src/workers/message-handlers/evm-verify-message.worker.ts",
"chars": 650,
"preview": "import { utils } from 'ethers';\nimport {\n DAEventType,\n DAStructurePublication,\n PublicationTypedData,\n} from '../../"
},
{
"path": "momoka-node/src/workers/message-handlers/index.ts",
"chars": 93,
"preview": "export * from './bundlr-verify-receipt.worker';\nexport * from './evm-verify-message.worker';\n"
},
{
"path": "momoka-node/src/workers/worker-pool.ts",
"chars": 1433,
"preview": "import { cpus } from 'os';\nimport { resolve as resolvePath } from 'path';\nimport { Worker } from 'worker_threads';\nimpor"
},
{
"path": "momoka-node/tsconfig.json",
"chars": 559,
"preview": "{\n \"compilerOptions\": {\n \"target\": \"es2020\",\n \"module\": \"commonjs\",\n \"rootDir\": \"src\",\n \"outDir\": \"lib\",\n "
},
{
"path": "momoka-rs/Cargo.toml",
"chars": 922,
"preview": "[package]\nname = \"momoka\"\nversion = \"1.1.0\"\nedition = \"2021\"\nauthors = [\"Josh Stevens <josh@aave.io>\"]\ndescription = \"Th"
},
{
"path": "momoka-rs/README.md",
"chars": 1719,
"preview": "# momoka_rs\n\nTHIS ONLY SUPPORTS LENS V1 PUBLICATIONS AND HAS NOT BEEN MIGRATED TO LENS V2 SUPPORT YET.\n\nThis is the rust"
},
{
"path": "momoka-rs/src/abi/lens_hub_contract_abi.json",
"chars": 44019,
"preview": "[\n {\n \"inputs\": [\n { \"internalType\": \"address\", \"name\": \"followNFTImpl\", \"type\": \"address\" },\n { \"internal"
},
{
"path": "momoka-rs/src/bundlr/api.rs",
"chars": 20208,
"preview": "use crate::{\n environment::{Deployment, Environment},\n http::post_with_timeout,\n submitter::state::get_submitte"
},
{
"path": "momoka-rs/src/bundlr/mod.rs",
"chars": 29,
"preview": "pub mod api;\npub mod verify;\n"
},
{
"path": "momoka-rs/src/bundlr/verify.rs",
"chars": 4361,
"preview": "use crate::types::{\n transaction::TransactionTimestampProofsValidation, verifier_error::MomokaVerifierError,\n};\nuse b"
},
{
"path": "momoka-rs/src/cache.rs",
"chars": 2236,
"preview": "use std::collections::HashMap;\nuse std::sync::{Arc, RwLock};\n\nuse crate::types::transaction::MomokaTxId;\nuse crate::type"
},
{
"path": "momoka-rs/src/contracts/lens_hub.rs",
"chars": 4503,
"preview": "use std::{fs, sync::Arc};\n\nuse ethers::{\n abi::Abi,\n prelude::{abigen, Contract, Multicall},\n providers::{Http,"
},
{
"path": "momoka-rs/src/contracts/mod.rs",
"chars": 18,
"preview": "pub mod lens_hub;\n"
},
{
"path": "momoka-rs/src/environment.rs",
"chars": 3783,
"preview": "use std::str::FromStr;\n\nuse ethers::types::Address;\n\n/// Represents different deployment environments.\n#[derive(Debug, C"
},
{
"path": "momoka-rs/src/evm.rs",
"chars": 2976,
"preview": "use std::{str::FromStr, time::Duration};\n\nuse ethers::{\n providers::{Http, HttpRateLimitRetryPolicy, Provider, RetryC"
},
{
"path": "momoka-rs/src/http.rs",
"chars": 2748,
"preview": "use reqwest::Client;\nuse serde::de::DeserializeOwned;\nuse serde::Serialize;\nuse std::thread::sleep;\nuse std::time::Durat"
},
{
"path": "momoka-rs/src/logger.rs",
"chars": 1535,
"preview": "use crate::utils::get_current_utc_string;\n\n/// A logger for printing log messages in different colors.\npub struct Logger"
},
{
"path": "momoka-rs/src/main.rs",
"chars": 9259,
"preview": "mod bundlr;\nmod cache;\nmod contracts;\nmod environment;\nmod evm;\nmod http;\nmod logger;\nmod submitter;\nmod types;\nmod util"
},
{
"path": "momoka-rs/src/submitter/mod.rs",
"chars": 15,
"preview": "pub mod state;\n"
},
{
"path": "momoka-rs/src/submitter/state.rs",
"chars": 3371,
"preview": "use std::str::FromStr;\n\nuse ethers::types::Address;\n\nuse crate::environment::{Deployment, Environment};\n\n/// Returns the"
},
{
"path": "momoka-rs/src/types/chain_proofs.rs",
"chars": 1929,
"preview": "use ethers::types::H256;\nuse serde::{Deserialize, Serialize};\n\nuse super::{eip721::TypedData, transaction::TransactionPo"
},
{
"path": "momoka-rs/src/types/eip721.rs",
"chars": 3720,
"preview": "use ethers::types::{\n transaction::eip712::{EIP712Domain, Eip712DomainType},\n Address, U256,\n};\nuse serde::{Deseri"
},
{
"path": "momoka-rs/src/types/evm_event.rs",
"chars": 2177,
"preview": "use ethers::types::Address;\nuse serde::{Deserialize, Serialize};\n\nuse super::{hex::Hex, profile_id::ProfileId, publicati"
},
{
"path": "momoka-rs/src/types/hex.rs",
"chars": 2271,
"preview": "use ethers::types::U256;\nuse serde::{Deserialize, Deserializer, Serialize, Serializer};\nuse std::fmt;\n\n#[derive(Debug, C"
},
{
"path": "momoka-rs/src/types/mod.rs",
"chars": 159,
"preview": "pub mod chain_proofs;\npub mod eip721;\npub mod evm_event;\npub mod hex;\npub mod profile_id;\npub mod publication_id;\npub mo"
},
{
"path": "momoka-rs/src/types/profile_id.rs",
"chars": 4198,
"preview": "use ethers::types::U256;\nuse serde::{Deserialize, Deserializer, Serialize, Serializer};\nuse std::fmt;\n\n/// Represents a "
},
{
"path": "momoka-rs/src/types/publication_id.rs",
"chars": 3829,
"preview": "use ethers::types::U256;\nuse serde::{Deserialize, Deserializer, Serialize, Serializer};\nuse std::fmt;\n\n/// Represents a "
},
{
"path": "momoka-rs/src/types/transaction.rs",
"chars": 30809,
"preview": "use std::str::FromStr;\n\nuse crate::evm::ProviderContext;\nuse crate::verifier::transactions::comment::verifier_comment;\nu"
},
{
"path": "momoka-rs/src/types/verifier_error.rs",
"chars": 4187,
"preview": "use serde::{Deserialize, Serialize};\nuse std::{\n error::Error,\n fmt::{Display, Formatter, Result},\n};\nuse strum_ma"
},
{
"path": "momoka-rs/src/utils.rs",
"chars": 412,
"preview": "use chrono::Utc;\n\n/// Gets the current UTC time as a formatted string.\n///\n/// The formatted string follows the format \""
},
{
"path": "momoka-rs/src/verifier/mod.rs",
"chars": 37,
"preview": "pub mod proof;\npub mod transactions;\n"
},
{
"path": "momoka-rs/src/verifier/proof.rs",
"chars": 24094,
"preview": "use json::JsonValue;\nuse regex::Regex;\nuse std::{\n collections::{HashMap, HashSet},\n str::FromStr,\n sync::Arc,\n"
},
{
"path": "momoka-rs/src/verifier/transactions/comment.rs",
"chars": 5861,
"preview": "use crate::{\n contracts::lens_hub::get_profile_details,\n environment::environment_to_lens_hub_contract,\n evm::P"
},
{
"path": "momoka-rs/src/verifier/transactions/common.rs",
"chars": 1941,
"preview": "use std::{collections::BTreeMap, str::FromStr};\n\nuse ethers::types::{\n transaction::eip712::{EIP712Domain, Eip712, Ei"
},
{
"path": "momoka-rs/src/verifier/transactions/mirror.rs",
"chars": 5566,
"preview": "use crate::{\n contracts::lens_hub::get_profile_details,\n environment::environment_to_lens_hub_contract,\n evm::P"
},
{
"path": "momoka-rs/src/verifier/transactions/mod.rs",
"chars": 59,
"preview": "pub mod comment;\nmod common;\npub mod mirror;\npub mod post;\n"
},
{
"path": "momoka-rs/src/verifier/transactions/post.rs",
"chars": 9471,
"preview": "use crate::contracts::lens_hub::{lens_hub_contract, Eip712Signature, ILensHub, PostWithSigData};\nuse crate::environment:"
}
]
About this extraction
This page contains the full source code of the lens-protocol/momoka GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 179 files (892.2 KB), approximately 231.8k tokens, and a symbol index with 591 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.