moonbeam-foundation / moonbeam-docs Goto Github PK

Prize Title

ETH-Shanghai Hackathon Best Moonbeam Project

Prize Bounty

USDC $3000, split between winners if there are more than one. And other rewards tailored to help your project grow:

• A fast track pass for applying to the Moonbeam Foundation Grants Program and ecosystem funds. The Moonbeam Foundation is dedicated to promoting the development, growth, and adoption of Moonbeam and its ecosystem. Projects that add value to the Moonbeam ecosystem are eligible for funding opportunities
• Co-marketing exposure and access to Moonbeam Global ambassadors (KOLs, Communities, media, investors, etc.); acquire remarkable community powers (user traffic, TVL, community exposure, etc.)
• In-depth technical support of multi-chain development starts from the Moonbeam developer infrastructure
• Sustainable funded supports and incubation programs operating by top-tier VCs
• Smart contract security audit resources and compliance advisory
• And much more!

Challenge Description

Moonbeam is the fully Ethereum-compatible smart contract platform on Polkadot. This compatibility makes deploying new or existing Solidity DApps quick and easy, using all the familiar tools from the Ethereum toolchain such as Hardhat, Remix and Scaffold-ETH. This hackathon is an opportunity to get your feet wet in this new ecosystem and start developing with workshops, live support, and prizes.

Participating projects must deploy to Moonbeam, Moonriver or the Moonbase Alpha TestNet.

Challenge 1: Develop a DApp using Moonbeam Precompiles

Develop a DApp using a Moonbeam precompile that allows applications or Solidity smart contracts to interact with Substrate functions through a Solidity interface.

Precompiles, a precompiled piece of code or smart contract, are originally used by Ethereum, for commonly used encryption and hashing algorithms, such as SHA256, RIPEMD56, Keccak256, etc.

Precompiles are also a type of Substrate primitive, an important part of building cross-chain interactions and interacting with Substrate pallets.

Currently, Moonbeam supports a number of precompiles, including Parachain Staking, Pallet Democracy, xTokens, XCM transactor, Author Mapping, etc. Through these precompiles, developers can easily create applications that interact with Substrate pallet functions, and create DApps such as:

• Staking DAO
• XC-20 asset dashboard
• XC-20 wallet
• On-chain governance and voting DApp
• Collator candidate DAO
• And more

Read more about Moonbeam precompiles & XC-20:

• Complete List of Moonbeam Precompiles
• Precompiled Developer Documentation
• Moonbeam Development Introductory Course - Developing a Delegation DAO with Precompiles (English)
• Moonbeam Development Introductory Course - Developing a Delegation DAO with Precompiles (Chinese)

Challenge 2: Tokenized SocialFi or DeFi DApp

Tokenization and incentive design lie at the root of decentralized application design. Develop and deploy any tokenized SocialFi or DeFi DApp on a Moonbeam network.

Extra points will be awarded to projects that utilize Moonbeam's XC-20 native cross-chain features and assets, such as xcDOT, xcKSM, or the xTokens precompile, on Moonbeam.

XCM is a foundational new technology of Polkadot that allows heterogeneous blockchains to interoperate and seamlessly transfer value. XCM functionality recently debuted on Moonriver with the introduction of the XC-20 standard, a Substrate-native asset that conforms to ERC-20 standards. xcKSM, or KSM migrated from the Kusama Relay Chain, is the first XC-20 to launch on Moonriver.

• XCM Developer Docs
• xTokens precompile

Challenge 3: Create Any NFT based DApp on Moonbeam

Moonbeam and Moonriver have a vibrant and growing NFT ecosystem, and support all NFT standards found on Ethereum. With the upcoming XCM v3 standard, NFT's will be able to cross chain natively within the Polkadot ecosystem (learn more).

Develop and deploy any NFT related DApp on a Moonbeam network to anticipate the upcoming crosschain NFTs on Polkadot. This can be NFT tooling such as NFT deployment tools or NFT explorers, NFT showcase or wallets, NFT games, and so on. These DApps can integrate with any existing NFT platforms and projects on Moonbeam and Moonriver, and use their data.

• Moonbeam NFT Scan
• Partial list of Moonriver NFT projects

Submission Requirements

• Link to GitHub repo containing the source code of the DApp being submitted
• Team description and contact information in the README file of the GitHub repo
• Presentation and demo at the online demo day or a submission of a video demo illustrating product features

Judging Criteria

