sdk

package module
v1.26.0 Latest Latest
Warning

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

 Go to latest Published: Sep 9, 2021 License: MIT Imports: 22 Imported by: 1

README

Injective Protocol Golang SDK 🌟

📚 Getting Started

Clone the repository locally and install needed dependencies

$ git clone git@github.com:InjectiveLabs/sdk-go.git
$ cd sdk-go
$ go install ./...

Updating Exchange API proto and client

$ make copy-exchange-client

(you have to clone this repo into ../injective-exchange)

Publishing Tagged Release

$ git add .
$ git commit -m "bugfix"
$ git tag -a v1.1.1
$ git push origin master --tags

⛑ Support

Reach out to us at one of the following places!

🔐 License

Documentation

Index

Constants

View Source 
const (
	// ESInvalid is an event that is never emitted. It is here to discern between a declared but uninitialized OrderEventEndState
	ESInvalid = OrderEventEndState("INVALID")
	// ESOrderAdded means an order was successfully added to the Mesh node
	ESOrderAdded = OrderEventEndState("ADDED")
	// ESOrderFilled means an order was filled for a partial amount
	ESOrderFilled = OrderEventEndState("FILLED")
	// ESOrderFullyFilled means an order was fully filled such that it's remaining fillableTakerAssetAmount is 0
	ESOrderFullyFilled = OrderEventEndState("FULLY_FILLED")
	// ESOrderCancelled means an order was cancelled on-chain
	ESOrderCancelled = OrderEventEndState("CANCELLED")
	// ESOrderExpired means an order expired according to the latest block timestamp
	ESOrderExpired = OrderEventEndState("EXPIRED")
	// ESOrderUnexpired means an order is no longer expired. This can happen if a block re-org causes the latest
	// block timestamp to decline below the order's expirationTimestamp (rare and usually short-lived)
	ESOrderUnexpired = OrderEventEndState("UNEXPIRED")
	// ESOrderBecameUnfunded means an order has become unfunded. This happens if the maker transfers the balance /
	// changes their allowance backing an order
	ESOrderBecameUnfunded = OrderEventEndState("UNFUNDED")
	// ESOrderFillabilityIncreased means the fillability of an order has increased. Fillability for an order can
	// increase if a previously processed fill event gets reverted, or if a maker tops up their balance/allowance
	// backing an order
	ESOrderFillabilityIncreased = OrderEventEndState("FILLABILITY_INCREASED")
	// ESStoppedWatching means an order is potentially still valid but was removed for a different reason (e.g.
	// the database is full or the peer that sent the order was misbehaving). The order will no longer be watched
	// and no further events for this order will be emitted. In some cases, the order may be re-added in the
	// future.
	ESStoppedWatching = OrderEventEndState("STOPPED_WATCHING")
)

OrderEventEndState values

Variables

View Source 
var BatchFillFnNames = map[FuturesFunctionName]bool{
	BatchFillOrders:        true,
	BatchFillOrKillOrders:  true,
	BatchFillOrdersNoThrow: true,
}
View Source 
var BatchMatchOrderFnNames = map[FuturesFunctionName]bool{
	BatchMatchOrders:                true,
	BatchMatchOrdersWithMaximalFill: true,
}
View Source 
var MarketFillFnNames = map[FuturesFunctionName]bool{
	MarketBuyOrdersFillOrKill:  true,
	MarketSellOrdersFillOrKill: true,
	MarketBuyOrdersNoThrow:     true,
	MarketSellOrdersNoThrow:    true,
}
View Source 
var MatchOrderFnNames = map[FuturesFunctionName]bool{
	MatchOrders:                true,
	MatchOrdersWithMaximalFill: true,
}
View Source 
var SingleFillFnNames = map[FuturesFunctionName]bool{
	FillOrder:       true,
	FillOrKillOrder: true,
}

Functions

func IFuturesABIPack 

func IFuturesABIPack(fnName FuturesFunctionName, args ...interface{}) (data []byte, err error)

func OrdersToTrimmed 

func OrdersToTrimmed(orders []*SignedOrder) []wrappers.Order

func WrapTxToEIP712 

func WrapTxToEIP712(
	cdc codectypes.AnyUnpacker,
	chainID uint64,
	msg cosmtypes.Msg,
	data []byte,
	feeDelegation *FeeDelegationOptions,
) (typeddata.TypedData, error)

WrapTxToEIP712 is an ultimate method that wraps Amino-encoded Cosmos Tx JSON data into an EIP712-compatible request. All messages must be of the same type.

