Hello, Anatoly Yakovenko

We are pushing off-ramp into a new era

extern crate blindpay_sdk;

use blindpay_sdk::{BlindPay, CreateReceiverParams, CreateAccountParams, CreateQuoteParams, GetPayoutParams};

#[tokio::main]
async fn main() {
    // Initialize BlindPay with your API key
    let blindpay = BlindPay::new("bp_123456789");

    // Create a receiver
    let receiver = blindpay.receivers().create(CreateReceiverParams {
        receiver_type: "individual",
        address: "Rua Doutor Jairo de Matos Pereira".to_string(),
        address_2: Some("Apto. 1001".to_string()),
        city: "Vila Velha".to_string(),
        state_province_region: "ES".to_string(),
        country: "BR".to_string(),
        postal_code: "29101310".to_string(),
        first_name: "Bernardo".to_string(),
        last_name: "Moura".to_string(),
        tax_id: "14947677786".to_string(),
    }).await.unwrap();

    // Create an account
    let account = blindpay.accounts().create(CreateAccountParams {
        receiver_id: receiver.id.clone(),
        currency: "BRL".to_string(),
        bank_country: "BR".to_string(),
        bank_details: Some(json!({
            "pix_key": "14947677786"
        })),
    }).await.unwrap();

    // Create a quote
    let quote = blindpay.quotes().create(CreateQuoteParams {
        account_id: account.id.clone(),
        amount_currency: "receiver".to_string(),
        cover_fees: true,
        amount: 979.80,
    }).await.unwrap();

    // Now you would perform the transaction to the address account.addresses.solana_usdc
    // with the amount of quote.sender_amount. Due to the nature of this simulation,
    // we're skipping the transaction step as it's specific to Solana blockchain.

    // After the transaction, you can get payout details using transaction hash
    let payout_details = blindpay.payouts().get(GetPayoutParams {
        tx_hash: "#123456".to_string(),
    }).await;

    match payout_details {
        Ok(data) => println!("{:?}", data),
        Err(error) => println!("{:?}", error),
    }
}

import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

(async function() {
  const receiver = await blindpay.receivers.create({
    type: 'individual',
    address: 'Rua Doutor Jairo de Matos Pereira',
    address_2: 'Apto. 1001',
    city: 'Vila Velha',
    state_province_region: 'ES',
    country: 'BR',
    postal_code: '29101310',
    individual: {
      first_name: 'Bernardo',
      last_name: 'Moura',
      tax_id: '14947677786',
    },
  });

  const account = await blindpay.accounts.create({
    receiver_id: receiver.id,
    currency: 'BRL',
    bank_country: 'BR',
    bank_details: {
      pix_key: '14947677786',
    },
  });

  const quote = await blindpay.quotes.create({
    account_id: account.id,
    amount_currency: 'receiver',
    cover_fees: true,
    amount: 979.80
  });

  /*
  Now you have 5 minutes to make a transaction to
  the address `account.addresses.solana_usdc` with
  the amount of `quote.sender_amount`.
  */

  /*
  After the transaction is done on solana blockchain
  we can use the transaction hash to get payout details.
  */

  const {data, error} = await blindpay.payouts.get({
    tx_hash: '#123456'
  });

  if (error) {
    return console.log(error);
  }

  console.log(data);
})();

import { BlindPay } from 'blindpay';

export default async function handler(req, res) {
  const { method, body } = req;

  if (method !== 'POST') {
    return res.status(405).json({ message: 'Method Not Allowed' });
  }

  try {
    const blindpay = new BlindPay('bp_123456789');

    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const payout = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    res.status(200).json({ payout });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
}

import { json } from '@remix-run/node';
import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

export async function loader() {
  try {
    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const {data} = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    return json(data, 200);
  }
  catch (error) {
    return json({ error }, 400);
  }
};

import { BlindPay } from 'blindpay';

const blindpay = new BlindPay('bp_123456789');

export default defineEventHandler(async () => {
  const receiver = await blindpay.receivers.create({
    type: 'individual',
    address: 'Rua Doutor Jairo de Matos Pereira',
    address_2: 'Apto. 1001',
    city: 'Vila Velha',
    state_province_region: 'ES',
    country: 'BR',
    postal_code: '29101310',
    individual: {
      first_name: 'Bernardo',
      last_name: 'Moura',
      tax_id: '14947677786',
    },
  });

  const account = await blindpay.accounts.create({
    receiver_id: receiver.id,
    currency: 'BRL',
    bank_country: 'BR',
    bank_details: {
      pix_key: '14947677786',
    },
  });

  const quote = await blindpay.quotes.create({
    account_id: account.id,
    amount_currency: 'receiver',
    cover_fees: true,
    amount: 979.80
  });

  /*
  Now you have 5 minutes to make a transaction to
  the address `account.addresses.solana_usdc` with
  the amount of `quote.sender_amount`.
  */

  /*
  After the transaction is done on solana blockchain
  we can use the transaction hash to get payout details.
  */

  const { data, error } = await blindpay.payouts.get({
    tx_hash: '#123456'
  });

  if (error) {
    return error;
  }

  return data;
});

import { BlindPay } from 'blindpay';
import { error } from '@sveltejs/kit';

/** @type {import('./$types').RequestHandler} */
export function POST({ url }) {
    try {
    const blindpay = new BlindPay('bp_123456789');

    const receiver = await blindpay.receivers.create({
      type: 'individual',
      address: 'Rua Doutor Jairo de Matos Pereira',
      address_2: 'Apto. 1001',
      city: 'Vila Velha',
      state_province_region: 'ES',
      country: 'BR',
      postal_code: '29101310',
      individual: {
        first_name: 'Bernardo',
        last_name: 'Moura',
        tax_id: '14947677786',
      },
    });

    const account = await blindpay.accounts.create({
      receiver_id: receiver.id,
      currency: 'BRL',
      bank_country: 'BR',
      bank_details: {
        pix_key: '14947677786',
      },
    });

    const quote = await blindpay.quotes.create({
      account_id: account.id,
      amount_currency: 'receiver',
      cover_fees: true,
      amount: 979.80
    });

    /*
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    */

    /*
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    */

    const payout = await blindpay.payouts.get({
      tx_hash: '#123456'
    });

    return new Response({quote, payout});
  } catch (e) {
    return error(400, e);
  }
}

from blindpay import BlindPay
import asyncio

async def main():
    blindpay = BlindPay('bp_123456789')

    receiver = await blindpay.receivers.create({
        'type': 'individual',
        'address': 'Rua Doutor Jairo de Matos Pereira',
        'address_2': 'Apto. 1001',
        'city': 'Vila Velha',
        'state_province_region': 'ES',
        'country': 'BR',
        'postal_code': '29101310',
        'individual': {
            'first_name': 'Bernardo',
            'last_name': 'Moura',
            'tax_id': '14947677786',
        },
    })

    account = await blindpay.accounts.create({
        'receiver_id': receiver.id,
        'currency': 'BRL',
        'bank_country': 'BR',
        'bank_details': {
            'pix_key': '14947677786',
        },
    })

    quote = await blindpay.quotes.create({
        'account_id': account.id,
        'amount_currency': 'receiver',
        'cover_fees': True,
        'amount': 979.80
    })

    '''
    Now you have 5 minutes to make a transaction to
    the address `account.addresses.solana_usdc` with
    the amount of `quote.sender_amount`.
    '''

    '''
    After the transaction is done on solana blockchain
    we can use the transaction hash to get payout details.
    '''

    data, error = await blindpay.payouts.get({
        'tx_hash': '#123456'
    })

    if error:
        return print(error)

    print(data)

asyncio.run(main())