GitLocker: The Coding Marketplace

Description:

flutter web3

flutter_web3

This is a fork of flutter_web3_provider. Be sure to check out the original package.

Introduction #
flutter_web3 v2 is full Dart class and function wrapper for

Ethereum object from provider, i.e. MetaMask.
Ether.js package

This can be used to sign transaction and interact with smart contract, also query Blockchain data utils and a lot of helper function for developing dapps.

Wallet Connect Provider package

This enable QR code modal interaction and enable wallet that utilize Wallet Connect to use provider.

This package is made especially for developing Dapp on cross(multiple) chain in Flutter Web
V2.1 Changes #
Version 2.1 introduce EIP-1559 properties for various object.

gasPrice property on many(all) class is now nullable.

will be null on mainnet but not null on fork or chain that not yet implement EIP-1559.

Added maxFeePerGas and maxPriorityFeePerGas properties to Transaction, TransactionRequest, and TransactionOverride.
Added getFeeData method to Provider.
Added baseFee property to Block.

Pull requests for missing features/properties are always welcomed.

Example Usage And Tutorial #

Auction

A ERC20 token auction website built by Flutter
https://github.com/y-pakorn/flutter_web3_auction

Building Modern Web Dapp with Flutter

https://medium.com/coinmonks/building-modern-web-dapp-with-flutter-91656c71d8b

Getting Started #
Installing #
To use Flutter Web3 package, use
flutter pub add flutter_web3
copied to clipboard
Ethers JS and Wallet Connect Provider
To use Ethers JS and Wallet Connect Provider, we need to include script to JS package in web/index.html

<script src="https://cdn.ethers.io/lib/ethers-5.4.umd.min.js" type="application/javascript"></script>

<script src="https://cdn.jsdelivr.net/npm/@walletconnect/web3-provider@1.6.5/dist/umd/index.min.js" type="application/javascript"></script>
copied to clipboard

Ethereum Provider #
Prompt the connection to MetaMask or other provider.
// `Ethereum.isSupported` is the same as `ethereum != null`
if (ethereum != null) {
try {
// Prompt user to connect to the provider, i.e. confirm the connection modal
final accs = await ethereum!
.requestAccount(); // Get all accounts in node disposal
accs; // [foo,bar]
} on EthereumUserRejected {
print('User rejected the modal');
}
}
copied to clipboard
Subscribe to Ethereum events.
// Subscribe to `chainChanged` event
ethereum!.onChainChanged((chainId) {
chainId; // foo
});

// Subscribe to `accountsChanged` event.
ethereum!.onAccountsChanged((accounts) {
print(accounts); // ['0xbar']
});

// Subscribe to `message` event, need to convert JS message object to dart object.
ethereum!.on('message', (message) {
dartify(message); // baz
});
copied to clipboard
Call other JSON RPC API.
// Call `eth_gasPrice` as `BigInt`
final result = await ethereum!.request<BigInt>('eth_gasPrice');

result; // 5000000000
result is BigInt; // true
copied to clipboard

Ethers #

Based on Ethers documentation on Getting Started.

Connecting to Ethereum: Metamask
final web3provider = Web3Provider(ethereum!);
// or
final web3provider = Web3Provider.fromEthereum(ethereum!);
// or
provider; // Default Web3Provider instance from default Ethereum provider
copied to clipboard
Connecting to Ethereum: RPC
final rpcProvider = JsonRpcProvider(); // Rpc Provider from default Rpc url, i.e. https://localhost:8545

final rpcProvider = JsonRpcProvider('https://bsc-dataseed.binance.org/'); // Rpc Provider from specific Rpc url
copied to clipboard
Querying the Blockchain
// Look up the current block number
await provider!.getBlockNumber(); // 9261427

// Get the lastest block information that available
await provider!.getLastestBlock(); // Block: 9261427 0x9e7900b8 mined at 2021-07-18T16:58:45.000 with diff 2

// Get the specific account balance
await provider!.getBalance('0xgarply'); // 315752957360231815