Types

type ContractEvent 

type ContractEvent struct {
	BlockHash  common.Hash
	TxHash     common.Hash
	TxIndex    uint
	LogIndex   uint
	IsRemoved  bool
	Address    common.Address
	Kind       string
	Parameters interface{}
}

ContractEvent is an event emitted by a smart contract

func (ContractEvent) MarshalJSON 

func (c ContractEvent) MarshalJSON() ([]byte, error)

MarshalJSON implements a custom JSON marshaller for the ContractEvent type

type CoordinatorApproval 

type CoordinatorApproval struct {
	TxOrigin             common.Address `json:"txOrigin"`
	TransactionHash      common.Hash    `json:"txHash"`
	TransactionSignature []byte         `json:"txSignature"`
	Domain               EIP712Domain   `json:"domain"`
	// contains filtered or unexported fields
}

func (*CoordinatorApproval) ComputeApprovalHash 

func (a *CoordinatorApproval) ComputeApprovalHash() (common.Hash, error)

ComputeApprovalHash computes a hash of 0x coordinator approval

func (*CoordinatorApproval) CoordinatorDomain 

func (a *CoordinatorApproval) CoordinatorDomain() typeddata.TypedDataDomain

type ECSignature 

type ECSignature struct {
	V byte
	R common.Hash
	S common.Hash
}

ECSignature contains the parameters of an elliptic curve signature

func (ECSignature) Bytes 

func (ecSignature ECSignature) Bytes() []byte

Bytes generates 0x EthSign Signature (append the signature type byte) data

type EIP712Domain 

type EIP712Domain struct {
	VerifyingContract common.Address `json:"verifyingContract"`
	ChainID           *big.Int       `json:"chainID"`
}

type EthRPCSigner 

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

EthRPCSigner is a signer that uses a call to Ethereum JSON-RPC method `eth_call` to produce a signature

func (*EthRPCSigner) EcRecover 

func (e *EthRPCSigner) EcRecover(message []byte, sig []byte) (common.Address, error)

func (*EthRPCSigner) EthSign 

func (e *EthRPCSigner) EthSign(message []byte, signerAddress common.Address) (*ECSignature, error)

EthSign signs a message via the `eth_sign` Ethereum JSON-RPC call

type FeeDelegationOptions 

type FeeDelegationOptions struct {
	FeePayer cosmtypes.AccAddress
}

type FuturesFunctionName 

