Funding Accounts through Wallets

This section covers how an Account can be funded through its connected Wallet.

Funding on Sandbox

EVM

In testnet, EVM wallets can be funded by calling the faucet:

import { DinariClient, DinariEnvironment } from "@dinari/api-sdk";

const client = new DinariClient({
  apiKeyId: process.env.DINARI_API_KEY_ID!, // This is the default and can be omitted
  apiSecretKey: process.env.DINARI_API_SECRET_KEY!, // This is the default and can be omitted
  environment: DinariEnvironment.Sandbox, // defaults to DinariEnvironment.Production
});

async function main() {
  const accountId = "your-account-id";

  await client.accounts.createAccountFaucet({
    accountId,
    chainId: "eip155:84532",
  });

  console.log("Sandbox tokens minted");
}

main();
import os

from dinari_api_sdk import DinariClient
from dinari_api_sdk.environment import DinariClientEnvironment

client = DinariClient(
    api_key_id=os.environ["DINARI_API_KEY_ID"],  # This is the default and can be omitted
    api_secret_key=os.environ["DINARI_API_SECRET_KEY"],  # This is the default and can be omitted
    environment=DinariClientEnvironment.SANDBOX,  # defaults to DinariClientEnvironment.PRODUCTION
)

account_id = "your-account-id"

client.accounts.create_account_faucet(
    account_id=account_id,
    chain_id="eip155:84532",
)
print("Sandbox tokens minted")
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	dinari "github.com/dinaricrypto/dinari-api-sdk-go"
	client "github.com/dinaricrypto/dinari-api-sdk-go/client"
	option "github.com/dinaricrypto/dinari-api-sdk-go/option"
)

func main() {
	c := client.NewDinariClient(
		option.WithBaseURL(dinari.Environments.Sandbox), // Defaults to production when omitted
		option.WithAPIKeyID(os.Getenv("DINARI_API_KEY_ID")),
		option.WithAPISecretKey(os.Getenv("DINARI_API_SECRET_KEY")),
	)

	accountID := "your-account-id"

	err := c.Accounts.CreateAccountFaucet(context.Background(), &dinari.FaucetInput{
		AccountID: accountID,
		ChainID:   dinari.ChainIDEip15584532.Ptr(),
	})
	if err != nil {
		log.Fatalf("Failed to mint sandbox tokens: %v", err)
	}

	fmt.Println("Sandbox tokens minted")
}
import com.dinari.api.DinariClient;
import com.dinari.api.core.Environment;
import com.dinari.api.resources.accounts.requests.FaucetInput;
import com.dinari.api.types.ChainId;

public class Main {
    public static void main(String[] args) {
        DinariClient client = DinariClient.builder()
                .environment(Environment.SANDBOX) // defaults to Environment.PRODUCTION
                .apiKeyId(System.getenv("DINARI_API_KEY_ID")) // This is the default and can be omitted
                .apiSecretKey(System.getenv("DINARI_API_SECRET_KEY")) // This is the default and can be omitted
                .build();

        String accountId = "your-account-id";

        client.accounts().createAccountFaucet(
                accountId,
                FaucetInput.builder().chainId(ChainId.EIP15584532).build());
        System.out.println("Sandbox tokens minted");
    }
}

Funding on Production

External Wallets

EVM

External wallets can be funded via USD+, USDC, or USDT

Managed Wallets

EVM

Similar to external wallets, managed wallets can be funded via USD+, USDC, or USDT.


Did this page help you?