DEV Community: Alex

$20,000 Blockchain Grant Open for African Developers: Build a Micro-Payments MVP on Fedrok Blockchain

Alex — Fri, 16 May 2025 15:15:28 +0000

Funding Opportunity for African Tech Builders Looking to Solve Real-World Financial Access Challenges

If you’re a developer or fintech builder in Africa looking for funded, real-world blockchain projects, here’s an opportunity you might want to jump on.

Fedrok AG, a Swiss blockchain technology company, has opened applications for a $20,000 grant to support the design and development of a micro-transaction platform built on its EVM-compatible blockchain.

The project is focused on building solutions for low-cost, secure digital transactions in Chad and Niger, two of Africa’s most underbanked regions. The aim is to make digital payments more accessible for everyday users, including small businesses and rural communities with limited internet connectivity.

This is not a hackathon or theoretical exercise, it’s a funded opportunity to build and deploy a real MVP with the potential for long-term partnership and market impact.

What’s On Offer

Successful applicants will receive:

$20,000 in milestone-based funding
Technical documentation and mentorship from Fedrok’s blockchain team
Access to the Fedrok Blockchain platform for development and deployment
The chance to deploy in Chad and Niger, with real user impact
Potential ongoing collaboration after the MVP phase

What You’ll Be Building

The goal is to develop a mobile-first micro-transaction platform designed for financial inclusion in low-bandwidth environments.

Key features should include:

Peer-to-peer (P2P) and small business payments
USSD or SMS-based user interfaces, in addition to web or app access
Wallet functionality, including identity verification and transaction history
Multi-language support, with French required and local languages optional
Full integration with Fedrok Blockchain for transaction transparency and security

Who Can Apply

Fedrok is looking for Africa-based developers or teams who:

Have experience in blockchain, fintech, or micro-payment platform development
Understand the local context and user needs in Chad and Niger

Whether you’re part of a startup, a tech hub, or an independent team, you’re eligible to apply if you meet the above criteria.

Why This Matters

Africa is already recognized as a global leader in mobile money adoption, but blockchain-powered micro-payments remain largely unexplored at scale. This grant offers developers a chance to:

Build a working blockchain application with real social impact
Address financial exclusion in two of Africa’s most underserved markets
Test and validate their solution with the backing of a Swiss-registered blockchain company

While Fedrok may not yet be a household name in Africa’s tech scene, the company has positioned itself as a blockchain player focused on environmental and social impact, not just speculation. This challenge reflects their mission to connect blockchain utility with real-world needs.

How to Apply

Submit your proposal by June 1, 2025
Send it to: grants@fedrok.com
Use the subject line: “MVP Micro-Transaction Platform Proposal – [Your Team Name]”

Your proposal should include:

Executive Summary of your idea
Technical Approach and architecture
Development Timeline with milestones
Team Profiles and relevant experience
Budget Breakdown
Deployment and Go-to-Market Strategy for Chad and Niger

Shortlisted applicants may be invited for a virtual interview to discuss their proposal in more detail.

Get Involved: Build Impactful Blockchain Solutions for Africa

If you’re passionate about using technology to solve real-world challenges and you have the skills to deliver scalable, low-cost financial solutions, don’t miss this opportunity.

The deadline is June 1, 2025, so start preparing your proposal today.

For more information and submission details, visit https://bit.ly/abifedrok.

Hack the Grid: LUKSO's Final Call to Web3 Builders with $150K in Prizes

Alex — Thu, 24 Apr 2025 15:31:59 +0000

LUKSO’s “Hack the Grid” hackathon is in its final phase, giving developers just under two weeks to build and submit mini-dApps powered by smart contract accounts, gasless UX, and Universal Profiles.

Backed by LUKSO’s Foundation for the New Creative Economies (FNCΞ), this final wave of the Hack the Grid Hackathon invites developers to experiment with a new design space for Web3: one where identity, ownership, and social interaction are native to the stack.

Why Build on LUKSO?

LUKSO is a Layer 1 EVM blockchain, but it’s not just “another chain.” It was built from the ground up with Universal Profiles, smart contract-based accounts with customizable permissions, metadata, and social features, that solve the UX and security issues plaguing traditional EOAs.

For developers, that means:

No gas tokens required for users (transactions can be relayed)
Fine-grained permissions and secure controller logic (via Key Manager)
Reactive contracts that can respond to on-chain events
Built-in support for digital identity, token registries, and automation

In other words: the blockchain account becomes the platform.

Funding & Track Details

The current round offers $150,000 in LYX across multiple grant tiers:

Prime Grants – 2 winners × $9,000
Core Grants – 3 winners × $5,000
Origin Grants – 4 winners × $2,250
Level 4: Community Grants – $24,000 distributed via quadratic funding on Gitcoin

Developers are invited to submit mini-dApps that leverage Universal Profiles and the LUKSO Standard Proposals (LSPs), a new suite of smart contract standards designed for user-centric applications.

Suggested themes include:

Onchain social tools
DAO & treasury management
Custom profile extensions
Smart token & NFT utilities
DePIN integrations
Wallet-less onboarding experiences

Resources & How to Apply

Apply and submit here: https://lukso.gitcoin.co
Hackathon guide and submission tips: Best Practices

The hackathon runs through early May 2025, with submission deadlines fast approaching. Winning projects not only receive grants but also increased visibility across the LUKSO ecosystem, including potential inclusion in the Universal Everything platform and long-term funding via the LUKSO Grants Program.

As the crypto space moves beyond DeFi and speculation, LUKSO is creating what a truly usable, creator-friendly Web3 can look like. With standards for social recovery, metadata-rich NFTs, programmable identities, and gasless onboarding, the chain is designed for builders who care about UX, privacy, and long-term adoption.

“This is your chance to build something people can actually use, not just trade,”
says the LUKSO team.

“We’ve built the infrastructure. Now it’s time to build the experiences.”

Final submissions due in less than two weeks. Don’t miss your chance to be part of what many are calling the New Web3, one built for humans.

Building Secure, Scalable, and Cross-chain dApps with Agoric’s Orchestration API

Alex — Tue, 13 Aug 2024 17:17:11 +0000

If you’ve ever tried to build a cross-chain application, you’ve probably experienced the headaches of managing multiple blockchains, each with its unique properties and challenges. It’s a bit like juggling while riding a unicycle, except the unicycle is on fire. The fragmented nature of the blockchain space makes interoperability a true test of patience and skill. From managing different consensus algorithms and transaction finalities to dealing with varied programming languages and security models, the obstacles are endless.

Current Challenges When Building in the Crypto Space

One of the first things I realized was how isolated each blockchain is, they're all speaking different languages. This fragmentation means cross-chain communication is far from straightforward. Add to that the constant worry about security, with each chain having its own security model, ensuring the safety of assets and data as they move across chains is nerve-wracking.

Then there's the complexity of it all, switching between different programming languages and environments feels like constantly having to switch between different operating systems, each with its peculiarities. And, of course, there’s scalability. Building something that can grow across multiple chains without falling apart? Now that's a whole other story.

As you see, the need for seamless, secure, and scalable solutions is critical. Recently, I came across Agoric’s Orchestration tools, and they seem to take a lot of that pain away.

Introducing Agoric

Agoric is a Cosmos-based Layer 1 blockchain designed for building cross-chain smart contracts in JavaScript. By leveraging JavaScript, Agoric makes blockchain programming accessible to the large community of developers familiar with the language. Its new orchestration tools enable developers to build decentralized applications (dApps) that can securely and efficiently interact across multiple blockchains, solving the interoperability challenges faced in the crypto space.

Key Features of Agoric

Async/Await & Multi-Block Execution: Supports long-lived processes and cross-chain actions, making it easier to build applications with rich features.

Timers: Allows smart contracts to perform actions at predefined times, enhancing their autonomy and complexity.

Interoperability: Native support for Inter-Blockchain Communication (IBC) and extensions like Axelar’s General Message Passing (GMP) provide access to a wide range of blockchain networks.

JavaScript Smart Contracts: Written in a hardened version of JavaScript, offering advanced safety features and composability akin to web development frameworks like ReactJS.

Step-by-Step Guide to Using Agoric's Orchestration API

Agoric's Orchestration API simplifies building multi-chain applications by providing tools to manage cross-chain accounts, execute asynchronous tasks, and handle complex workflows. Here’s a step-by-step guide on how to use these tools to build a secure and scalable dApp.