type FuturesFunctionName string
const (
	ClosePositionMetaTransaction     FuturesFunctionName = "closePositionMetaTransaction"
	ClosePosition                    FuturesFunctionName = "closePosition"
	LiquidatePosition                FuturesFunctionName = "liquidatePosition"
	VaporizePosition                 FuturesFunctionName = "vaporizePosition"
	BatchCheckFunding                FuturesFunctionName = "batchCheckFunding"
	WithdrawForSubAccount            FuturesFunctionName = "withdrawForSubAccount"
	DepositForSubaccount             FuturesFunctionName = "depositForSubaccount"
	Deposit                          FuturesFunctionName = "deposit"
	CreateMarketWithFixedMarketId    FuturesFunctionName = "createMarketWithFixedMarketId"
	BatchCancelOrders                FuturesFunctionName = "batchCancelOrders"
	AddMarginIntoPosition            FuturesFunctionName = "addMarginIntoPosition"
	SettleExpiryFuturesPosition      FuturesFunctionName = "settleExpiryFuturesPosition"
	BatchSettleExpiryFuturesPosition FuturesFunctionName = "batchSettleExpiryFuturesPosition"
	TransferPosition                 FuturesFunctionName = "transferPosition"
	ApproveForReceiving              FuturesFunctionName = "approveForReceiving"
	SetReceiptApprovalForMarket      FuturesFunctionName = "setReceiptApprovalForMarket"
	SetReceiptApprovalForAll         FuturesFunctionName = "setReceiptApprovalForAll"
	Approve                          FuturesFunctionName = "approve"
	SetApprovalForMarket             FuturesFunctionName = "setApprovalForMarket"
	SetApprovalForAll                FuturesFunctionName = "setApprovalForAll"
)
const (
	//BatchCancelOrders                 FuturesFunctionName = "batchCancelOrders"
	BatchExecuteTransactions          FuturesFunctionName = "batchExecuteTransactions"
	BatchFillOrKillOrders             FuturesFunctionName = "batchFillOrKillOrders"
	BatchFillOrders                   FuturesFunctionName = "batchFillOrders"
	BatchFillOrdersNoThrow            FuturesFunctionName = "batchFillOrdersNoThrow"
	BatchMatchOrders                  FuturesFunctionName = "batchMatchOrders"
	BatchMatchOrdersWithMaximalFill   FuturesFunctionName = "batchMatchOrdersWithMaximalFill"
	CancelOrder                       FuturesFunctionName = "cancelOrder"
	CancelOrdersUpTo                  FuturesFunctionName = "cancelOrdersUpTo"
	ExecuteTransaction                FuturesFunctionName = "executeTransaction"
	FillOrKillOrder                   FuturesFunctionName = "fillOrKillOrder"
	FillOrder                         FuturesFunctionName = "fillOrder"
	FillOrderNoThrow                  FuturesFunctionName = "fillOrderNoThrow"
	MarketBuyOrdersNoThrow            FuturesFunctionName = "marketBuyOrdersNoThrow"
	MarketSellOrdersNoThrow           FuturesFunctionName = "marketSellOrdersNoThrow"
	MarketBuyOrdersFillOrKill         FuturesFunctionName = "marketBuyOrdersFillOrKill"
	MarketSellOrdersFillOrKill        FuturesFunctionName = "marketSellOrdersFillOrKill"
	MatchOrders                       FuturesFunctionName = "matchOrders"
	MatchOrdersWithMaximalFill        FuturesFunctionName = "matchOrdersWithMaximalFill"
	PreSign                           FuturesFunctionName = "preSign"
	RegisterAssetProxy                FuturesFunctionName = "registerAssetProxy"
	SetSignatureValidatorApproval     FuturesFunctionName = "setSignatureValidatorApproval"
	SimulateDispatchTransferFromCalls FuturesFunctionName = "simulateDispatchTransferFromCalls"
	TransferOwnership                 FuturesFunctionName = "transferOwnership"
	SetProtocolFeeMultiplier          FuturesFunctionName = "setProtocolFeeMultiplier"
	SetProtocolFeeCollectorAddress    FuturesFunctionName = "setProtocolFeeCollectorAddress"
	DetachProtocolFeeCollector        FuturesFunctionName = "detachProtocolFeeCollector"
)

func (FuturesFunctionName) HasPart 

func (e FuturesFunctionName) HasPart(part string) bool

type LocalKeystoreSigner 

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

LocalKeystoreSigner is a signer that produces an `eth_sign`-compatible signature locally using a private key

func (*LocalKeystoreSigner) EcRecover 

func (l *LocalKeystoreSigner) EcRecover(message []byte, sig []byte) (common.Address, error)

func (*LocalKeystoreSigner) EthSign 

func (l *LocalKeystoreSigner) EthSign(message []byte, signerAddress common.Address) (*ECSignature, error)

type LocalSigner 

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

LocalSigner is a signer that produces an `eth_sign`-compatible signature locally using a private key

func (*LocalSigner) EcRecover 

func (l *LocalSigner) EcRecover(message []byte, sig []byte) (common.Address, error)

func (*LocalSigner) EthSign 

func (l *LocalSigner) EthSign(message []byte, signerAddress common.Address) (*ECSignature, error)

EthSign mimicks the signing of `eth_sign` locally its supplied private key

func (*LocalSigner) GetSignerAddress 

func (l *LocalSigner) GetSignerAddress() common.Address

GetSignerAddress returns the signerAddress corresponding to LocalSigner's private key

type Order 

type Order struct {
	ChainID               *big.Int       `json:"chainId"`
	ExchangeAddress       common.Address `json:"exchangeAddress"`
	MakerAddress          common.Address `json:"makerAddress"`
	MakerAssetData        []byte         `json:"makerAssetData"`
	MakerFeeAssetData     []byte         `json:"makerFeeAssetData"`
	MakerAssetAmount      *big.Int       `json:"makerAssetAmount"`
	MakerFee              *big.Int       `json:"makerFee"`
	TakerAddress          common.Address `json:"takerAddress"`
	TakerAssetData        []byte         `json:"takerAssetData"`
	TakerFeeAssetData     []byte         `json:"takerFeeAssetData"`
	TakerAssetAmount      *big.Int       `json:"takerAssetAmount"`
	TakerFee              *big.Int       `json:"takerFee"`
	SenderAddress         common.Address `json:"senderAddress"`
	FeeRecipientAddress   common.Address `json:"feeRecipientAddress"`
	ExpirationTimeSeconds *big.Int       `json:"expirationTimeSeconds"`
	Salt                  *big.Int       `json:"salt"`
	// contains filtered or unexported fields
}