• Originality (20%)
• Integration with Moonbeam (20%)
• Use of Moonbeam Features (20%)
• Product Design (10%)
• Implementation (20%）
• Presentation and Demo (10%)

Winner Announcement Date

June 10th, 2022

Resources

• ETH-Shanghai Hackathon Discord
• Moonbeam Discord
• Moonbeam Developer Documentation
• How to Connect to a Moonbeam Network
• Moonbeam Block Explorers
• Using Scaffold-ETH with Moonbeam
• Using Hardhat with Moonbeam
• Using Remix with Moonbeam
• Using the Graph with Moonbeam
• Using Chainlink with Moonbeam
• Get Dev Tokens on Moonbase Alpha

GetBlock is a service that provides instant API access to more than 40 leading blockchains, including Moonbeam and Moonriver available for shared and dedicated nodes.
GetBlock offers an option: dedicated Moonbeam and Moonriver nodes and shared nodes for Moonbeam and Moonriver.

Get started with GetBlock

Register an account

Open GetBlock Dashboard and Set you API Key
Generate your endpoint

Search for the necessary blockchain then choose the network, proceed by clicking “create” and there it is!

I browsed Moonbeam's official documentation and found a XC-20 tutorial for cross-chain transfers https://docs.moonbeam.network/builders/xcm/xc20/xtokens/ but it was taught using Moonbeam Alphanet's environment and did not use https://github.com/PureStake/moonbeam/tree/master/tools link to set up transfers between local parachains. Instead, my local environment was launched with the command npm run launch -- --parachain moonbase-0.26.0 --parachain moonbase-0.26.0 My ultimate goal is that I need to test XC-20 transfers on my local machine（no public IP）, how should I do this?

Thanks!

Following https://docs.moonbeam.network/builders/tools/pubsub/#check-if-a-node-is-synchronized-with-the-network query the syncing status, the return result seems empty.

• Test script:

const Web3 = require("web3");
const web3 = new Web3('wss://wss.testnet.moonbeam.network');


web3.eth
  .subscribe("syncing")
  .on("connected", function (subscriptionId) {
    console.log(subscriptionId);
  })
  .on("data", function (log) {
    console.log(log);
  });

• Output:

> node test_sync.js                                                                                      ~/w/d/d/tests
0x44546f334c704d6d6e356e4c41727a76

On the foundry page: https://docs.moonbeam.network/builders/build/eth-api/dev-env/foundry/#creating-a-foundry-project

we should {target=_blank) in the main body text for some reason:

Looks to be a bad brace, it's a ) erroneously.

You don't need to run polkadot-ui to connect to chopsticks. polkadot.js.org/apps/ will do

See https://docs.moonbeam.network/node-operators/networks/tracing-node/#run-a-tracing-node

We no longer need the native runtime for tracing thanks to some awesome work by Telmo and Jeremy.

Originally reported in moonbeam-foundation/moonbeam#1060 (comment) (thanks @omryr)

The following Issue is a description of an AmsterDOT Bounty and is not meant to convey an issue with Moonbeam-Docs

Description:
One of the first major applications of XCM on Moonbeam is sending and receiving assets from other parachains. But did you know Moonbeam also enables you to create your own custom cross-chain assets? The challenge is to create a custom cross-chain asset that is owned by a smart contract on Moonbase Alpha. In the course of your work on this project, you should:

• Submit a democracy proposal asking for local asset creation and set a smart contract that you have designed as the owner of the asset.
• Demonstrate a cross-chain use case for the custom asset.
• Demonstrate that the owner of the smart contract can mint/burn tokens.
• Demonstrate that the custom asset can be sent to another parachain via XCM using XTokens.sol. You can do this via Remix. No need to create a front-end.
• Your finished project should be deployed to Moonbase Alpha.

Helpful resources:

• Governance on Moonbeam: https://docs.moonbeam.network/learn/features/governance/
• XCM Overview: https://docs.moonbeam.network/builders/xcm/overview/
• Interacting with XC20s: https://docs.moonbeam.network/builders/xcm/xc20/
• Using XTokens.sol: https://docs.moonbeam.network/builders/xcm/xc20/xtokens/
• How to Interact with xcRMRKs: https://youtu.be/G0882jjbohw
• How to Interact with Cross Chain Assets on Moonriver: https://youtu.be/5hI59Bum4dU
• XC-20s: The New Standard for Cross-Chain Tokens on Dotsama: https://moonbeam.network/blog/introducing-xc-20s-the-new-standard-for-cross-chain-tokens-on-dotsama/
• Get XC-20 Tokens on Moonbase Alpha here: https://moonbeam-swap.netlify.app/#/swap
• Moonbeam Discord for DEV Faucet Funds and Technical Support: https://discord.gg/moonbeam

Judging Criteria:
Projects will be judged based on the overall quality of the submission, with an emphasis on the user experience.

When I run this command on my terminal "truffle migrate --network dev" I get this error Error(PollingBlockTracker - encountered an error while attempting to update latest block:\n${err.stack})

I'd love to add our Ankr Moonbeam RPCs to your list of Endpoint Providers. We have a free public one here: https://www.ankr.com/protocol/public/moonbeam/ that requires zero sign up, and you can just get started straight away. (We've also got a premium plan that allows you to sign up to all our multi-chain RPCs).

The new flag is --trie-cache-size according to ./moonbeam --help

The following Issue is a description of an AmsterDOT Bounty and is not meant to convey an issue with Moonbeam-Docs

Description:
XCM is a foundational new technology of Polkadot that allows heterogeneous blockchains to interoperate and seamlessly transfer value. XCM functionality was enabled on Moonriver by introducing the XC-20 standard, a Substrate-native asset that conforms to ERC-20 standards. xcKSM or KSM migrated from the Kusama Relay Chain, is the first XC-20 to launch on Moonriver and allows KSM to be harnessed in the growing DeFi ecosystem in Moonriver. xcKSM is already tradable on several decentralized exchanges.

