Help us shape the future of Go! Take the 2026 Go Developer Survey

client

package
v0.10.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 21, 2026 License: Apache-2.0, MIT Imports: 14 Imported by: 0

Documentation

Index

Examples

Constants

View Source 
const (
	// DefaultTimeout is the default HTTP client timeout
	DefaultTimeout = 30 * time.Second
)

Variables

View Source 
var ErrNotFound = errors.New("not found")

ErrNotFound is returned when a resource is not found (HTTP 404)

Functions

This section is empty.

Types

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client is a client for the bridgeservice REST API

func New 

func New(cfg Config) *Client

New creates a new bridgeservice client

Example 
package main

import (
	"fmt"
	"time"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	// Create a client with default timeout (30 seconds)
	_ = client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	fmt.Printf("Client created with base URL: %s\n", "http://localhost:8080")

	// Create a client with custom timeout
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
		Timeout: 10 * time.Second,
	})

	_ = c
}

func (*Client) GetBridgeByDepositCount 

func (c *Client) GetBridgeByDepositCount(
	ctx context.Context, networkID uint32, depositCount uint32,
) (*types.BridgeResponse, error)

GetBridgeByDepositCount retrieves the bridge for the given network and deposit count. Returns ErrNotFound if the bridge does not exist in bridge or bridge_archive.

func (*Client) GetBridges 

func (c *Client) GetBridges(ctx context.Context, params GetBridgesParams) (*types.BridgesResult, error)

GetBridges retrieves paginated bridge events

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	// Minimal parameters
	resp, err := c.GetBridges(context.Background(), client.GetBridgesParams{
		NetworkID: 1,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total bridges: %d\n", resp.Count)

	// With optional parameters
	pageNum := uint32(1)
	pageSize := uint32(20)
	depositCount := uint64(10)
	fromAddr := "0x1234567890123456789012345678901234567890"

	resp, err = c.GetBridges(context.Background(), client.GetBridgesParams{
		NetworkID:    1,
		PageNumber:   &pageNum,
		PageSize:     &pageSize,
		DepositCount: &depositCount,
		FromAddress:  &fromAddr,
		NetworkIDs:   []uint32{2, 3},
	})
	if err != nil {
		log.Fatal(err)
	}

	for _, bridge := range resp.Bridges {
		fmt.Printf("Bridge at block %d\n", bridge.BlockNum)
	}
}

func (*Client) GetBridgesByContent 

func (c *Client) GetBridgesByContent(
	ctx context.Context, params GetBridgesByContentParams,
) (*types.BridgesByContentResult, error)

GetBridgesByContent retrieves bridges matching the given content fields for the specified network.

func (*Client) GetClaimProof 

func (c *Client) GetClaimProof(
	ctx context.Context, networkID, leafIndex, depositCount uint32,
) (*types.ClaimProof, error)

GetClaimProof retrieves Merkle proofs for claim verification

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	proof, err := c.GetClaimProof(context.Background(), 1, 10, 5)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Claim proof retrieved for L1 Info Tree Index: %d\n", proof.L1InfoTreeLeaf.L1InfoTreeIndex)
}

func (*Client) GetClaims 

func (c *Client) GetClaims(ctx context.Context, params GetClaimsParams) (*types.ClaimsResult, error)

GetClaims retrieves paginated claims

Example 
package main

import (
	"context"
	"fmt"
	"log"
	"math/big"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	includeAll := true
	globalIndex := big.NewInt(123)

	resp, err := c.GetClaims(context.Background(), client.GetClaimsParams{
		NetworkID:        1,
		IncludeAllFields: &includeAll,
		GlobalIndex:      globalIndex,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total claims: %d\n", resp.Count)
}

func (*Client) GetClaimsByGER 

func (c *Client) GetClaimsByGER(ctx context.Context, networkID uint32, ger string) (*types.ClaimsByGERResult, error)

GetClaimsByGER retrieves all claims matching the given global exit root (0x-prefixed hex hash) for the specified network (0 for L1, L2 network ID otherwise).

func (*Client) GetInjectedL1InfoLeaf 

func (c *Client) GetInjectedL1InfoLeaf(
	ctx context.Context, networkID, leafIndex int,
) (*types.L1InfoTreeLeafResponse, error)

GetInjectedL1InfoLeaf retrieves an injected L1 info tree leaf

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	resp, err := c.GetInjectedL1InfoLeaf(context.Background(), 2, 5)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("L1 Info Tree Index: %d, Block: %d\n", resp.L1InfoTreeIndex, resp.BlockNumber)
}

func (*Client) GetL1InfoTreeIndex 

func (c *Client) GetL1InfoTreeIndex(ctx context.Context, networkID, depositCount int) (uint32, error)

GetL1InfoTreeIndex retrieves the L1 Info Tree index for a bridge

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	index, err := c.GetL1InfoTreeIndex(context.Background(), 1, 10)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("L1 Info Tree Index: %d\n", index)
}

func (*Client) GetLastReorgEvent 

func (c *Client) GetLastReorgEvent(ctx context.Context, networkID int) (*bridgesync.LastReorg, error)

GetLastReorgEvent retrieves the last reorganization event

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	// For L1 (networkID = 0)
	resp, err := c.GetLastReorgEvent(context.Background(), 0)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Last reorg from block %d to block %d\n", resp.FromBlock, resp.ToBlock)
}

func (*Client) GetLegacyTokenMigrations 

func (c *Client) GetLegacyTokenMigrations(
	ctx context.Context, params GetLegacyTokenMigrationsParams,
) (*types.LegacyTokenMigrationsResult, error)