Order represents an unsigned 0x order

func FromTrimmedOrder 

func FromTrimmedOrder(order wrappers.Order) *Order

func (*Order) ComputeOrderHash 

func (o *Order) ComputeOrderHash() (common.Hash, error)

ComputeOrderHash computes a 0x order hash

func (*Order) ComputeSubaccountID 

func (o *Order) ComputeSubaccountID() common.Hash

func (*Order) MarshalIntoTrimmedOrderJSON 

func (o *Order) MarshalIntoTrimmedOrderJSON() ([]byte, error)

MarshalJSON implements a custom JSON marshaller for the Order type into Trimmed Order

func (*Order) ResetHash 

func (o *Order) ResetHash()

ResetHash resets the cached order hash. Usually only required for testing.

type OrderEvent 

type OrderEvent struct {
	// Timestamp is an order event timestamp that can be used for bookkeeping purposes.
	// If the OrderEvent represents a Mesh-specific event (e.g., ADDED, STOPPED_WATCHING),
	// the timestamp is when the event was generated. If the event was generated after
	// re-validating an order at the latest block height (e.g., FILLED, UNFUNDED, CANCELED),
	// then it is set to the latest block timestamp at which the order was re-validated.
	Timestamp time.Time `json:"timestamp"`
	// OrderHash is the EIP712 hash of the 0x order
	OrderHash common.Hash `json:"orderHash"`
	// SignedOrder is the signed 0x order struct
	SignedOrder *SignedOrder `json:"signedOrder"`
	// EndState is the end state of this order at the time this event was generated
	EndState OrderEventEndState `json:"endState"`
	// FillableTakerAssetAmount is the amount for which this order is still fillable
	FillableTakerAssetAmount *big.Int `json:"fillableTakerAssetAmount"`
	// ContractEvents contains all the contract events that triggered this orders re-evaluation.
	// They did not all necessarily cause the orders state change itself, only it's re-evaluation.
	// Since it's state _did_ change, at least one of them did cause the actual state change.
	ContractEvents []*ContractEvent `json:"contractEvents"`
}

OrderEvent is the order event emitted by Mesh nodes on the "orders" topic when calling JSON-RPC method `mesh_subscribe`

func (OrderEvent) MarshalJSON 

func (o OrderEvent) MarshalJSON() ([]byte, error)

MarshalJSON implements a custom JSON marshaller for the OrderEvent type

type OrderEventEndState 

type OrderEventEndState string

OrderEventEndState enumerates all the possible order event types. An OrderEventEndState describes the end state of a 0x order after revalidation

type OrderStatus 

type OrderStatus uint8

OrderStatus represents the status of an order as returned from the 0x smart contracts as part of OrderInfo 

const (
	OSInvalid OrderStatus = iota
	OSInvalidMakerAssetAmount
	OSInvalidTakerAssetAmount
	OSFillable
	OSExpired
	OSFullyFilled
	OSCancelled
	OSSignatureInvalid
	OSInvalidMakerAssetData
	OSInvalidTakerAssetData
)

OrderStatus values

type Permyriad 

type Permyriad struct {
	Value *big.Int
}

type SignatureType 

type SignatureType uint8

SignatureType represents the type of 0x signature encountered 

const (
	IllegalSignature SignatureType = iota
	InvalidSignature
	EIP712Signature
	EthSignSignature
	WalletSignature
	ValidatorSignature
	PreSignedSignature
	EIP1271WalletSignature
	NSignatureTypesSignature
)

SignatureType values

type SignedCoordinatorApproval 

type SignedCoordinatorApproval struct {
	CoordinatorApproval
	Signature []byte `json:"signature"`
}

func SignCoordinatorApproval 

func SignCoordinatorApproval(
	coordinatorFrom common.Address,
	ethSigner Signer,
	approval *CoordinatorApproval,
) (*SignedCoordinatorApproval, error)

SignCoordinatorApproval signs the 0x coordinator approval with the supplied Signer

type SignedOrder 

type SignedOrder struct {
	Order
	Signature []byte `json:"signature"`
}

SignedOrder represents a signed 0x order

func SignOrder 

func SignOrder(signer Signer, order *Order) (*SignedOrder, error)

SignOrder signs the 0x order with the supplied Signer.