XC-20s look and behave like typical ERC-20s, which means that interacting with them is easy. However, before getting started, you should understand the fundamentals of how XCM works. In this challenge, build a project that harnesses XC-20s on Moonriver. In thinking through your project idea, there are two user scenarios to consider.

At a minimum, your project should address the needs of a user who already has XC-20s. The simplest project for this bounty is a DApp that is compatible with XC-20s. Given that XC-20s behave exactly like ERC-20s, this is a straightforward integration.

A complete project would be one that considers a user who does not yet have XC-20s on Moonriver. This holistic approach would consider a user’s token balances across multiple chains (such as Moonriver and the Kusama relay chain). Sample project ideas include DeFi applications for XC-20s, unified wallets that track balances across chains, and unified XCM block explorers.

Requirements:

• Your project should have a front-end (a basic one is fine).
• Your finished project should be deployed to Moonbase Alpha.

Helpful resources:

• XCM Overview: https://docs.moonbeam.network/builders/xcm/overview/
• Interacting with XC20s: https://docs.moonbeam.network/builders/xcm/xc20/
• How to Interact with xcRMRKs: https://youtu.be/G0882jjbohw
• How to Interact with Cross Chain Assets on Moonriver: https://youtu.be/5hI59Bum4dU
• Moonbuilder’s Workshop - A Technical Introduction to XCM on Moonbeam: https://youtu.be/5HD5rFBqvQ4
• XC-20s: The New Standard for Cross-Chain Tokens on Dotsama: https://moonbeam.network/blog/introducing-xc-20s-the-new-standard-for-cross-chain-tokens-on-dotsama/
• Get XC-20 Tokens on Moonbase Alpha here: https://moonbeam-swap.netlify.app/#/swap
• Moonbeam Discord for DEV Faucet Funds and Technical Support: https://discord.gg/moonbeam

Judging Criteria:
Projects will be judged based on the overall quality of the submission, with an emphasis on the user experience.

Hello,

I am doing the Moonbuilder Academy course. I am in lesson 4.
When the video gets to time slot 3:02, a document is opened with the keys for the example. Where can I find that document?

Since those are just test accounts, the keys should be written in the documentation and easy to find.

Every call to the xcDOT contract fails when using forge, here is an example

interface StandardErc20 {
    function approve(address to, uint256 amount) external returns (bool);
}

contract SimpleXcDotTest {
    function testDotApprove() public {
        address xcDotAddress = 0xFfFFfFff1FcaCBd218EDc0EbA20Fc2308C778080;

        StandardErc20 xcDot = StandardErc20(xcDotAddress);

        // this fails
        xcDot.approve(address(2), 2e18);
    }
}

Running 1 test for contracts/test/sol:SimpleXcDotTest.sol:SimpleXcDotTest
[FAIL. Reason: EvmError: Revert] testDotApprove() (gas: 2879)
Traces:
  [2879] SimpleXcDotTest::testDotApprove() 
    ├─ [6] 0xffff…8080::095ea7b3(00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000001bc16d674ec80000) 
    │   └─ ← ()
    └─ ← "EvmError: Revert"

Test result: FAILED. 0 passed; 1 failed; finished in 1.39s

Failing tests:
Encountered 1 failing test in contracts/test/sol:SimpleXcDotTest.sol:SimpleXcDotTest
[FAIL. Reason: EvmError: Revert] testDotApprove() (gas: 2879)

eth_newPendingTransactionFilter is not supported by Frontier but in our docs we say it is supported (https://docs.moonbeam.network/builders/get-started/eth-compare/rpc-support/#filter-rpc-methods)

This is the Frontier relevant code -> https://github.com/paritytech/frontier/blob/5bd0dc7aef2054cb881037a40866df3ce47b3b9e/client/rpc/src/eth/filter.rs#L126-L128

The instructions at https://docs.moonbeam.network/node-operators/networks/collator/#checking-the-mappings show users how to read the entire set of mappings. When the set of mappings grows large this is expensive for the node to lookup and also hard for the user to read.

Rather, they should include their own author Id as a parameter an only look up their own mapping.

Update the Polkadot.js documentation to include a warning message for Brave Browser users to disable Brave Shield.

When I get to the part "Using the Moonbeam Truffle Plugin to Run a Node", I do the first step, which is to Download the corresponding Docker image: truffle run moonbeam install

I always get this error below:
Error response from daemon: manifest for purestake/moonbeam:runtime-2302 not found: manifest unknown: manifest unknown

The pages for Run a Node on Moonbeam Using Systemd
and Run a Node on Moonbeam Using Docker should be updated with the latest recommended options.

• --execution wasm is default, doesn't need to be explicitly set
• --wasm-execution compiled is default, doesn't need to be explicitly set
• --trie-cache-size 0 might want to double check if this is still the recommendation for collators as i thought cache is meant to improve performance not degrade.
• --sync <strategy> Depending on whether we think these instructions are intended for people wanting to run full nodes for RPC reasons - or builder teams for their own infra, we should probably encourage them to use the quicker sync methods.