Basic flow

async fn test_create_spl_token_and_transfer() -> Result<()> {
    drop_and_recreate_database()?;
    signup("pepe_pablo").await?;

    let mut client = connect_user("pepe_pablo").await?;

    let create_org: CreateOrganizationResponse = client
        .create_organization(&CreateOrganizationRequest {
            name: "org".to_string(),
            country: "xx".to_string(),
            tax_id: "xx".to_string(),
            address: "xx".to_string(),
            note: "xxx".to_string(),
        })
        .await?;
    println!("create org {:?}", create_org);
    let create_bucket: CreateBucketResponse = client
        .create_bucket(&CreateBucketRequest {
            bucket_name: "BKT".to_string(),
            organization_id: create_org.organization_id,
            description: "Bucket".to_string(),
            always_online: true,
        })
        .await?;
    println!("Create bucket {:?}", create_bucket);
    let create_asset: CreateAssetResponse = client
        .create_asset(&CreateAssetRequest {
            short_name: "TEST".to_string(),
            long_name: "Asset for testing".to_string(),
            description: "This is a kind of sset for testing".to_string(),
            network_type: "SPL".to_string(),
            contract_address: "".to_string(),
            precision: 9,
            organization: None,
            can_plan: false,
        })
        .await?;
    println!("Create Asset {:?}", create_asset);
    let create_vault: CreateVaultResponse = client
        .create_vault(&CreateVaultRequest {
            bucket_id: create_bucket.bucket_id,
            vault_name: "vault".to_string(),
            asset_id: create_asset.asset_id,
        })
        .await?;
    println!("Create vault {:?}", create_vault);
    let create_wallet: CreateWalletResponse = client
        .create_wallet(&CreateWalletRequest {
            vault_id: create_vault.vault_id,
            wallet_name: "wallet".to_string(),
        })
        .await?;
    println!("Create wallet {:?}", create_wallet);
    let create_vault2: CreateVaultResponse = client
        .create_vault(&CreateVaultRequest {
            bucket_id: create_bucket.bucket_id,
            vault_name: "vault".to_string(),
            asset_id: create_asset.asset_id,
        })
        .await?;
    println!("Create vault2 {:?}", create_vault2);
    let create_wallet2: CreateWalletResponse = client
        .create_wallet(&CreateWalletRequest {
            vault_id: create_vault2.vault_id,
            wallet_name: "wallet".to_string(),
        })
        .await?;
    println!("Create wallet2 {:?}", create_wallet2);

    let asset_transfer: StartTransferAssetResponse = client
        .start_transfer_asset(&StartTransferAssetRequest {
            vault_wallet_id: create_vault.vault_id,
            target_address: create_wallet2.wallet_address,
            amount: 1.0,
        })
        .await?;
    println!("start signing {:?}", asset_transfer);

    let approve_signing: ApproveTransferAssetResponse = client
        .approve_transfer_asset(&ApproveTransferAssetRequest {
            transfer_id: asset_transfer.transfer_id,
        })
        .await?;
    println!("start signing {:?}", approve_signing);
    let list_transfer_assets: ListTransferAssetsResponse = client
        .list_transfer_assets(&ListTransferAssetsRequest {})
        .await?;
    println!("List transfer asset {:?}", list_transfer_assets);
    Ok(())
}