func (SignedOrder) MarshalJSON 

func (s SignedOrder) MarshalJSON() ([]byte, error)

MarshalJSON implements a custom JSON marshaller for the SignedOrder type

func (*SignedOrder) Trim 

func (s *SignedOrder) Trim() wrappers.Order

Trim converts the order to a TrimmedOrder, which is the format expected by our smart contracts. It removes the ChainID and ExchangeAddress fields.

func (*SignedOrder) UnmarshalJSON 

func (s *SignedOrder) UnmarshalJSON(data []byte) error

UnmarshalJSON implements a custom JSON unmarshaller for the SignedOrder type

type SignedOrderJSON 

type SignedOrderJSON struct {
	ChainID               int64  `json:"chainId"`
	ExchangeAddress       string `json:"exchangeAddress"`
	MakerAddress          string `json:"makerAddress"`
	MakerAssetData        string `json:"makerAssetData"`
	MakerFeeAssetData     string `json:"makerFeeAssetData"`
	MakerAssetAmount      string `json:"makerAssetAmount"`
	MakerFee              string `json:"makerFee"`
	TakerAddress          string `json:"takerAddress"`
	TakerAssetData        string `json:"takerAssetData"`
	TakerFeeAssetData     string `json:"takerFeeAssetData"`
	TakerAssetAmount      string `json:"takerAssetAmount"`
	TakerFee              string `json:"takerFee"`
	SenderAddress         string `json:"senderAddress"`
	FeeRecipientAddress   string `json:"feeRecipientAddress"`
	ExpirationTimeSeconds string `json:"expirationTimeSeconds"`
	Salt                  string `json:"salt"`
	Signature             string `json:"signature"`
}

SignedOrderJSON is an unmodified JSON representation of a SignedOrder

type SignedSpotOrder 

type SignedSpotOrder struct {
	SpotOrder
	Signature []byte `json:"signature"`
}

SignedSpotOrder represents a signed Injective Spot order

func SignSpotOrder 

func SignSpotOrder(signer Signer, order *SpotOrder) (*SignedSpotOrder, error)

SignSpotOrder signs the Injective Spot order with the supplied Signer.

func (*SignedSpotOrder) ComputeSpotPrice 

func (s *SignedSpotOrder) ComputeSpotPrice() *decimal.Decimal

type SignedTransaction 

type SignedTransaction struct {
	Transaction
	Signature []byte `json:"signature"`
}

func SignTransaction 

func SignTransaction(
	sender common.Address,
	ethSigner Signer,
	tx *Transaction,
) (*SignedTransaction, error)

SignTransaction signs the 0x transaction with the supplied Signer

type Signer 

type Signer interface {
	EthSign(message []byte, signerAddress common.Address) (*ECSignature, error)
	EcRecover(message []byte, sig []byte) (common.Address, error)
}

Signer defines the methods needed to act as a elliptic curve signer

func NewEthRPCSigner 

func NewEthRPCSigner(rpcClient *rpc.Client) Signer

NewEthRPCSigner instantiates a new EthRPCSigner

func NewLocalKeystoreSigner 

func NewLocalKeystoreSigner(keystore *keystore.KeyStore) Signer

NewLocalKeystoreSigner instantiates a new LocalKeystoreSigner

func NewLocalSigner 

func NewLocalSigner(privateKey *ecdsa.PrivateKey) Signer

NewLocalSigner instantiates a new LocalSigner

type SpotOrder 

type SpotOrder struct {
	ChainID      int64          `json:"chainId"`
	SubaccountID common.Hash    `json:"subaccountID"`
	Sender       common.Address `json:"sender"`
	FeeRecipient common.Address `json:"feeRecipient"`
	Expiry       uint64         `json:"expiry"`
	MarketID     common.Hash    `json:"marketID"`
	SupplyAmount *big.Int       `json:"supplyAmount"`
	DemandAmount *big.Int       `json:"demandAmount"`
	Salt         uint64         `json:"salt"`
	OrderType    uint8          `json:"orderType"`
	TriggerPrice *big.Int       `json:"triggerPrice"`
	// contains filtered or unexported fields
}

SpotOrder represents an unsigned Injective Spot order

func (*SpotOrder) ComputeOrderHash 

func (o *SpotOrder) ComputeOrderHash() (common.Hash, error)

ComputeOrderHash computes a Injective Spot Order hash

func (*SpotOrder) GetMakerAddressAndNonce 

func (o *SpotOrder) GetMakerAddressAndNonce() (common.Address, *big.Int)