Getting Started with the Orchestration API

Setup:
Install the necessary libraries and dependencies.

npm install @agoric/sdk

Initialize the Orchestration:
Import the orchestration tools and set up your environment.

import { makeChainHub, Orchestrator } from '@agoric/sdk';

const orchestrator = new Orchestrator();
const chainHub = makeChainHub(remotePowers.agoricNames);

Register Chains:
Connect the Agoric chain to other blockchains.

chainHub.registerChain('polygon', { /* Polygon chain info */ });
chainHub.registerConnection('agoric', 'polygon', { /* Connection info */ });

Create Accounts:
Create accounts on the registered chains.

const polygonAccount = await chainHub.getChain('polygon').makeAccount();
const agoricAccount = await chainHub.getChain('agoric').makeAccount();

Manage Interchain Accounts (ICA):
Use ICAs to control accounts on other blockchains.

const polygonAddress = await polygonAccount.getAddress();

Example: Orchestrating Multi-Chain Staking

Take, for example, a scenario where a user wants to stake MATIC tokens from Polygon on the Cosmos Hub. In the past, this would have required multiple steps, each with potential pitfalls. But with Agoric’s Orchestration, the process is streamlined. You can deposit the tokens, swap them, and stake them, all within a coherent workflow that doesn’t require endless code switching. The fact that you can orchestrate this entire process with a few API calls hits home how much easier multi-chain development can be.

The steps will look something as the following:

Deposit Tokens: Transfer MATIC tokens from the user's wallet to the Agoric chain.

const depositMsg = { /* Transfer details */ };
await agoricAccount.transferSteps(depositMsg);

Swap Tokens: Swap MATIC for ATOM on the Agoric chain.

const swapMsg = { /* Swap details */ };
await agoricAccount.transferSteps(swapMsg);

Stake Tokens: Stake the converted ATOM tokens on the Cosmos Hub.

const stakingMsg = { /* Staking details */ };
await polygonAccount.delegate(stakingMsg);

Here’s a detailed walkthrough of a smart contract that performs cross-chain staking will look as follows:

import { withOrchestration } from '@agoric/sdk/utils';
import { makeNatAmountShape } from '@agoric/sdk/amounts';

const contract = async (zcf, privateArgs, zone, { orchestrate }) => {
  const { brands } = zcf.getTerms();

  const stakeAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
    const { give } = seat.getProposal();
    const polygon = await orch.getChain('polygon');
    const agoric = await orch.getChain('agoric');

    const [polygonAccount, localAccount] = await Promise.all([
      polygon.makeAccount(),
      agoric.makeAccount(),
    ]);

    const polygonAddress = polygonAccount.getAddress();

    const payments = await withdrawFromSeat(zcf, seat, give);
    await deeplyFulfilled(objectMap(payments, payment => localAccount.deposit(payment)));
    seat.exit();

    const transferMsg = orcUtils.makeOsmosisSwap({
      destChain: 'polygon',
      destAddress: polygonAddress,
      amountIn: give.Stable,
      brandOut: '...',
      slippage: 0.03,
    });

    try {
      await localAccount.transferSteps(give.Stable, transferMsg);
      await polygonAccount.delegate(offerArgs.validator, offerArgs.staked);
    } catch (e) {
      console.error(e);
    }
  };

  const swapAndStakeHandler = orchestrate('LSTTia', { zcf }, stakeAndSwapFn);

  const publicFacet = zone.exo('publicFacet', undefined, {
    makeSwapAndStakeInvitation() {
      return zcf.makeInvitation(
        swapAndStakeHandler,
        'Swap for TIA and stake',
        undefined,
        harden({
          give: { Stable: makeNatAmountShape(brands.Stable, 1n) },
          want: {},
          exit: M.any(),
        }),
      );
    },
  });

  return harden({ publicFacet });
};

export const start = withOrchestration(contract);

Conclusion

In the end, Agoric’s Orchestration API made what used to be a complicated task into something almost routine. By leveraging familiar JavaScript patterns and offering robust APIs, it feels like the days of wrestling with blockchain fragmentation might finally be behind us. For anyone building in this space, it’s worth exploring. Sometimes, the right tools make all the difference.