GetLegacyTokenMigrations retrieves legacy token migrations

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	resp, err := c.GetLegacyTokenMigrations(context.Background(), client.GetLegacyTokenMigrationsParams{
		NetworkID: 2,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total legacy token migrations: %d\n", resp.Count)
}

func (*Client) GetRemoveGEREvents 

func (c *Client) GetRemoveGEREvents(
	ctx context.Context, params GetRemoveGEREventsParams,
) (*types.RemoveGEREventsResult, error)

GetRemoveGEREvents retrieves removed GER (Global Exit Root) events

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	ger := "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
	limit := 25

	resp, err := c.GetRemoveGEREvents(context.Background(), client.GetRemoveGEREventsParams{
		GlobalExitRoot: &ger,
		Limit:          &limit,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total remove GER events: %d\n", resp.Count)
}

func (*Client) GetSetClaims 

func (c *Client) GetSetClaims(ctx context.Context, params GetSetClaimsParams) (*types.SetClaimsResult, error)

GetSetClaims retrieves set claims (L2 only)

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	pageNum := 1
	pageSize := 10

	resp, err := c.GetSetClaims(context.Background(), client.GetSetClaimsParams{
		PageNumber: &pageNum,
		PageSize:   &pageSize,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total set claims: %d\n", resp.Count)
}

func (*Client) GetSyncStatus 

func (c *Client) GetSyncStatus(ctx context.Context) (*types.SyncStatus, error)

GetSyncStatus retrieves the bridge synchronization status

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	resp, err := c.GetSyncStatus(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("L1 Synced: %v, L2 Synced: %v\n", resp.L1Info.IsSynced, resp.L2Info.IsSynced)
}

func (*Client) GetTokenMappings 

func (c *Client) GetTokenMappings(
	ctx context.Context, params GetTokenMappingsParams,
) (*types.TokenMappingsResult, error)

GetTokenMappings retrieves token mappings

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	tokenAddr := "0xabcdef0123456789abcdef0123456789abcdef01"

	resp, err := c.GetTokenMappings(context.Background(), client.GetTokenMappingsParams{
		NetworkID:          1,
		OriginTokenAddress: &tokenAddr,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total token mappings: %d\n", resp.Count)
}

func (*Client) GetUnsetClaims 

func (c *Client) GetUnsetClaims(ctx context.Context, params GetUnsetClaimsParams) (*types.UnsetClaimsResult, error)

GetUnsetClaims retrieves unset claims (L2 only)

Example 
package main

import (
	"context"
	"fmt"
	"log"
	"math/big"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	pageNum := 1
	pageSize := 10
	globalIndex := big.NewInt(456)

	resp, err := c.GetUnsetClaims(context.Background(), client.GetUnsetClaimsParams{
		PageNumber:  &pageNum,
		PageSize:    &pageSize,
		GlobalIndex: globalIndex,
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Total unset claims: %d\n", resp.Count)
}

func (*Client) HealthCheck 

func (c *Client) HealthCheck(ctx context.Context) (*types.HealthCheckResponse, error)

HealthCheck performs a health check

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/agglayer/aggkit/bridgeservice/client"
)

func main() {
	c := client.New(client.Config{
		BaseURL: "http://localhost:8080",
	})

	resp, err := c.HealthCheck(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Status: %s\n", resp.Status)
}

type Config 

type Config struct {
	BaseURL string
	Timeout time.Duration
}

Config contains configuration for the client

type GetBridgesByContentParams 

type GetBridgesByContentParams struct {
	NetworkID          uint32
	LeafType           uint8
	OriginAddress      string
	DestinationNetwork uint32
	DestinationAddress string
	Amount             *big.Int
	Metadata           []byte
}

GetBridgesByContentParams holds the content fields for GetBridgesByContent

type GetBridgesParams 

type GetBridgesParams struct {
	NetworkID    uint32
	PageNumber   *uint32
	PageSize     *uint32
	DepositCount *uint64
	FromAddress  *string
	NetworkIDs   []uint32
}

GetBridgesParams contains parameters for GetBridges

type GetClaimsParams 

type GetClaimsParams struct {
	NetworkID        uint32
	PageNumber       *uint32
	PageSize         *uint32
	NetworkIDs       []uint32
	IncludeAllFields *bool
	GlobalIndex      *big.Int
}

GetClaimsParams contains parameters for GetClaims

type GetLegacyTokenMigrationsParams 

type GetLegacyTokenMigrationsParams struct {
	NetworkID  int
	PageNumber *int
	PageSize   *int
}

GetLegacyTokenMigrationsParams contains parameters for GetLegacyTokenMigrations

type GetRemoveGEREventsParams 

type GetRemoveGEREventsParams struct {
	GlobalExitRoot *string
	Limit          *int
}

GetRemoveGEREventsParams contains parameters for GetRemoveGEREvents

type GetSetClaimsParams 

type GetSetClaimsParams struct {
	PageNumber  *int
	PageSize    *int
	GlobalIndex *big.Int
}

GetSetClaimsParams contains parameters for GetSetClaims

type GetTokenMappingsParams 

type GetTokenMappingsParams struct {
	NetworkID          int
	PageNumber         *int
	PageSize           *int
	OriginTokenAddress *string
}

GetTokenMappingsParams contains parameters for GetTokenMappings

type GetUnsetClaimsParams 

type GetUnsetClaimsParams struct {
	PageNumber  *int
	PageSize    *int
	GlobalIndex *big.Int
}

GetUnsetClaimsParams contains parameters for GetUnsetClaims

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.