func (*SpotOrder) ResetHash 

func (o *SpotOrder) ResetHash()

ResetHash resets the cached order hash. Usually only required for testing.

type Transaction 

type Transaction struct {
	Salt                  *big.Int       `json:"salt"`
	SignerAddress         common.Address `json:"signerAddress"`
	Data                  []byte         `json:"data"`
	ExpirationTimeSeconds *big.Int       `json:"expirationTimeSeconds"`
	GasPrice              *big.Int       `json:"gasPrice"`
	Domain                EIP712Domain   `json:"domain"`
	// contains filtered or unexported fields
}

func (*Transaction) ComputeTransactionHash 

func (tx *Transaction) ComputeTransactionHash() (common.Hash, error)

ComputeTransactionHash computes a 0x transaction hash

func (*Transaction) DecodeTransactionData 

func (tx *Transaction) DecodeTransactionData() (*ZeroExTransactionData, error)

func (*Transaction) ExchangeDomain 

func (tx *Transaction) ExchangeDomain() typeddata.TypedDataDomain

type TrimmedOrderJSON 

type TrimmedOrderJSON struct {
	MakerAddress          string `json:"makerAddress"`
	MakerAssetData        string `json:"makerAssetData"`
	MakerFeeAssetData     string `json:"makerFeeAssetData"`
	MakerAssetAmount      string `json:"makerAssetAmount"`
	MakerFee              string `json:"makerFee"`
	TakerAddress          string `json:"takerAddress"`
	TakerAssetData        string `json:"takerAssetData"`
	TakerFeeAssetData     string `json:"takerFeeAssetData"`
	TakerAssetAmount      string `json:"takerAssetAmount"`
	TakerFee              string `json:"takerFee"`
	SenderAddress         string `json:"senderAddress"`
	FeeRecipientAddress   string `json:"feeRecipientAddress"`
	ExpirationTimeSeconds string `json:"expirationTimeSeconds"`
	Salt                  string `json:"salt"`
}

TrimmedOrderJSON is an unmodified JSON representation of a Trimmed Order

type ZeroExTransactionData 

type ZeroExTransactionData struct {
	FunctionName              FuturesFunctionName
	Orders                    []*Order
	MarketIDs                 []common.Hash
	SubAccountID              common.Hash
	ExchangeAddress           common.Address
	CloseQuantity             *big.Int
	SubaccountID              common.Hash
	Signatures                [][]byte
	PositionID                *big.Int
	Quantity                  *big.Int
	BaseCurrency              common.Address
	Amount                    *big.Int
	IsRevertingOnPartialFills bool
	// market specific parameters
	Ticker                 string
	Oracle                 common.Address
	InitialMarginRatio     Permyriad
	MaintenanceMarginRatio Permyriad
	FundingInterval        *big.Int
	ExpirationTime         *big.Int
	MakerTxFee             Permyriad
	TakerTxFee             Permyriad
	RelayerFeePercentage   Permyriad
	MarketID               common.Hash
	// parameters from 0x
	LeftOrders            []*Order
	RightOrders           []*Order
	TakerAssetFillAmounts []*big.Int
	MakerAssetFillAmount  *big.Int
	TakerAssetFillAmount  *big.Int
	LeftSignatures        [][]byte
	RightSignatures       [][]byte
}

func DecodeFromTransactionData 

func DecodeFromTransactionData(data []byte) (txData *ZeroExTransactionData, err error)

func (*ZeroExTransactionData) ValidateAssetFillAmounts 

func (data *ZeroExTransactionData) ValidateAssetFillAmounts() error

Source Files

View all Source files

Directories

Path Synopsis
bandchain
hooks/price
oracle/types
chain
auction/types
Package types is a reverse proxy.
 Package types is a reverse proxy.
client
client/tmclient
crypto/codec
crypto/ethsecp256k1
crypto/hd
erc20bridge/client/cli
erc20bridge/types
Package types is a reverse proxy.
 Package types is a reverse proxy.
evm/client/cli
evm/types
exchange/types
insurance/types
Package types is a reverse proxy.
 Package types is a reverse proxy.
oracle/types
Package types is a reverse proxy.
 Package types is a reverse proxy.
peggy/types
types
ethereum
rpc
util
exchange
accounts_rpc/pb
derivative_exchange_rpc/pb
exchange_rpc/pb
insurance_rpc/pb
oracle_rpc/pb
spot_exchange_rpc/pb

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.