No Jargon. No Nonsense. Just a simple developer experience that helps you build the next generation of blockchain powered smart apps.
Build what's next
In just a few lines of code, you can start building something incredible.
Don’t believe us? Here’s how.
Lamden Wallet IDE
The Lamden Wallet has a inbuilt python IDE that makes it simple to start building smart contracts in minutes, not days.
Below is the code for Lamden Paints‘ smart contract. It’s simple, and uses a Hash (Similar to Python Dictionary) to store data for painting pixels on an x and y grid.
data = Hash(contract='con_paint', name='data')
@export('con_paint')
def paint(x: int, y: int, c: str):
data[x, y] = cNeed something more advanced? We’ve got that too. You can write smart contracts anywhere you write python code.
Visual Studio. PyCharm. Brackets.
It all just works, because it’s native python.
Learn More about Smart Contracts»
Learn More about the Wallet IDE»
Lamden Wallet API
Built your backend with python, and now you’re building a web frontend? Connecting to the wallet is simple with the Javascript Lamden Wallet API.
const detail = JSON.stringify({
appName: 'Lamden Paint',
version: '1.0.8',
logo: '/logo.png', //or whatever the location of your logo
background: '/background.png',
contractName: 'con_paint', //should never change
networkType: 'mainnet', // other option is 'testnet'
})
document.dispatchEvent(new CustomEvent('lamdenWalletConnect', {
detail
}));
Now you have permission to interact with the users wallet and send transactions.
Javascript not for you? That’s cool. Try the Unity Plugin, or connect manually to the Lamden Masternode API.
Lamden Wallet API
Now it’s time to send your transaction.
In this example we’re painting a pixel on the paint method on the contract we approved in step 2. We’re painting the pixel at x=3 and y=14 to be #aaff00.
const detail = JSON.stringify({
//Which Lamden Network to send this to
//mainnet, testnet are the only acceptable values
networkType: 'mainnet',
//The method in your contract to call
methodName: 'paint',
//The argument values for your method
kwargs: {
x: 3,
y: 14,
c: #aaff00
},
//The maximum amount of stamps this transaction is allowed to use
//Could use less but won't be allowed to use more
stampLimit: 10
});
document.dispatchEvent(new CustomEvent('lamdenWalletSendTx', {detail}));
That’s it! Your transaction has been posted to the blockchain.
Pending your users approval of course.
Lamden Masternode API
Now, if we wanted to get the state from the contract for a certain pixel, we could simply send a request to the REST Lamden Masternode API.
Obviously, we don’t want to be sending a million requests to the API for the whole pixel grid, but this is a good starting off point for developing your app.
To get the data for the pixel at x=0 and y=0 we just send a request to:
https://masternode-01.lamden.io/contracts/con_paint/data?key=0:0And here’s the response:
{"value":"#a83d10"}Alternatively we could have used contracting to get the state of the contract, or used the Lamden Wallet API to get the status of any of the transactions we sent earlier.
Simple! It’s easy-to-use powerful tools like these that make creating decentralised applications with Lamden as simple as creating traditional applications.
Next Steps
- Explore the Smart Contract Docs
- Learn the Lamden Wallet IDE
- Learn the Lamden Masternode API
- See it all come together with the Lamden Paint dApp (requires Lamden Wallet and TAU balance)
Meet the Lamden Toolset
Flexible tools that help you build things faster.
Build and Deploy Smart Contracts
Python – Build and Deploy Smart Contracts in minutes from within the browser.
Python – Build, Deploy and Interact with smart contracts faster with Python Contracting.
Interact with the Lamden Wallet Browser Extension
Javascript – Easily connect to the Lamden Wallet and your smart contracts from within the users browser.
Javascript – Interact with the Lamden Wallet API via a webpage with a modern callback/promise workflow.
Interact with the Lamden Blockchain Directly
With Lamden, It's possible
Learn how businesses and developers all over the world are creating exciting dApps on the Lamden Ecosystem.
Learn the process
Conceptualise your app and learn how the toolset can help make your application a reality faster than on any other blockchain.
1. Plan your app
With developers currently receiving 90% of all transaction fees, you can monetise your application from Day 1 with ease.
Think about monetisation, what will be done on and off-chain, and what technologies you’ll use to build your frontend.
Build python smart contracts as your applications backend. And do as little, or as much processing on the blockchain as you’d like.
Build in monetization, game mechanics, tokens, DeFi elements or anything you can think of with Python.
3. Build your frontend
Build your front-end using Unity, Python, Javascript, or go all out and interact with the REST API to build an incredible frontend for your Smart Contract.
Lamden Sàrl