waves_sdk 0.1.4

Flutter Waves SDK

example/lib/main.dart

import 'dart:convert';
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:waves_sdk/waves_sdk.dart';

void main() => runApp(MyApp());

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  String seed;
  String publicKeyValue, privateKeyValue;
  String address, address2;
  Uint8List signature, signature2;
  String balance;
  KeyPair keyPairValue;
  bool signatureVerified, signature2Verified;

  Map<String, bool> results = {};

  @override
  void initState() {
    super.initState();

    // WavesSdk.init();
    WavesSdk.init(env: Environment.TEST_NET);
  }

  Future randomSeed() async {
    var value = await WavesCrypto.randomSeed();
    results['randomSeed'] = value != null;
    setState(() => seed = value);
  }

  Future addressBySeed() async {
    var value = await WavesCrypto.addressBySeed(seed);
    results['addressBySeed'] = value != null;
    setState(() => address = value);
  }

  Future publicKey() async {
    var value = await WavesCrypto.publicKey(seed);
    results['publicKey'] = value != null;
    setState(() => publicKeyValue = value);
  }

  Future privateKey() async {
    var value = await WavesCrypto.privateKey(seed);
    results['privateKey'] = value != null;
    setState(() => privateKeyValue = value);
  }

  Future keyPair() async {
    final value = await WavesCrypto.keyPair(seed);
    results['keyPair'] = value.publicKey == publicKeyValue && value.privateKey == privateKeyValue;
    setState(() => keyPairValue = value);
  }

  Future addressByPublicKey() async {
    var value = await WavesCrypto.addressByPublicKey(publicKeyValue);
    results['addressByPublicKey'] = address == value;
    setState(() => address2 = address);
  }

  Future verifyAddress() async {
    results['verifyAddress'] = await WavesCrypto.verifyAddress(address, publicKey: publicKeyValue);
    setState(() => {});
  }

  Future verifyPublicKey() async {
    results['verifyPublicKey'] = await WavesCrypto.verifyPublicKey(publicKeyValue);
    setState(() => {});
  }

  Future signBytesWithPrivateKey() async {
    var value = await WavesCrypto.signBytesWithPrivateKey(utf8.encode('test'), privateKeyValue);
    results['signBytesWithPrivateKey'] = value != null;
    setState(() => signature = value);
  }

  Future signBytesWithSeed() async {
    var value = await WavesCrypto.signBytesWithSeed(utf8.encode('test'), seed);
    results['signBytesWithSeed'] = value != null;
    setState(() => signature2 = value);
  }

  Future verifySignature() async {
    var result = await WavesCrypto.verifySignature(publicKeyValue, utf8.encode('test'), signature);
    results['verifySignature'] = result;
    setState(() => signatureVerified = result);
  }

  Future verifySignature2() async {
    results['verifySignature2'] = await WavesCrypto.verifySignature(publicKeyValue, utf8.encode('test'), signature2);
    setState(() => signatureVerified = results['verifySignature2']);
  }

  Future getBalance() async {
    var value = await WavesSdk.service().getNode().addressesBalance(address);
    results['getBalance'] = value != null;
    setState(() => balance = value);
  }

  void test() async {
    // WavesCrypto tests
    try { await randomSeed(); } catch (e) { results['randomSeed'] = false; }
    try { await addressBySeed(); } catch (e) { results['addressBySeed'] = false; }
    try { await publicKey(); } catch (e) { results['publicKey'] = false; }
    try { await privateKey(); } catch (e) { results['privateKey'] = false; }
    try { await keyPair(); } catch (e) { results['keyPair'] = false; }
    try { await addressByPublicKey(); } catch (e) { results['addressByPublicKey'] = false; }
    try { await verifyAddress(); } catch (e) { results['verifyAddress'] = false; }
    try { await verifyPublicKey(); } catch (e) { results['verifyPublicKey'] = false; }
    try { await signBytesWithPrivateKey(); } catch (e) { results['signBytesWithPrivateKey'] = false;}
    try { await verifySignature(); } catch (e) {print(e); results['verifySignature'] = false; }
    try { await signBytesWithSeed(); } catch (e) { results['signBytesWithSeed'] = false; }
    try { await verifySignature2(); } catch (e) { results['verifySignature2'] = false; }

    // Waves Node Service tests
    // try { await getBalance(); } catch (e) { results['getBalance'] = false; }
  }

  buildTestResult(name, [value = '']) {
    return Container(
      padding: EdgeInsets.only(bottom: 10, top: 10),
      decoration: BoxDecoration(
        border: Border(bottom: BorderSide(color: Colors.black26))
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: <Widget>[
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: <Widget>[
              Text(name, style: TextStyle(fontWeight: FontWeight.w500)),
              results[name] != null ? Text(results[name] ? 'OK' : 'ERROR') : Container()
            ],
          ),
          value != null ? Text(value) : Container()
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Waves SDK'),
        ),
        body: SingleChildScrollView(
          child: Padding(
            padding: EdgeInsets.all(10),
            child: Column(
              children: <Widget>[
                FlatButton(color: Colors.blue, child: Text('Test'), onPressed: test),

                // Waves Crypto
                buildTestResult('randomSeed', seed),
                buildTestResult('addressBySeed', address),
                buildTestResult('publicKey', publicKeyValue),
                buildTestResult('privateKey', privateKeyValue),
                buildTestResult('keyPair', keyPairValue == null ? '' : keyPairValue.toString()),
                buildTestResult('addressByPublicKey', address2),
                buildTestResult('verifyAddress'),
                buildTestResult('verifyPublicKey'),
                buildTestResult('signBytesWithPrivateKey', signature == null ? '' : signature.toString()),
                buildTestResult('verifySignature', signatureVerified == null ? '' : (signatureVerified ? 'true' : 'false')),
                buildTestResult('signBytesWithSeed', signature2 == null ? '' : signature2.toString()),
                buildTestResult('verifySignature2', signature2Verified == null ? '' : (signature2Verified ? 'true' : 'false')),

                // Waves Node Service
                // buildTestResult('getBalance', balance),
              ],
            ),
          )
        ),
      ),
    );
  }
}