Andrew Miller
17057ad1f2
Transaction.GetInterchain and Block.GetInterchain take variadic options (client.WithPerChain / client.WithChains, re-exported as sdk.WithPerChain / sdk.WithChains) that map to the new prime-node ?perChain=&chains= query params. Backward compatible: existing no-option calls get the default (one anchor per chain). client.InterchainQuery builds the suffix; unit-tested.
83 lines
3.1 KiB
Go
Executable File
83 lines
3.1 KiB
Go
Executable File
package transaction
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"git.dragonchain.com/dragonchain/prime-sdk-go/client"
|
|
"git.dragonchain.com/dragonchain/prime-sdk-go/models"
|
|
)
|
|
|
|
type TransactionClient struct {
|
|
client *client.Client
|
|
}
|
|
|
|
func NewTransactionClient(c *client.Client) *TransactionClient {
|
|
return &TransactionClient{client: c}
|
|
}
|
|
|
|
// Create submits a new transaction and returns immediately with the assigned transaction ID.
|
|
// It does NOT wait for the transaction to be included in a block. Block processing happens
|
|
// asynchronously on a ~5-second cycle. If you need the block ID (e.g. for interchain
|
|
// verification), poll Get until Header.BlockId is populated.
|
|
func (tc *TransactionClient) Create(ctx context.Context, req *models.TransactionCreateRequest) (*models.TransactionCreateResponse, error) {
|
|
var resp models.TransactionCreateResponse
|
|
err := tc.client.Post(ctx, "/api/v1/transaction", models.ContentTypeJSON, req, &resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resp, nil
|
|
}
|
|
|
|
// CreateBulk submits multiple transactions and returns immediately with the assigned transaction IDs.
|
|
// It does NOT wait for the transactions to be included in a block. Block processing happens
|
|
// asynchronously on a ~5-second cycle. If you need block IDs, poll Get for each transaction
|
|
// until Header.BlockId is populated.
|
|
func (tc *TransactionClient) CreateBulk(ctx context.Context, req *models.TransactionBulkRequest) (*models.TransactionBulkResponse, error) {
|
|
var resp models.TransactionBulkResponse
|
|
err := tc.client.Post(ctx, "/api/v1/transaction/bulk", models.ContentTypeJSON, req, &resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resp, nil
|
|
}
|
|
|
|
func (tc *TransactionClient) Get(ctx context.Context, transactionID string) (*models.Transaction, error) {
|
|
var resp models.Transaction
|
|
path := fmt.Sprintf("/api/v1/transaction/%s", transactionID)
|
|
err := tc.client.Get(ctx, path, &resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resp, nil
|
|
}
|
|
|
|
// GetInterchain traces a transaction to the validator (verification) blocks that
|
|
// validated its prime block and the public-chain interchain anchors those
|
|
// validator blocks were bundled into. If the transaction is still pending (not
|
|
// yet in a block) the trace's slices are empty.
|
|
//
|
|
// By default it returns the first anchor per public chain (anchor proofs are
|
|
// chained, so the earliest per chain is the meaningful one). Use
|
|
// client.WithPerChain / client.WithChains to return more anchors per chain or
|
|
// restrict to specific chains.
|
|
func (tc *TransactionClient) GetInterchain(ctx context.Context, transactionID string, opts ...client.InterchainOption) (*models.InterchainTrace, error) {
|
|
var resp models.InterchainTrace
|
|
path := fmt.Sprintf("/api/v1/transaction/%s/interchain%s", transactionID, client.InterchainQuery(opts...))
|
|
err := tc.client.Get(ctx, path, &resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resp, nil
|
|
}
|
|
|
|
func (tc *TransactionClient) List(ctx context.Context) (*models.ListTransactionsResponse, error) {
|
|
var resp models.ListTransactionsResponse
|
|
path := "/api/v1/transaction/"
|
|
err := tc.client.Get(ctx, path, &resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &resp, nil
|
|
}
|