Skip to main content

sdk-core


Anvil SDK Core

Anvil SDK's core services and utils

Website

This library provides utilities to build a network of interconnected services using dependency injection through the Brandi.js library.

Installation​

npm install @ada-anvil/sdk-core

Usage​

Services​

Services are simple classes that provide functionality through methods and attributes.

export class MyService {
  doSomething() {
    // Do something
  }
}

A service can inject other services in its constructor to use them inside its own methods.

import { DebugService } from "@ada-anvil/sdk-core";

export class MyService {
  // Inject the DebugService into the constructor
  constructor(private _debug: DebugService) {}

  sayHello() {
    // Use the DebugService to log a message
    this._debug.log("Hello from MyService");
  }
}

Plugins​

Plugins are collections of services that can be combined to create a complete SDK.

Creating a plugin​

// Create a plugin that registers a singular service that can be accessed directly from the plugin name.
// Example: `sdk.myPlugin.sayHello()`
const plugin = createPlugin({
  name: "myPlugin",
  service: { service: MyService, scope: "transient", access: "public" },
});
or

// Create a plugin that registers multiple services that can be accessed from the plugin name.
// Example: `sdk.myPlugin.myService.sayHello()`
const plugin = createPlugin({
  name: "myPlugin",
  services: {
    myService: { service: MyService, scope: "transient", access: "public" },
    myOtherService: { service: MyOtherService, scope: "transient", access: "public" },
  },
});
or

// Create a plugin that registers multiple services that can be accessed directly from their name.
// Example: `sdk.myService.sayHello()`
const plugin = createPlugin({
  name: "myPlugin",
  flat: true, // Set to true to expose the services to the SDK root
  services: {
    myService: { service: MyService, scope: "transient", access: "public" },
    myOtherService: { service: MyOtherService, scope: "transient", access: "public" },
  },
});

Service definition​

  • service: The service class
  • scope: The service's binding scope. Refer to Brandi's documentation for details on the different options.
  • access: If set to private, the service won't be accessible through the SDK's interface.

SDKs​

SDKs are are simply a collection of plugins that can interact with one another.

Creating a SDK​

const anvil = createSdk({
  plugins: [myPlugin], // No need to add corePlugin, it's added by default
});

Using the Anvil backend API without the SDK​

If you do not wish to install the SDK but still need to use the Anvil backend API, you can do so by calling our traditional REST API with your preferred HTTP client.

You can call any of the service methods using the following structure: {baseUrl}/{serviceName}/{methodName}

The methods that only fetch data (exchange.create, exchange.mint) must be accessed with POST requests while others must be accessed with GET requests.

Example using Axios​

import axios from "axios";

try {
  const baseUrl = "https://prod.api.ada-anvil.app";
  const apiKey = "<API_KEY>";
  const input = encodeURIComponent(JSON.stringify({ exchangeId: 378 }));

  // Retrieve a pending exchange
  const { data } = await axios.get(`${baseUrl}/exchange/getPending?input=${input}`, {
    headers: { "x-api-key": apiKey },
  });

  console.log("exchange", data.result.data);

  // Create an exchange
  await axios.post(
    `${baseUrl}/exchange/create`,
    { fromAmount: 1, fromCurrency: 3, toCurrency: 4, address: "<ADDRESS>" },
    { headers: { "x-api-key": apiKey } },
  );
} catch (error) {
  console.error(error);
}

Example using fetch​

try {
  const baseUrl = "https://prod.api.ada-anvil.app";
  const apiKey = "<API_KEY>";
  const input = encodeURIComponent(JSON.stringify({ exchangeId: 378 }));

  // Retrieve a pending exchange
  const res = await fetch(`${baseUrl}/exchange/getPending?input=${input}`, {
    method: "GET",
    headers: { "x-api-key": apiKey },
  });

  const { result } = await res.json();

  console.log("exchange", result.data);
} catch (error) {
  console.error(error);
}

Inferring Types​

import { anvil } from "@ada-anvil/sdk-client";
import type { inferSdkInputs, inferSdkOutputs } from "@ada-anvil/sdk-core";

type AnvilSdk = typeof anvil;

type SdkInput = inferSdkInputs<AnvilSdk>;
type SdkOutput = inferSdkOutputs<AnvilSdk>;

type GetPendingExchangeInput = SdkInput["exchange"]["getPending"];
type GetPendingExchangeOutput = SdkOutput["exchange"]["getPending"];