// Get the transcation receipt of specific transaction hash
await provider!.getTransactionReceipt('0xwaldo'); // TransactionReceipt: 0x1612d8ba from 0x6886ec02 with 20 confirmations and 12 logs
copied to clipboard
Calling other Ether provider API.
// Call `getGasPrice` as `BigInt`
final result = await provider!.call<BigInt>('getGasPrice');

result; // 5000000000
result is BigInt; // true
copied to clipboard
Signer
Query data about your account.
// Get signer from provider
final signer = provider!.getSigner();

// Get account balance
await signer.getBalance(); // 315752957360231815

// Get account sent transaction count (not contract call)
await signer.getTransactionCount(BlockTag.latest); // 1
copied to clipboard
Send/write to the Blockchain
// Send 1000000000 wei to `0xcorge`
final tx = await provider!.getSigner().sendTransaction(
TransactionRequest(
to: '0xcorge',
value: BigInt.from(1000000000),
),
);

tx.hash; // 0xplugh

final receipt = await tx.wait();

receipt is TransactionReceipt; // true
copied to clipboard
Wallet
Create a wallet from mnemonic phrase.
final mnemonic =
"announce room limb pattern dry unit scale effort smooth jazz weasel alcohol";
final wallet = Wallet.fromMnemonic(mnemonic);
copied to clipboard
Or directly from private key.
final anotherWallet = Wallet(wallet.privateKey);
copied to clipboard
Then connect the wallet to specific provider.
// Connect wallet to network
final testnetProvider =
JsonRpcProvider('https://data-seed-prebsc-1-s2.binance.org:8545/');
final walletWithProvider = wallet.connect(testnetProvider);
copied to clipboard
After that, the wallet object can be used as normal signer object.
final tx = await walletWithProvider.sendTransaction(
TransactionRequest(
to: '0xbar',
value: BigInt.from(100),
),
); // Send 100 wei to `0xbar`

tx.hash; // 0xbash
copied to clipboard
Contract
Define ABI object, All ABI formats can be view here.
Note that you must be precise with the function argument and return types, this will yield different data types. For example, uint256 will yield BigNumber but uint16 will simply yield int. There might be error if you manually type this by hand.
final humanReadableAbi = [
"function balanceOf(address owner) view returns (uint256 balance)",
// Some examples with the struct type, we use the tuple keyword:
// (note: the tuple keyword is optional, simply using additional
// parentheses accomplishes the same thing)
// struct Person {
// string name;
// uint16 age;
// }
"function addPerson(tuple(string name, uint16 age) person)", // Or "function addPerson((string name, uint16 age) person)"
];

final jsonAbi = '''[
{
"type": "function",
"name": "balanceOf",
"constant":true,
"stateMutability": "view",
"payable":false, "inputs": [
{ "type": "address", "name": "owner"}
],
"outputs": [
{ "type": "uint256"}
]
}
]''';

// Contruct Interface object out of `humanReadableAbi` or `jsonAbi`
final humanInterface = Interface(humanReadableAbi);
final jsonInterface = Interface(jsonAbi);

// These two abi interface can be exchanged
humanInterface.format(FormatTypes.minimal); // [function balanceOf(address) view returns (uint256)]
humanInterface.format(FormatTypes.minimal)[0] == jsonInterface.format(FormatTypes.minimal)[0]; // true
copied to clipboard
Initialize Contract object.
final abi = [
// Some details about the token
"function name() view returns (string)",
"function symbol() view returns (string)",

// Get the account balance
"function balanceOf(address) view returns (uint)",

// Send some of your tokens to someone else
"function transfer(address to, uint amount)",

// An event triggered whenever anyone transfers to someone else
"event Transfer(address indexed from, address indexed to, uint amount)"
];

final busdAddress = '0xe9e7cea3dedca5984780bafc599bd69add087d56';

// Use `Provider` for Read-only contract, i.e. Can't call state-changing method
final busd = Contract(
busdAddress,
abi,
provider!,
);

