Go SDK

The Go SDK reads Tapehouse's contracts and packs their transactions as calldata you sign and send yourself. It sits on go-ethereum's bind/v2 and bindings generated from the contracts' ABIs. The repository's keeper, bidder, alerts, sponsor and backtest commands import it.

Read and send#

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/tapehouse/tapehouse/services/sdk"
)

func main() {
	ctx := context.Background()
	deployments, err := sdk.LoadDeployments("deployments/46630.json")
	if err != nil {
		log.Fatal(err)
	}
	backend, err := ethclient.Dial("https://rpc.testnet.chain.robinhood.com")
	if err != nil {
		log.Fatal(err)
	}
	client := sdk.NewClient(backend, deployments)

	quote, err := client.Band().Quote(&bind.CallOpts{Context: ctx}, "TSLA")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(quote.State, quote.Low, quote.High)
}

A transaction function returns an sdk.Tx, the recipient and the calldata. Check it with client.Simulate, then sign and send it with client.Send, both of which return a decoded *sdk.Revert where the revert data matches an error of the contracts.

tx, err := client.Accounts().Borrow(sdk.Cross, big.NewInt(50_000_000), account, account)
if err != nil {
	log.Fatal(err)
}
if err := client.Simulate(&bind.CallOpts{Context: ctx, From: account}, tx); err != nil {
	log.Fatal(err)
}
sent, err := client.Send(transactOpts, tx)

Assets are strings ("TSLA") and the SDK converts them with sdk.ToBytes32. A position is sdk.Cross, the cross position, or an asset's bytes32. Amounts are *big.Int in raw units. Every read takes *bind.CallOpts; set BlockNumber to read at a block, and reads that combine several calls (Repayment, InBaskets) use one block, the latest where you name none. Slippage arguments are int64 basis points from 0 to 10,000.

Registry#

Deployments also carries .chainlinkSequencer (ChainlinkSequencer), which the Go SDK reads for the sequencer-uptime feed.

Client#

sdk.NewClient(backend bind.ContractBackend, deployments *Deployments) returns a *Client. Its accessors return the objects below.

Band#

PackageSource is an interface with one method, Payload(ctx context.Context, feedIDs []string) ([]byte, error). The SDK holds no RedStone key and calls no gateway.

Accounts#

position is [32]byte.

Shorts, baskets and gap cover#

The Go SDK has no builders for the supply vault, and no reads for the gap backstop's state or a depositor's holdings. Use the generated binding in services/sdk/bindings/supplyvault or gapbackstop for those, or the TypeScript SDK, which has supply and backstop modules.

Errors#

sdk.DecodeRevert(err) returns the *sdk.Revert behind an error, with Name, Args and Data. client.Simulate and client.Send already return one. See errors.

if revert, ok := sdk.DecodeRevert(err); ok {
	fmt.Println(revert.Name, revert.Args)
}

Example#

services/sdk/examples/devnode runs the SDK against a local Nitro dev node: PRIVATE_KEY=0x… go run ./sdk/examples/devnode RPC_URL DEPLOYMENTS_JSON PAYLOAD_FILE, from the services directory. It reads the key from the environment, never from a flag.

Next#

• SDKs overview: the three SDKs side by side.
• Errors: decode a revert and fix it.
• Run the keepers: services built on this SDK.