// Use `Signer` for Read-write contract
// Notice that ABI can be exchangeable
final anotherBusd = Contract(
busdAddress,
Interface(abi),
provider!.getSigner(),
);
// Or `busd.connect(provider!.getSigner());`
copied to clipboard
Read-only method.
// Call `name`
await busd.call<String>('name'); // BUSD Token
// Call `symbol`
await busd.call<String>('symbol'); // BUSD
// Call `balanceOf`
await busd.call<BigInt>(
'balanceOf',
['0xthud'],
); // 2886780594123782414119
copied to clipboard
Use List to notate Tuple type.
final abi = "function see(tuple(address, uint8, bytes)[], uint256) view returns (uint256)";

final contract = Contract('0xrandomContract', abi, provider!);

await contract.call<BigInt>('see', [
[
'0x0000000000000000000000000000000000000000',
0,
'0x',
],
1000,
]); // 1248842
copied to clipboard
Write/State-changing method.
// Send 1 ether to `0xfoo`
final tx = await anotherBusd.send('transfer', ['0xfoo', '1000000000000000000']);
tx.hash; // 0xbar

final receipt = tx.wait(); // Wait until transaction complete
receipt.from; // 0xthud
receipt.to; // 0xe9e7cea3dedca5984780bafc599bd69add087d56 (BUSD Address)
copied to clipboard
Send Ether along with payable method.
final abi = "function throw() payable";

final contract = Contract('0xrandomContract', abi, provider!);

// Send 100 wei of ether along
final tx = await contract.send(
'throw',
[],
TransactionOverride(value: BigInt.from(100)),
);

tx.hash; // 0xfoo
copied to clipboard
Listening to Events.
// Receive an event when ANY transfer occurs
busd.on('Transfer', (from, to, amount, event) {
from; // 0x0648ff5de80Adf54aAc07EcE2490f50a418Dde23
to; // 0x12c64E61440582793EF4964A36d98020d83490a3
amount; // 1015026418461703883891
Event.fromJS(event); // Event: Transfer Transfer(address,address,uint256) with args [0x0648ff5de80Adf54aAc07EcE2490f50a418Dde23, 0x12c64E61440582793EF4964A36d98020d83490a3, 1015026418461703883891]
});

// A filter for when a specific address receives tokens
final myAddress = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
final filter = busd.getFilter('Transfer', [null, myAddress]);
// {
// address: '0xe9e7cea3dedca5984780bafc599bd69add087d56',
// topics: [
// '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
// null,
// '0x0000000000000000000000008ba1f109551bd432803012645ac136ddd64dba72'
// ]
// }

busd.on(filter, (from, to, amount, event) {
// ...
});
copied to clipboard
Query Historic Events
final filter = busd.getFilter('Transfer');

// Query past event in last 100 blocks.
final events = await busd.queryFilter(filter, -100);

events.first; // Event: Transfer Transfer(address,address,uint256) with args [0x209F2A37Ccb5672794329cB311406A995de9347c, 0x928bE3DEB1f8B9e4A24a5744bD313E726462961D, 150000000000000000000]
copied to clipboard
Alternatively for ERC20 Contract, we can use ContractERC20 class.
final token = ContractERC20('0xfoo', provider!.getSigner());

await token.name; // foo
await token.symbol; // bar
await token.decimals; // baz

final tx = await token.transfer('0xbar', BigInt.parse('10000000000000'));
tx.hash // 0xbarbaz

token.onApproval((owner, spender, value, event) {
owner // 0xfoo
spender //0xbar
value //0xbaz
});
copied to clipboard

Wallet Connect Provider #
Create WalletConnectProvider object.
// From RPC
final wc = WalletConnectProvider.fromRpc(
{56: 'https://bsc-dataseed.binance.org/'},
chainId: 56,
network: 'binance',
);

// From Infura
final infuraWc = WalletConnectProvider.fromInfura('https://foo.infura.io/v3/barbaz');

// Static RPC
final binaceWc = WalletConnectProvider.binance();
final polygonWc = WalletConnectProvider.polygon();
...
copied to clipboard
Enable the session, toggle QRCode Modal.
await wc.connect();
copied to clipboard
Use in Ethers Web3Provider.
final web3provider = Web3Provider.fromWalletConnect(wc);

await web3provider.getGasPrice(); // 5000000000
copied to clipboard