ccipruntime

package
v0.0.0-...-346157b Latest Latest
Warning

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

 Go to latest Published: May 27, 2026 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	PackageName = "ccip-runtime"
	PackageID   = "4b849289445f60506da7c3e545ff6eb1a7f72aaf2b272dc8d7a63ca0c1fbc7c5"
	SDKVersion  = "3.4.11"
)
View Source 
const (
	OffRampKey              = types.TEXT("off-ramp")
	OnRampKey               = types.TEXT("on-ramp")
	NoExecutionAddressBytes = types.TEXT("eba517d200000000000000000000000000000000000000000000000000000000")
	MessageStaticSize       = types.INT64(69)
	MaxExecutedMessagesSize = types.INT64(25000)
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AddCustomObservers2 

type AddCustomObservers2 struct {
	Parties []types.PARTY `json:"parties"`
}

AddCustomObservers2 is a Record type

func (AddCustomObservers2) MarshalHex 

func (t AddCustomObservers2) MarshalHex() (string, error)

MarshalHex encodes AddCustomObservers2 to hex string (Canton MCMS format)

func (AddCustomObservers2) MarshalJSON 

func (t AddCustomObservers2) MarshalJSON() ([]byte, error)

func (AddCustomObservers2) ToMap 

func (t AddCustomObservers2) ToMap() map[string]any

ToMap converts AddCustomObservers2 to a map for DAML arguments

func (*AddCustomObservers2) UnmarshalHex 

func (t *AddCustomObservers2) UnmarshalHex(data string) error

UnmarshalHex decodes AddCustomObservers2 from hex string (Canton MCMS format)

func (*AddCustomObservers2) UnmarshalJSON 

func (t *AddCustomObservers2) UnmarshalJSON(data []byte) error

type AddCustomObserversParams2 

type AddCustomObserversParams2 struct {
	Parties []types.PARTY `json:"parties"`
}

AddCustomObserversParams2 is a Record type

func (AddCustomObserversParams2) MarshalHex 

func (t AddCustomObserversParams2) MarshalHex() (string, error)

MarshalHex encodes AddCustomObserversParams2 to hex string (Canton MCMS format)

func (AddCustomObserversParams2) MarshalJSON 

func (t AddCustomObserversParams2) MarshalJSON() ([]byte, error)

func (AddCustomObserversParams2) ToMap 

func (t AddCustomObserversParams2) ToMap() map[string]any

ToMap converts AddCustomObserversParams2 to a map for DAML arguments

func (*AddCustomObserversParams2) UnmarshalHex 

func (t *AddCustomObserversParams2) UnmarshalHex(data string) error

UnmarshalHex decodes AddCustomObserversParams2 from hex string (Canton MCMS format)

func (*AddCustomObserversParams2) UnmarshalJSON 

func (t *AddCustomObserversParams2) UnmarshalJSON(data []byte) error

type ArchivedExecutedMessages 

type ArchivedExecutedMessages struct {
	CcipOwner                types.PARTY `json:"ccipOwner"`
	PartyOwner               types.PARTY `json:"partyOwner"`
	PerPartyRouterInstanceId types.TEXT  `json:"perPartyRouterInstanceId"`
	ArchiveIndex             types.INT64 `json:"archiveIndex"`
	ExecutedMessages         types.SET   `json:"executedMessages"`
}

ArchivedExecutedMessages is a Template type

func (ArchivedExecutedMessages) Archive 

func (t ArchivedExecutedMessages) Archive(contractID string) *model.ExerciseCommand

Archive exercises the Archive choice on this ArchivedExecutedMessages contract This method uses the package name in the template ID

func (ArchivedExecutedMessages) ArchiveWithPackageID 

func (t ArchivedExecutedMessages) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand

ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name

func (ArchivedExecutedMessages) CreateCommand 

func (t ArchivedExecutedMessages) CreateCommand() *model.CreateCommand

CreateCommand returns a CreateCommand for this template using the package name

func (ArchivedExecutedMessages) CreateCommandWithPackageID 

func (t ArchivedExecutedMessages) CreateCommandWithPackageID(packageID string) *model.CreateCommand

CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name

func (ArchivedExecutedMessages) GetTemplateID 

func (t ArchivedExecutedMessages) GetTemplateID() string

GetTemplateID returns the template ID for this template using the package name

func (ArchivedExecutedMessages) GetTemplateIDWithPackageID 

func (t ArchivedExecutedMessages) GetTemplateIDWithPackageID(packageID string) string

GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name

func (ArchivedExecutedMessages) IsExecuted 

func (t ArchivedExecutedMessages) IsExecuted(contractID string, args IsExecuted) *model.ExerciseCommand

IsExecuted exercises the IsExecuted choice on this ArchivedExecutedMessages contract This method uses the package name in the template ID

func (ArchivedExecutedMessages) IsExecutedWithPackageID 

func (t ArchivedExecutedMessages) IsExecutedWithPackageID(contractID string, packageID string, args IsExecuted) *model.ExerciseCommand

IsExecutedWithPackageID exercises the IsExecuted choice using the provided package ID instead of package name

func (ArchivedExecutedMessages) MarshalHex 

func (t ArchivedExecutedMessages) MarshalHex() (string, error)

MarshalHex encodes ArchivedExecutedMessages to hex string (Canton MCMS format)

func (ArchivedExecutedMessages) MarshalJSON 

func (t ArchivedExecutedMessages) MarshalJSON() ([]byte, error)

func (*ArchivedExecutedMessages) UnmarshalHex 

func (t *ArchivedExecutedMessages) UnmarshalHex(data string) error

UnmarshalHex decodes ArchivedExecutedMessages from hex string (Canton MCMS format)

func (*ArchivedExecutedMessages) UnmarshalJSON 

func (t *ArchivedExecutedMessages) UnmarshalJSON(data []byte) error

type CCIPSend 

type CCIPSend struct {
	Context                 splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	SendingMessageCid       types.CONTRACT_ID                          `json:"sendingMessageCid"`
	FeeTokenHoldingCids     []types.CONTRACT_ID                        `json:"feeTokenHoldingCids"`
	FeeTokenConfigCid       types.CONTRACT_ID                          `json:"feeTokenConfigCid"`
	FeeTokenTransferFactory types.CONTRACT_ID                          `json:"feeTokenTransferFactory"`
	FeeTokenExtraArgs       splice_api_token_metadata_v1.ExtraArgs     `json:"feeTokenExtraArgs"`
}

CCIPSend is a Record type

func (CCIPSend) MarshalHex 

func (t CCIPSend) MarshalHex() (string, error)

MarshalHex encodes CCIPSend to hex string (Canton MCMS format)

func (CCIPSend) MarshalJSON 

func (t CCIPSend) MarshalJSON() ([]byte, error)

func (CCIPSend) ToMap 

func (t CCIPSend) ToMap() map[string]any

ToMap converts CCIPSend to a map for DAML arguments

func (*CCIPSend) UnmarshalHex 

func (t *CCIPSend) UnmarshalHex(data string) error

UnmarshalHex decodes CCIPSend from hex string (Canton MCMS format)

func (*CCIPSend) UnmarshalJSON 

func (t *CCIPSend) UnmarshalJSON(data []byte) error

type CCIPSendFromRouter 

type CCIPSendFromRouter struct {
	RouterPartyOwner      types.PARTY        `json:"routerPartyOwner"`
	RouterInstanceId      types.TEXT         `json:"routerInstanceId"`
	CurrentSequenceNumber types.NUMERIC      `json:"currentSequenceNumber"`
	RmnRemoteCid          types.CONTRACT_ID  `json:"rmnRemoteCid"`
	GlobalConfigCid       types.CONTRACT_ID  `json:"globalConfigCid"`
	TokenAdminRegistryCid types.CONTRACT_ID  `json:"tokenAdminRegistryCid"`
	TokenConfigCid        *types.CONTRACT_ID `json:"tokenConfigCid" hex:"optional"`
	SendingMessageCid     types.CONTRACT_ID  `json:"sendingMessageCid"`
}

CCIPSendFromRouter is a Record type

func (CCIPSendFromRouter) MarshalHex 

func (t CCIPSendFromRouter) MarshalHex() (string, error)

MarshalHex encodes CCIPSendFromRouter to hex string (Canton MCMS format)

func (CCIPSendFromRouter) MarshalJSON 

func (t CCIPSendFromRouter) MarshalJSON() ([]byte, error)

func (CCIPSendFromRouter) ToMap 

func (t CCIPSendFromRouter) ToMap() map[string]any

ToMap converts CCIPSendFromRouter to a map for DAML arguments

func (*CCIPSendFromRouter) UnmarshalHex 

func (t *CCIPSendFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes CCIPSendFromRouter from hex string (Canton MCMS format)

func (*CCIPSendFromRouter) UnmarshalJSON 

func (t *CCIPSendFromRouter) UnmarshalJSON(data []byte) error

type CCIPSendFromRouterResult 

type CCIPSendFromRouterResult struct {
	CcipMessageSent      types.CONTRACT_ID `json:"ccipMessageSent"`
	VerifierBlobs        []types.TEXT      `json:"verifierBlobs"`
	MessageSentObservers []types.PARTY     `json:"messageSentObservers"`
	Receipts             []core.Receipt    `json:"receipts"`
}

CCIPSendFromRouterResult is a Record type

func (CCIPSendFromRouterResult) MarshalHex 

func (t CCIPSendFromRouterResult) MarshalHex() (string, error)

MarshalHex encodes CCIPSendFromRouterResult to hex string (Canton MCMS format)

func (CCIPSendFromRouterResult) MarshalJSON 

func (t CCIPSendFromRouterResult) MarshalJSON() ([]byte, error)

func (CCIPSendFromRouterResult) ToMap 

func (t CCIPSendFromRouterResult) ToMap() map[string]any

ToMap converts CCIPSendFromRouterResult to a map for DAML arguments

func (*CCIPSendFromRouterResult) UnmarshalHex 

func (t *CCIPSendFromRouterResult) UnmarshalHex(data string) error

UnmarshalHex decodes CCIPSendFromRouterResult from hex string (Canton MCMS format)

func (*CCIPSendFromRouterResult) UnmarshalJSON 

func (t *CCIPSendFromRouterResult) UnmarshalJSON(data []byte) error

type CCIPSendResult 

type CCIPSendResult struct {
	Router                 types.CONTRACT_ID   `json:"router"`
	CcipMessageSent        types.CONTRACT_ID   `json:"ccipMessageSent"`
	MessageId              types.TEXT          `json:"messageId"`
	FeeChangeCids          []types.CONTRACT_ID `json:"feeChangeCids"`
	PendingFeeInstructions []types.CONTRACT_ID `json:"pendingFeeInstructions"`
}

CCIPSendResult is a Record type

func (CCIPSendResult) MarshalHex 

func (t CCIPSendResult) MarshalHex() (string, error)

MarshalHex encodes CCIPSendResult to hex string (Canton MCMS format)

func (CCIPSendResult) MarshalJSON 

func (t CCIPSendResult) MarshalJSON() ([]byte, error)

func (CCIPSendResult) ToMap 

func (t CCIPSendResult) ToMap() map[string]any

ToMap converts CCIPSendResult to a map for DAML arguments

func (*CCIPSendResult) UnmarshalHex 

func (t *CCIPSendResult) UnmarshalHex(data string) error

UnmarshalHex decodes CCIPSendResult from hex string (Canton MCMS format)

func (*CCIPSendResult) UnmarshalJSON 

func (t *CCIPSendResult) UnmarshalJSON(data []byte) error

type Contract 

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

Contract wraps template operations with Sui-style API access. Use NewContract to create instances, then call Encoder() for encoding methods.

func NewContract 

func NewContract(packageID, moduleName, templateName string) *Contract

NewContract creates a Contract with encoder for the given template. This provides Sui-style API: contract.Encoder().Method(args)

func (*Contract) Encoder 

func (c *Contract) Encoder() MCMSEncoder

Encoder returns the encoder for Sui-style contract.Encoder().Method() usage.

type CreateRouter 

type CreateRouter struct {
	PartyOwner types.PARTY `json:"partyOwner"`
	InstanceId types.TEXT  `json:"instanceId"`
}

CreateRouter is a Record type

func (CreateRouter) MarshalHex 

func (t CreateRouter) MarshalHex() (string, error)

MarshalHex encodes CreateRouter to hex string (Canton MCMS format)

func (CreateRouter) MarshalJSON 

func (t CreateRouter) MarshalJSON() ([]byte, error)

func (CreateRouter) ToMap 

func (t CreateRouter) ToMap() map[string]any

ToMap converts CreateRouter to a map for DAML arguments

func (*CreateRouter) UnmarshalHex 

func (t *CreateRouter) UnmarshalHex(data string) error

UnmarshalHex decodes CreateRouter from hex string (Canton MCMS format)

func (*CreateRouter) UnmarshalJSON 

func (t *CreateRouter) UnmarshalJSON(data []byte) error

type CreateRouterResult 

type CreateRouterResult struct {
	Router  types.CONTRACT_ID `json:"router"`
	Factory types.CONTRACT_ID `json:"factory"`
}

CreateRouterResult is a Record type

func (CreateRouterResult) MarshalHex 

func (t CreateRouterResult) MarshalHex() (string, error)

MarshalHex encodes CreateRouterResult to hex string (Canton MCMS format)

func (CreateRouterResult) MarshalJSON 

func (t CreateRouterResult) MarshalJSON() ([]byte, error)

func (CreateRouterResult) ToMap 

func (t CreateRouterResult) ToMap() map[string]any

ToMap converts CreateRouterResult to a map for DAML arguments

func (*CreateRouterResult) UnmarshalHex 

func (t *CreateRouterResult) UnmarshalHex(data string) error

UnmarshalHex decodes CreateRouterResult from hex string (Canton MCMS format)

func (*CreateRouterResult) UnmarshalJSON 

func (t *CreateRouterResult) UnmarshalJSON(data []byte) error

type Execute 

type Execute struct {
	Context             splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	ExecutingMessageCid types.CONTRACT_ID                          `json:"executingMessageCid"`
}

Execute is a Record type

func (Execute) MarshalHex 

func (t Execute) MarshalHex() (string, error)

MarshalHex encodes Execute to hex string (Canton MCMS format)

func (Execute) MarshalJSON 

func (t Execute) MarshalJSON() ([]byte, error)

func (Execute) ToMap 

func (t Execute) ToMap() map[string]any

ToMap converts Execute to a map for DAML arguments

func (*Execute) UnmarshalHex 

func (t *Execute) UnmarshalHex(data string) error

UnmarshalHex decodes Execute from hex string (Canton MCMS format)

func (*Execute) UnmarshalJSON 

func (t *Execute) UnmarshalJSON(data []byte) error

type ExecuteFromRouter 

type ExecuteFromRouter struct {
	RouterPartyOwner      types.PARTY        `json:"routerPartyOwner"`
	ExecutingMessageCid   types.CONTRACT_ID  `json:"executingMessageCid"`
	GlobalConfigCid       types.CONTRACT_ID  `json:"globalConfigCid"`
	TokenAdminRegistryCid types.CONTRACT_ID  `json:"tokenAdminRegistryCid"`
	TokenConfigCid        *types.CONTRACT_ID `json:"tokenConfigCid" hex:"optional"`
	RmnRemoteCid          types.CONTRACT_ID  `json:"rmnRemoteCid"`
}

ExecuteFromRouter is a Record type

func (ExecuteFromRouter) MarshalHex 

func (t ExecuteFromRouter) MarshalHex() (string, error)

MarshalHex encodes ExecuteFromRouter to hex string (Canton MCMS format)

func (ExecuteFromRouter) MarshalJSON 

func (t ExecuteFromRouter) MarshalJSON() ([]byte, error)

func (ExecuteFromRouter) ToMap 

func (t ExecuteFromRouter) ToMap() map[string]any

ToMap converts ExecuteFromRouter to a map for DAML arguments

func (*ExecuteFromRouter) UnmarshalHex 

func (t *ExecuteFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes ExecuteFromRouter from hex string (Canton MCMS format)

func (*ExecuteFromRouter) UnmarshalJSON 

func (t *ExecuteFromRouter) UnmarshalJSON(data []byte) error

type ExecuteFromRouterResult 

type ExecuteFromRouterResult struct {
	MessageId             types.TEXT         `json:"messageId"`
	Message               core.MessageV1     `json:"message"`
	SourceChainSelector   types.NUMERIC      `json:"sourceChainSelector"`
	SequenceNumber        types.NUMERIC      `json:"sequenceNumber"`
	TokenReceiveTicket    *types.CONTRACT_ID `json:"tokenReceiveTicket" hex:"optional"`
	ExecutionStateChanged types.CONTRACT_ID  `json:"executionStateChanged"`
}

ExecuteFromRouterResult is a Record type

func (ExecuteFromRouterResult) MarshalHex 

func (t ExecuteFromRouterResult) MarshalHex() (string, error)

MarshalHex encodes ExecuteFromRouterResult to hex string (Canton MCMS format)

func (ExecuteFromRouterResult) MarshalJSON 

func (t ExecuteFromRouterResult) MarshalJSON() ([]byte, error)

func (ExecuteFromRouterResult) ToMap 

func (t ExecuteFromRouterResult) ToMap() map[string]any

ToMap converts ExecuteFromRouterResult to a map for DAML arguments

func (*ExecuteFromRouterResult) UnmarshalHex 

func (t *ExecuteFromRouterResult) UnmarshalHex(data string) error

UnmarshalHex decodes ExecuteFromRouterResult from hex string (Canton MCMS format)

func (*ExecuteFromRouterResult) UnmarshalJSON 

func (t *ExecuteFromRouterResult) UnmarshalJSON(data []byte) error

type ExecuteResult 

type ExecuteResult struct {
	Router                types.CONTRACT_ID          `json:"router"`
	TokenReceiveTicket    *types.CONTRACT_ID         `json:"tokenReceiveTicket" hex:"optional"`
	ExecutionStateChanged types.CONTRACT_ID          `json:"executionStateChanged"`
	MessageId             types.TEXT                 `json:"messageId"`
	Message               core.MessageV1             `json:"message"`
	State                 core.MessageExecutionState `json:"state"`
}

ExecuteResult is a Record type

func (ExecuteResult) MarshalHex 

func (t ExecuteResult) MarshalHex() (string, error)

MarshalHex encodes ExecuteResult to hex string (Canton MCMS format)

func (ExecuteResult) MarshalJSON 

func (t ExecuteResult) MarshalJSON() ([]byte, error)

func (ExecuteResult) ToMap 

func (t ExecuteResult) ToMap() map[string]any

ToMap converts ExecuteResult to a map for DAML arguments

func (*ExecuteResult) UnmarshalHex 

func (t *ExecuteResult) UnmarshalHex(data string) error

UnmarshalHex decodes ExecuteResult from hex string (Canton MCMS format)

func (*ExecuteResult) UnmarshalJSON 

func (t *ExecuteResult) UnmarshalJSON(data []byte) error

type FactorySetDeps 

type FactorySetDeps struct {
	NewDeps SetDepsParams `json:"newDeps"`
}

FactorySetDeps is a Record type

func (FactorySetDeps) MarshalHex 

func (t FactorySetDeps) MarshalHex() (string, error)

MarshalHex encodes FactorySetDeps to hex string (Canton MCMS format)

func (FactorySetDeps) MarshalJSON 

func (t FactorySetDeps) MarshalJSON() ([]byte, error)

func (FactorySetDeps) ToMap 

func (t FactorySetDeps) ToMap() map[string]any

ToMap converts FactorySetDeps to a map for DAML arguments

func (*FactorySetDeps) UnmarshalHex 

func (t *FactorySetDeps) UnmarshalHex(data string) error

UnmarshalHex decodes FactorySetDeps from hex string (Canton MCMS format)

func (*FactorySetDeps) UnmarshalJSON 

func (t *FactorySetDeps) UnmarshalJSON(data []byte) error

type FeeCalculationInputs 

type FeeCalculationInputs struct {
	FeeToken            splice_api_token_holding_v1.InstrumentId `json:"feeToken"`
	Payload             types.TEXT                               `json:"payload"`
	ExecutorArgs        types.TEXT                               `json:"executorArgs"`
	HasTokenTransfer    types.BOOL                               `json:"hasTokenTransfer"`
	CcipReceiveGasLimit types.INT64                              `json:"ccipReceiveGasLimit"`
	CcvFeeUSDCents      types.NUMERIC                            `json:"ccvFeeUSDCents"`
	CcvGasSum           types.INT64                              `json:"ccvGasSum"`
	CcvBytesSum         types.INT64                              `json:"ccvBytesSum"`
	PoolFeeUSDCents     types.NUMERIC                            `json:"poolFeeUSDCents"`
	PoolGas             types.INT64                              `json:"poolGas"`
	PoolBytes           types.INT64                              `json:"poolBytes"`
	ExecutorFeeUSDCents types.NUMERIC                            `json:"executorFeeUSDCents"`
	HasExecutorFee      types.BOOL                               `json:"hasExecutorFee"`
}

FeeCalculationInputs is a Record type

func (FeeCalculationInputs) MarshalHex 

func (t FeeCalculationInputs) MarshalHex() (string, error)

MarshalHex encodes FeeCalculationInputs to hex string (Canton MCMS format)

func (FeeCalculationInputs) MarshalJSON 

func (t FeeCalculationInputs) MarshalJSON() ([]byte, error)

func (FeeCalculationInputs) ToMap 

func (t FeeCalculationInputs) ToMap() map[string]any

ToMap converts FeeCalculationInputs to a map for DAML arguments

func (*FeeCalculationInputs) UnmarshalHex 

func (t *FeeCalculationInputs) UnmarshalHex(data string) error

UnmarshalHex decodes FeeCalculationInputs from hex string (Canton MCMS format)

func (*FeeCalculationInputs) UnmarshalJSON 

func (t *FeeCalculationInputs) UnmarshalJSON(data []byte) error

type FeeCalculationResult 

type FeeCalculationResult struct {
	TotalFeeTokenAmount       types.NUMERIC `json:"totalFeeTokenAmount"`
	TotalUSDCents             types.NUMERIC `json:"totalUSDCents"`
	ExecutionCostUSDCents     types.NUMERIC `json:"executionCostUSDCents"`
	ExecutorDestGasLimit      types.INT64   `json:"executorDestGasLimit"`
	ExecutorDestBytesOverhead types.INT64   `json:"executorDestBytesOverhead"`
	TotalExecutionGasLimit    types.INT64   `json:"totalExecutionGasLimit"`
	PremiumMultiplier         types.NUMERIC `json:"premiumMultiplier"`
	FeeTokenPrice             types.NUMERIC `json:"feeTokenPrice"`
}

FeeCalculationResult is a Record type

func (FeeCalculationResult) MarshalHex 

func (t FeeCalculationResult) MarshalHex() (string, error)

MarshalHex encodes FeeCalculationResult to hex string (Canton MCMS format)

func (FeeCalculationResult) MarshalJSON 

func (t FeeCalculationResult) MarshalJSON() ([]byte, error)

func (FeeCalculationResult) ToMap 

func (t FeeCalculationResult) ToMap() map[string]any

ToMap converts FeeCalculationResult to a map for DAML arguments

func (*FeeCalculationResult) UnmarshalHex 

func (t *FeeCalculationResult) UnmarshalHex(data string) error

UnmarshalHex decodes FeeCalculationResult from hex string (Canton MCMS format)

func (*FeeCalculationResult) UnmarshalJSON 

func (t *FeeCalculationResult) UnmarshalJSON(data []byte) error

type FinalizeFee2 

type FinalizeFee2 struct {
	Context           splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	SendingMessageCid types.CONTRACT_ID                          `json:"sendingMessageCid"`
}

FinalizeFee2 is a Record type

func (FinalizeFee2) MarshalHex 

func (t FinalizeFee2) MarshalHex() (string, error)

MarshalHex encodes FinalizeFee2 to hex string (Canton MCMS format)

func (FinalizeFee2) MarshalJSON 

func (t FinalizeFee2) MarshalJSON() ([]byte, error)

func (FinalizeFee2) ToMap 

func (t FinalizeFee2) ToMap() map[string]any

ToMap converts FinalizeFee2 to a map for DAML arguments

func (*FinalizeFee2) UnmarshalHex 

func (t *FinalizeFee2) UnmarshalHex(data string) error

UnmarshalHex decodes FinalizeFee2 from hex string (Canton MCMS format)

func (*FinalizeFee2) UnmarshalJSON 

func (t *FinalizeFee2) UnmarshalJSON(data []byte) error

type FinalizeFeeFromRouter 

type FinalizeFeeFromRouter struct {
	RouterPartyOwner  types.PARTY       `json:"routerPartyOwner"`
	RouterInstanceId  types.TEXT        `json:"routerInstanceId"`
	GlobalConfigCid   types.CONTRACT_ID `json:"globalConfigCid"`
	FeeQuoterCid      types.CONTRACT_ID `json:"feeQuoterCid"`
	SendingMessageCid types.CONTRACT_ID `json:"sendingMessageCid"`
}

FinalizeFeeFromRouter is a Record type

func (FinalizeFeeFromRouter) MarshalHex 

func (t FinalizeFeeFromRouter) MarshalHex() (string, error)

MarshalHex encodes FinalizeFeeFromRouter to hex string (Canton MCMS format)

func (FinalizeFeeFromRouter) MarshalJSON 

func (t FinalizeFeeFromRouter) MarshalJSON() ([]byte, error)

func (FinalizeFeeFromRouter) ToMap 

func (t FinalizeFeeFromRouter) ToMap() map[string]any

ToMap converts FinalizeFeeFromRouter to a map for DAML arguments

func (*FinalizeFeeFromRouter) UnmarshalHex 

func (t *FinalizeFeeFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes FinalizeFeeFromRouter from hex string (Canton MCMS format)

func (*FinalizeFeeFromRouter) UnmarshalJSON 

func (t *FinalizeFeeFromRouter) UnmarshalJSON(data []byte) error

type GetExecutionState 

type GetExecutionState struct {
	MessageHash types.TEXT  `json:"messageHash"`
	Caller      types.PARTY `json:"caller"`
}

GetExecutionState is a Record type

func (GetExecutionState) MarshalHex 

func (t GetExecutionState) MarshalHex() (string, error)

MarshalHex encodes GetExecutionState to hex string (Canton MCMS format)

func (GetExecutionState) MarshalJSON 

func (t GetExecutionState) MarshalJSON() ([]byte, error)

func (GetExecutionState) ToMap 

func (t GetExecutionState) ToMap() map[string]any

ToMap converts GetExecutionState to a map for DAML arguments

func (*GetExecutionState) UnmarshalHex 

func (t *GetExecutionState) UnmarshalHex(data string) error

UnmarshalHex decodes GetExecutionState from hex string (Canton MCMS format)

func (*GetExecutionState) UnmarshalJSON 

func (t *GetExecutionState) UnmarshalJSON(data []byte) error

type GetExecutionStateMCMSParams 

type GetExecutionStateMCMSParams struct {
	MessageHash types.TEXT `json:"messageHash"`
}

GetExecutionStateMCMSParams is GetExecutionState without the Caller field for MCMS operationData encoding. Use this when encoding choice arguments for MCMS timelock operations.

func (GetExecutionStateMCMSParams) MarshalHex 

func (t GetExecutionStateMCMSParams) MarshalHex() (string, error)

MarshalHex encodes GetExecutionStateMCMSParams to hex string for MCMS operationData.

func (*GetExecutionStateMCMSParams) UnmarshalHex 

func (t *GetExecutionStateMCMSParams) UnmarshalHex(data string) error

UnmarshalHex decodes GetExecutionStateMCMSParams from hex string.

type GetFee 

type GetFee struct {
	Context           splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	DestChainSelector types.NUMERIC                              `json:"destChainSelector"`
	Message           core.Canton2AnyMessage                     `json:"message"`
	CcvFeeQuotes      []extensionapi.CrossChainVerifierFeeQuote  `json:"ccvFeeQuotes"`
	TokenPoolFeeQuote *extensionapi.TokenPoolFeeQuote            `json:"tokenPoolFeeQuote" hex:"optional"`
	ExecutorFeeQuote  *extensionapi.ExecutorFeeQuote             `json:"executorFeeQuote" hex:"optional"`
}

GetFee is a Record type

func (GetFee) MarshalHex 

func (t GetFee) MarshalHex() (string, error)

MarshalHex encodes GetFee to hex string (Canton MCMS format)

func (GetFee) MarshalJSON 

func (t GetFee) MarshalJSON() ([]byte, error)

func (GetFee) ToMap 

func (t GetFee) ToMap() map[string]any

ToMap converts GetFee to a map for DAML arguments

func (*GetFee) UnmarshalHex 

func (t *GetFee) UnmarshalHex(data string) error

UnmarshalHex decodes GetFee from hex string (Canton MCMS format)

func (*GetFee) UnmarshalJSON 

func (t *GetFee) UnmarshalJSON(data []byte) error

type GetFeeFromRouter 

type GetFeeFromRouter struct {
	RouterPartyOwner  types.PARTY                               `json:"routerPartyOwner"`
	RouterInstanceId  types.TEXT                                `json:"routerInstanceId"`
	GlobalConfigCid   types.CONTRACT_ID                         `json:"globalConfigCid"`
	FeeQuoterCid      types.CONTRACT_ID                         `json:"feeQuoterCid"`
	DestChainSelector types.NUMERIC                             `json:"destChainSelector"`
	Message           core.Canton2AnyMessage                    `json:"message"`
	CcvFeeQuotes      []extensionapi.CrossChainVerifierFeeQuote `json:"ccvFeeQuotes"`
	TokenPoolFeeQuote *extensionapi.TokenPoolFeeQuote           `json:"tokenPoolFeeQuote" hex:"optional"`
	ExecutorFeeQuote  *extensionapi.ExecutorFeeQuote            `json:"executorFeeQuote" hex:"optional"`
}

GetFeeFromRouter is a Record type

func (GetFeeFromRouter) MarshalHex 

func (t GetFeeFromRouter) MarshalHex() (string, error)

MarshalHex encodes GetFeeFromRouter to hex string (Canton MCMS format)

func (GetFeeFromRouter) MarshalJSON 

func (t GetFeeFromRouter) MarshalJSON() ([]byte, error)

func (GetFeeFromRouter) ToMap 

func (t GetFeeFromRouter) ToMap() map[string]any

ToMap converts GetFeeFromRouter to a map for DAML arguments

func (*GetFeeFromRouter) UnmarshalHex 

func (t *GetFeeFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes GetFeeFromRouter from hex string (Canton MCMS format)

func (*GetFeeFromRouter) UnmarshalJSON 

func (t *GetFeeFromRouter) UnmarshalJSON(data []byte) error

type GetFeeFromRouterResult 

type GetFeeFromRouterResult struct {
	FeeTokenAmount types.NUMERIC `json:"feeTokenAmount"`
}

GetFeeFromRouterResult is a Record type

func (GetFeeFromRouterResult) MarshalHex 

func (t GetFeeFromRouterResult) MarshalHex() (string, error)

MarshalHex encodes GetFeeFromRouterResult to hex string (Canton MCMS format)

func (GetFeeFromRouterResult) MarshalJSON 

func (t GetFeeFromRouterResult) MarshalJSON() ([]byte, error)

func (GetFeeFromRouterResult) ToMap 

func (t GetFeeFromRouterResult) ToMap() map[string]any

ToMap converts GetFeeFromRouterResult to a map for DAML arguments

func (*GetFeeFromRouterResult) UnmarshalHex 

func (t *GetFeeFromRouterResult) UnmarshalHex(data string) error

UnmarshalHex decodes GetFeeFromRouterResult from hex string (Canton MCMS format)

func (*GetFeeFromRouterResult) UnmarshalJSON 

func (t *GetFeeFromRouterResult) UnmarshalJSON(data []byte) error

type GetRequiredCCVsForExecute 

type GetRequiredCCVsForExecute struct {
	Context                   splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	Message                   core.MessageV1                             `json:"message"`
	ReceiverRequiredCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverRequiredCCVs"`
	ReceiverOptionalCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverOptionalCCVs"`
	ReceiverOptionalThreshold types.INT64                                `json:"receiverOptionalThreshold"`
	TokenPoolRequiredCCVs     []chainlinkapi.RawInstanceAddress          `json:"tokenPoolRequiredCCVs"`
}

GetRequiredCCVsForExecute is a Record type

func (GetRequiredCCVsForExecute) MarshalHex 

func (t GetRequiredCCVsForExecute) MarshalHex() (string, error)

MarshalHex encodes GetRequiredCCVsForExecute to hex string (Canton MCMS format)

func (GetRequiredCCVsForExecute) MarshalJSON 

func (t GetRequiredCCVsForExecute) MarshalJSON() ([]byte, error)

func (GetRequiredCCVsForExecute) ToMap 

func (t GetRequiredCCVsForExecute) ToMap() map[string]any

ToMap converts GetRequiredCCVsForExecute to a map for DAML arguments

func (*GetRequiredCCVsForExecute) UnmarshalHex 

func (t *GetRequiredCCVsForExecute) UnmarshalHex(data string) error

UnmarshalHex decodes GetRequiredCCVsForExecute from hex string (Canton MCMS format)

func (*GetRequiredCCVsForExecute) UnmarshalJSON 

func (t *GetRequiredCCVsForExecute) UnmarshalJSON(data []byte) error

type GetRequiredCCVsForExecuteFromRouter 

type GetRequiredCCVsForExecuteFromRouter struct {
	GlobalConfigCid           types.CONTRACT_ID                 `json:"globalConfigCid"`
	Message                   core.MessageV1                    `json:"message"`
	ReceiverRequiredCCVs      []chainlinkapi.RawInstanceAddress `json:"receiverRequiredCCVs"`
	ReceiverOptionalCCVs      []chainlinkapi.RawInstanceAddress `json:"receiverOptionalCCVs"`
	ReceiverOptionalThreshold types.INT64                       `json:"receiverOptionalThreshold"`
	TokenPoolRequiredCCVs     []chainlinkapi.RawInstanceAddress `json:"tokenPoolRequiredCCVs"`
}

GetRequiredCCVsForExecuteFromRouter is a Record type

func (GetRequiredCCVsForExecuteFromRouter) MarshalHex 

func (t GetRequiredCCVsForExecuteFromRouter) MarshalHex() (string, error)

MarshalHex encodes GetRequiredCCVsForExecuteFromRouter to hex string (Canton MCMS format)

func (GetRequiredCCVsForExecuteFromRouter) MarshalJSON 

func (t GetRequiredCCVsForExecuteFromRouter) MarshalJSON() ([]byte, error)

func (GetRequiredCCVsForExecuteFromRouter) ToMap 

func (t GetRequiredCCVsForExecuteFromRouter) ToMap() map[string]any

ToMap converts GetRequiredCCVsForExecuteFromRouter to a map for DAML arguments

func (*GetRequiredCCVsForExecuteFromRouter) UnmarshalHex 

func (t *GetRequiredCCVsForExecuteFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes GetRequiredCCVsForExecuteFromRouter from hex string (Canton MCMS format)

func (*GetRequiredCCVsForExecuteFromRouter) UnmarshalJSON 

func (t *GetRequiredCCVsForExecuteFromRouter) UnmarshalJSON(data []byte) error

type GetRequiredCCVsForSend 

type GetRequiredCCVsForSend struct {
	Context           splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	DestChainSelector types.NUMERIC                              `json:"destChainSelector"`
	Message           core.Canton2AnyMessage                     `json:"message"`
	PoolReportedCCVs  []chainlinkapi.RawInstanceAddress          `json:"poolReportedCCVs"`
}

GetRequiredCCVsForSend is a Record type

func (GetRequiredCCVsForSend) MarshalHex 

func (t GetRequiredCCVsForSend) MarshalHex() (string, error)

MarshalHex encodes GetRequiredCCVsForSend to hex string (Canton MCMS format)

func (GetRequiredCCVsForSend) MarshalJSON 

func (t GetRequiredCCVsForSend) MarshalJSON() ([]byte, error)

func (GetRequiredCCVsForSend) ToMap 

func (t GetRequiredCCVsForSend) ToMap() map[string]any

ToMap converts GetRequiredCCVsForSend to a map for DAML arguments

func (*GetRequiredCCVsForSend) UnmarshalHex 

func (t *GetRequiredCCVsForSend) UnmarshalHex(data string) error

UnmarshalHex decodes GetRequiredCCVsForSend from hex string (Canton MCMS format)

func (*GetRequiredCCVsForSend) UnmarshalJSON 

func (t *GetRequiredCCVsForSend) UnmarshalJSON(data []byte) error

type GetRequiredCCVsForSendFromRouter 

type GetRequiredCCVsForSendFromRouter struct {
	GlobalConfigCid   types.CONTRACT_ID                 `json:"globalConfigCid"`
	DestChainSelector types.NUMERIC                     `json:"destChainSelector"`
	Message           core.Canton2AnyMessage            `json:"message"`
	PoolReportedCCVs  []chainlinkapi.RawInstanceAddress `json:"poolReportedCCVs"`
}

GetRequiredCCVsForSendFromRouter is a Record type

func (GetRequiredCCVsForSendFromRouter) MarshalHex 

func (t GetRequiredCCVsForSendFromRouter) MarshalHex() (string, error)

MarshalHex encodes GetRequiredCCVsForSendFromRouter to hex string (Canton MCMS format)

func (GetRequiredCCVsForSendFromRouter) MarshalJSON 

func (t GetRequiredCCVsForSendFromRouter) MarshalJSON() ([]byte, error)

func (GetRequiredCCVsForSendFromRouter) ToMap 

func (t GetRequiredCCVsForSendFromRouter) ToMap() map[string]any

ToMap converts GetRequiredCCVsForSendFromRouter to a map for DAML arguments

func (*GetRequiredCCVsForSendFromRouter) UnmarshalHex 

func (t *GetRequiredCCVsForSendFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes GetRequiredCCVsForSendFromRouter from hex string (Canton MCMS format)

func (*GetRequiredCCVsForSendFromRouter) UnmarshalJSON 

func (t *GetRequiredCCVsForSendFromRouter) UnmarshalJSON(data []byte) error

type GetSequenceNumber 

type GetSequenceNumber struct {
	DestChainSelector types.NUMERIC `json:"destChainSelector"`
}

GetSequenceNumber is a Record type

func (GetSequenceNumber) MarshalHex 

func (t GetSequenceNumber) MarshalHex() (string, error)

MarshalHex encodes GetSequenceNumber to hex string (Canton MCMS format)

func (GetSequenceNumber) MarshalJSON 

func (t GetSequenceNumber) MarshalJSON() ([]byte, error)

func (GetSequenceNumber) ToMap 

func (t GetSequenceNumber) ToMap() map[string]any

ToMap converts GetSequenceNumber to a map for DAML arguments

func (*GetSequenceNumber) UnmarshalHex 

func (t *GetSequenceNumber) UnmarshalHex(data string) error

UnmarshalHex decodes GetSequenceNumber from hex string (Canton MCMS format)

func (*GetSequenceNumber) UnmarshalJSON 

func (t *GetSequenceNumber) UnmarshalJSON(data []byte) error

type HasRouter 

type HasRouter struct {
	PartyOwner types.PARTY `json:"partyOwner"`
	Caller     types.PARTY `json:"caller"`
}

HasRouter is a Record type

func (HasRouter) MarshalHex 

func (t HasRouter) MarshalHex() (string, error)

MarshalHex encodes HasRouter to hex string (Canton MCMS format)

func (HasRouter) MarshalJSON 

func (t HasRouter) MarshalJSON() ([]byte, error)

func (HasRouter) ToMap 

func (t HasRouter) ToMap() map[string]any

ToMap converts HasRouter to a map for DAML arguments

func (*HasRouter) UnmarshalHex 

func (t *HasRouter) UnmarshalHex(data string) error

UnmarshalHex decodes HasRouter from hex string (Canton MCMS format)

func (*HasRouter) UnmarshalJSON 

func (t *HasRouter) UnmarshalJSON(data []byte) error

type HasRouterMCMSParams 

type HasRouterMCMSParams struct {
	PartyOwner types.PARTY `json:"partyOwner"`
}

HasRouterMCMSParams is HasRouter without the Caller field for MCMS operationData encoding. Use this when encoding choice arguments for MCMS timelock operations.

func (HasRouterMCMSParams) MarshalHex 

func (t HasRouterMCMSParams) MarshalHex() (string, error)

MarshalHex encodes HasRouterMCMSParams to hex string for MCMS operationData.

func (*HasRouterMCMSParams) UnmarshalHex 

func (t *HasRouterMCMSParams) UnmarshalHex(data string) error

UnmarshalHex decodes HasRouterMCMSParams from hex string.

type IsExecuted 

type IsExecuted struct {
	MessageHash types.TEXT `json:"messageHash"`
}

IsExecuted is a Record type

func (IsExecuted) MarshalHex 

func (t IsExecuted) MarshalHex() (string, error)

MarshalHex encodes IsExecuted to hex string (Canton MCMS format)

func (IsExecuted) MarshalJSON 

func (t IsExecuted) MarshalJSON() ([]byte, error)

func (IsExecuted) ToMap 

func (t IsExecuted) ToMap() map[string]any

ToMap converts IsExecuted to a map for DAML arguments

func (*IsExecuted) UnmarshalHex 

func (t *IsExecuted) UnmarshalHex(data string) error

UnmarshalHex decodes IsExecuted from hex string (Canton MCMS format)

func (*IsExecuted) UnmarshalJSON 

func (t *IsExecuted) UnmarshalJSON(data []byte) error

type MCMSEncoder 

type MCMSEncoder interface {
	AddCustomObservers(args AddCustomObservers2) (*bind.EncodedChoice, error)
	AddCustomObserversParams(args AddCustomObserversParams2) (*bind.EncodedChoice, error)
	CCIPSend(args CCIPSend) (*bind.EncodedChoice, error)
	CCIPSendFromRouter(args CCIPSendFromRouter) (*bind.EncodedChoice, error)
	CreateRouter(args CreateRouter) (*bind.EncodedChoice, error)
	Execute(args Execute) (*bind.EncodedChoice, error)
	ExecuteFromRouter(args ExecuteFromRouter) (*bind.EncodedChoice, error)
	FactorySetDeps(args FactorySetDeps) (*bind.EncodedChoice, error)
	FinalizeFee(args FinalizeFee2) (*bind.EncodedChoice, error)
	FinalizeFeeFromRouter(args FinalizeFeeFromRouter) (*bind.EncodedChoice, error)
	GetExecutionState(args GetExecutionState) (*bind.EncodedChoice, error)
	GetExecutionStateMCMSParams(args GetExecutionStateMCMSParams) (*bind.EncodedChoice, error)
	GetFee(args GetFee) (*bind.EncodedChoice, error)
	GetFeeFromRouter(args GetFeeFromRouter) (*bind.EncodedChoice, error)
	GetRequiredCCVsForExecute(args GetRequiredCCVsForExecute) (*bind.EncodedChoice, error)
	GetRequiredCCVsForExecuteFromRouter(args GetRequiredCCVsForExecuteFromRouter) (*bind.EncodedChoice, error)
	GetRequiredCCVsForSend(args GetRequiredCCVsForSend) (*bind.EncodedChoice, error)
	GetRequiredCCVsForSendFromRouter(args GetRequiredCCVsForSendFromRouter) (*bind.EncodedChoice, error)
	GetSequenceNumber(args GetSequenceNumber) (*bind.EncodedChoice, error)
	HasRouter(args HasRouter) (*bind.EncodedChoice, error)
	HasRouterMCMSParams(args HasRouterMCMSParams) (*bind.EncodedChoice, error)
	IsExecuted(args IsExecuted) (*bind.EncodedChoice, error)
	PrepareExecute(args PrepareExecute) (*bind.EncodedChoice, error)
	PrepareExecuteMCMSParams(args PrepareExecuteMCMSParams) (*bind.EncodedChoice, error)
	PrepareSend(args PrepareSend) (*bind.EncodedChoice, error)
	PrepareSendFromRouter(args PrepareSendFromRouter) (*bind.EncodedChoice, error)
	RemoveCustomObservers(args RemoveCustomObservers2) (*bind.EncodedChoice, error)
	RemoveCustomObserversParams(args RemoveCustomObserversParams2) (*bind.EncodedChoice, error)
	SetDeps(args SetDeps) (*bind.EncodedChoice, error)
	SetDepsParams(args SetDepsParams) (*bind.EncodedChoice, error)
}

MCMSEncoder interface for typed encoding methods. Implemented by Encoder for method-based encoding.

type OffRamp 

type OffRamp struct {
	InstanceId types.TEXT  `json:"instanceId"`
	CcipOwner  types.PARTY `json:"ccipOwner"`
	Deps       OffRampDeps `json:"deps"`
}

OffRamp is a Template type

func (OffRamp) Archive 

func (t OffRamp) Archive(contractID string) *model.ExerciseCommand

Archive exercises the Archive choice on this OffRamp contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (OffRamp) ArchiveWithPackageID 

func (t OffRamp) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand

ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name

func (OffRamp) CreateCommand 

func (t OffRamp) CreateCommand() *model.CreateCommand

CreateCommand returns a CreateCommand for this template using the package name

func (OffRamp) CreateCommandWithPackageID 

func (t OffRamp) CreateCommandWithPackageID(packageID string) *model.CreateCommand

CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name

func (OffRamp) ExecuteFromRouter 

func (t OffRamp) ExecuteFromRouter(contractID string, args ExecuteFromRouter) *model.ExerciseCommand

ExecuteFromRouter exercises the ExecuteFromRouter choice on this OffRamp contract This method uses the package name in the template ID

func (OffRamp) ExecuteFromRouterWithPackageID 

func (t OffRamp) ExecuteFromRouterWithPackageID(contractID string, packageID string, args ExecuteFromRouter) *model.ExerciseCommand

ExecuteFromRouterWithPackageID exercises the ExecuteFromRouter choice using the provided package ID instead of package name

func (OffRamp) GetRequiredCCVsForExecuteFromRouter 

func (t OffRamp) GetRequiredCCVsForExecuteFromRouter(contractID string, args GetRequiredCCVsForExecuteFromRouter) *model.ExerciseCommand

GetRequiredCCVsForExecuteFromRouter exercises the GetRequiredCCVsForExecuteFromRouter choice on this OffRamp contract This method uses the package name in the template ID

func (OffRamp) GetRequiredCCVsForExecuteFromRouterWithPackageID 

func (t OffRamp) GetRequiredCCVsForExecuteFromRouterWithPackageID(contractID string, packageID string, args GetRequiredCCVsForExecuteFromRouter) *model.ExerciseCommand

GetRequiredCCVsForExecuteFromRouterWithPackageID exercises the GetRequiredCCVsForExecuteFromRouter choice using the provided package ID instead of package name

func (OffRamp) GetTemplateID 

func (t OffRamp) GetTemplateID() string

GetTemplateID returns the template ID for this template using the package name

func (OffRamp) GetTemplateIDWithPackageID 

func (t OffRamp) GetTemplateIDWithPackageID(packageID string) string

GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name

func (OffRamp) MCMSReceiverEntrypoint 

func (t OffRamp) MCMSReceiverEntrypoint(contractID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypoint exercises the MCMSReceiver_Entrypoint choice on this OffRamp contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (OffRamp) MCMSReceiverEntrypointWithPackageID 

func (t OffRamp) MCMSReceiverEntrypointWithPackageID(contractID string, packageID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypointWithPackageID exercises the MCMSReceiver_Entrypoint choice using the provided package ID instead of package name

func (OffRamp) MarshalHex 

func (t OffRamp) MarshalHex() (string, error)

MarshalHex encodes OffRamp to hex string (Canton MCMS format)

func (OffRamp) MarshalJSON 

func (t OffRamp) MarshalJSON() ([]byte, error)

func (OffRamp) PrepareExecute 

func (t OffRamp) PrepareExecute(contractID string, args PrepareExecute) *model.ExerciseCommand

PrepareExecute exercises the PrepareExecute choice on this OffRamp contract This method uses the package name in the template ID

func (OffRamp) PrepareExecuteWithPackageID 

func (t OffRamp) PrepareExecuteWithPackageID(contractID string, packageID string, args PrepareExecute) *model.ExerciseCommand

PrepareExecuteWithPackageID exercises the PrepareExecute choice using the provided package ID instead of package name

func (OffRamp) SetDeps 

func (t OffRamp) SetDeps(contractID string, args SetDeps) *model.ExerciseCommand

SetDeps exercises the SetDeps choice on this OffRamp contract This method uses the package name in the template ID

func (OffRamp) SetDepsWithPackageID 

func (t OffRamp) SetDepsWithPackageID(contractID string, packageID string, args SetDeps) *model.ExerciseCommand

SetDepsWithPackageID exercises the SetDeps choice using the provided package ID instead of package name

func (*OffRamp) UnmarshalHex 

func (t *OffRamp) UnmarshalHex(data string) error

UnmarshalHex decodes OffRamp from hex string (Canton MCMS format)

func (*OffRamp) UnmarshalJSON 

func (t *OffRamp) UnmarshalJSON(data []byte) error

type OffRampDeps 

type OffRampDeps struct {
	GlobalConfig       chainlinkapi.RawInstanceAddress `json:"globalConfig"`
	RmnRemote          chainlinkapi.RawInstanceAddress `json:"rmnRemote"`
	TokenAdminRegistry chainlinkapi.RawInstanceAddress `json:"tokenAdminRegistry"`
}

OffRampDeps is a Record type

func (OffRampDeps) MarshalHex 

func (t OffRampDeps) MarshalHex() (string, error)

MarshalHex encodes OffRampDeps to hex string (Canton MCMS format)

func (OffRampDeps) MarshalJSON 

func (t OffRampDeps) MarshalJSON() ([]byte, error)

func (OffRampDeps) ToMap 

func (t OffRampDeps) ToMap() map[string]any

ToMap converts OffRampDeps to a map for DAML arguments

func (*OffRampDeps) UnmarshalHex 

func (t *OffRampDeps) UnmarshalHex(data string) error

UnmarshalHex decodes OffRampDeps from hex string (Canton MCMS format)

func (*OffRampDeps) UnmarshalJSON 

func (t *OffRampDeps) UnmarshalJSON(data []byte) error

type OnRamp 

type OnRamp struct {
	InstanceId        types.TEXT    `json:"instanceId"`
	CcipOwner         types.PARTY   `json:"ccipOwner"`
	MaxUSDCentsPerMsg types.NUMERIC `json:"maxUSDCentsPerMsg"`
	Deps              OnRampDeps    `json:"deps"`
}

OnRamp is a Template type

func (OnRamp) Archive 

func (t OnRamp) Archive(contractID string) *model.ExerciseCommand

Archive exercises the Archive choice on this OnRamp contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (OnRamp) ArchiveWithPackageID 

func (t OnRamp) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand

ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name

func (OnRamp) CCIPSendFromRouter 

func (t OnRamp) CCIPSendFromRouter(contractID string, args CCIPSendFromRouter) *model.ExerciseCommand

CCIPSendFromRouter exercises the CCIPSendFromRouter choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) CCIPSendFromRouterWithPackageID 

func (t OnRamp) CCIPSendFromRouterWithPackageID(contractID string, packageID string, args CCIPSendFromRouter) *model.ExerciseCommand

CCIPSendFromRouterWithPackageID exercises the CCIPSendFromRouter choice using the provided package ID instead of package name

func (OnRamp) CreateCommand 

func (t OnRamp) CreateCommand() *model.CreateCommand

CreateCommand returns a CreateCommand for this template using the package name

func (OnRamp) CreateCommandWithPackageID 

func (t OnRamp) CreateCommandWithPackageID(packageID string) *model.CreateCommand

CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name

func (OnRamp) FinalizeFeeFromRouter 

func (t OnRamp) FinalizeFeeFromRouter(contractID string, args FinalizeFeeFromRouter) *model.ExerciseCommand

FinalizeFeeFromRouter exercises the FinalizeFeeFromRouter choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) FinalizeFeeFromRouterWithPackageID 

func (t OnRamp) FinalizeFeeFromRouterWithPackageID(contractID string, packageID string, args FinalizeFeeFromRouter) *model.ExerciseCommand

FinalizeFeeFromRouterWithPackageID exercises the FinalizeFeeFromRouter choice using the provided package ID instead of package name

func (OnRamp) GetFeeFromRouter 

func (t OnRamp) GetFeeFromRouter(contractID string, args GetFeeFromRouter) *model.ExerciseCommand

GetFeeFromRouter exercises the GetFeeFromRouter choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) GetFeeFromRouterWithPackageID 

func (t OnRamp) GetFeeFromRouterWithPackageID(contractID string, packageID string, args GetFeeFromRouter) *model.ExerciseCommand

GetFeeFromRouterWithPackageID exercises the GetFeeFromRouter choice using the provided package ID instead of package name

func (OnRamp) GetRequiredCCVsForSendFromRouter 

func (t OnRamp) GetRequiredCCVsForSendFromRouter(contractID string, args GetRequiredCCVsForSendFromRouter) *model.ExerciseCommand

GetRequiredCCVsForSendFromRouter exercises the GetRequiredCCVsForSendFromRouter choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) GetRequiredCCVsForSendFromRouterWithPackageID 

func (t OnRamp) GetRequiredCCVsForSendFromRouterWithPackageID(contractID string, packageID string, args GetRequiredCCVsForSendFromRouter) *model.ExerciseCommand

GetRequiredCCVsForSendFromRouterWithPackageID exercises the GetRequiredCCVsForSendFromRouter choice using the provided package ID instead of package name

func (OnRamp) GetTemplateID 

func (t OnRamp) GetTemplateID() string

GetTemplateID returns the template ID for this template using the package name

func (OnRamp) GetTemplateIDWithPackageID 

func (t OnRamp) GetTemplateIDWithPackageID(packageID string) string

GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name

func (OnRamp) MCMSReceiverEntrypoint 

func (t OnRamp) MCMSReceiverEntrypoint(contractID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypoint exercises the MCMSReceiver_Entrypoint choice on this OnRamp contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (OnRamp) MCMSReceiverEntrypointWithPackageID 

func (t OnRamp) MCMSReceiverEntrypointWithPackageID(contractID string, packageID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypointWithPackageID exercises the MCMSReceiver_Entrypoint choice using the provided package ID instead of package name

func (OnRamp) MarshalHex 

func (t OnRamp) MarshalHex() (string, error)

MarshalHex encodes OnRamp to hex string (Canton MCMS format)

func (OnRamp) MarshalJSON 

func (t OnRamp) MarshalJSON() ([]byte, error)

func (OnRamp) PrepareSendFromRouter 

func (t OnRamp) PrepareSendFromRouter(contractID string, args PrepareSendFromRouter) *model.ExerciseCommand

PrepareSendFromRouter exercises the PrepareSendFromRouter choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) PrepareSendFromRouterWithPackageID 

func (t OnRamp) PrepareSendFromRouterWithPackageID(contractID string, packageID string, args PrepareSendFromRouter) *model.ExerciseCommand

PrepareSendFromRouterWithPackageID exercises the PrepareSendFromRouter choice using the provided package ID instead of package name

func (OnRamp) SetDeps 

func (t OnRamp) SetDeps(contractID string, args SetDeps) *model.ExerciseCommand

SetDeps exercises the SetDeps choice on this OnRamp contract This method uses the package name in the template ID

func (OnRamp) SetDepsWithPackageID 

func (t OnRamp) SetDepsWithPackageID(contractID string, packageID string, args SetDeps) *model.ExerciseCommand

SetDepsWithPackageID exercises the SetDeps choice using the provided package ID instead of package name

func (*OnRamp) UnmarshalHex 

func (t *OnRamp) UnmarshalHex(data string) error

UnmarshalHex decodes OnRamp from hex string (Canton MCMS format)

func (*OnRamp) UnmarshalJSON 

func (t *OnRamp) UnmarshalJSON(data []byte) error

type OnRampDeps 

type OnRampDeps struct {
	GlobalConfig       chainlinkapi.RawInstanceAddress `json:"globalConfig"`
	RmnRemote          chainlinkapi.RawInstanceAddress `json:"rmnRemote"`
	TokenAdminRegistry chainlinkapi.RawInstanceAddress `json:"tokenAdminRegistry"`
	FeeQuoter          chainlinkapi.RawInstanceAddress `json:"feeQuoter"`
	CcvRegistry        chainlinkapi.RawInstanceAddress `json:"ccvRegistry"`
}

OnRampDeps is a Record type

func (OnRampDeps) MarshalHex 

func (t OnRampDeps) MarshalHex() (string, error)

MarshalHex encodes OnRampDeps to hex string (Canton MCMS format)

func (OnRampDeps) MarshalJSON 

func (t OnRampDeps) MarshalJSON() ([]byte, error)

func (OnRampDeps) ToMap 

func (t OnRampDeps) ToMap() map[string]any

ToMap converts OnRampDeps to a map for DAML arguments

func (*OnRampDeps) UnmarshalHex 

func (t *OnRampDeps) UnmarshalHex(data string) error

UnmarshalHex decodes OnRampDeps from hex string (Canton MCMS format)

func (*OnRampDeps) UnmarshalJSON 

func (t *OnRampDeps) UnmarshalJSON(data []byte) error

type PerPartyRouter 

type PerPartyRouter struct {
	InstanceId                   types.TEXT                      `json:"instanceId"`
	CcipOwner                    types.PARTY                     `json:"ccipOwner"`
	PartyOwner                   types.PARTY                     `json:"partyOwner"`
	Deps                         PerPartyRouterDeps              `json:"deps"`
	OutboundSequenceNumbers      map[types.NUMERIC]types.NUMERIC `json:"outboundSequenceNumbers"`
	ExecutedMessages             types.SET                       `json:"executedMessages"`
	ArchivedExecutionContractIds []types.CONTRACT_ID             `json:"archivedExecutionContractIds"`
	CustomObservers              []types.PARTY                   `json:"customObservers"`
}

PerPartyRouter is a Template type

func (PerPartyRouter) AddCustomObservers 

func (t PerPartyRouter) AddCustomObservers(contractID string, args AddCustomObservers2) *model.ExerciseCommand

AddCustomObservers exercises the AddCustomObservers choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) AddCustomObserversWithPackageID 

func (t PerPartyRouter) AddCustomObserversWithPackageID(contractID string, packageID string, args AddCustomObservers2) *model.ExerciseCommand

AddCustomObserversWithPackageID exercises the AddCustomObservers choice using the provided package ID instead of package name

func (PerPartyRouter) Archive 

func (t PerPartyRouter) Archive(contractID string) *model.ExerciseCommand

Archive exercises the Archive choice on this PerPartyRouter contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (PerPartyRouter) ArchiveWithPackageID 

func (t PerPartyRouter) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand

ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name

func (PerPartyRouter) CCIPSend 

func (t PerPartyRouter) CCIPSend(contractID string, args CCIPSend) *model.ExerciseCommand

CCIPSend exercises the CCIPSend choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) CCIPSendWithPackageID 

func (t PerPartyRouter) CCIPSendWithPackageID(contractID string, packageID string, args CCIPSend) *model.ExerciseCommand

CCIPSendWithPackageID exercises the CCIPSend choice using the provided package ID instead of package name

func (PerPartyRouter) CreateCommand 

func (t PerPartyRouter) CreateCommand() *model.CreateCommand

CreateCommand returns a CreateCommand for this template using the package name

func (PerPartyRouter) CreateCommandWithPackageID 

func (t PerPartyRouter) CreateCommandWithPackageID(packageID string) *model.CreateCommand

CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name

func (PerPartyRouter) Execute 

func (t PerPartyRouter) Execute(contractID string, args Execute) *model.ExerciseCommand

Execute exercises the Execute choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) ExecuteWithPackageID 

func (t PerPartyRouter) ExecuteWithPackageID(contractID string, packageID string, args Execute) *model.ExerciseCommand

ExecuteWithPackageID exercises the Execute choice using the provided package ID instead of package name

func (PerPartyRouter) FinalizeFee 

func (t PerPartyRouter) FinalizeFee(contractID string, args FinalizeFee2) *model.ExerciseCommand

FinalizeFee exercises the FinalizeFee choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) FinalizeFeeWithPackageID 

func (t PerPartyRouter) FinalizeFeeWithPackageID(contractID string, packageID string, args FinalizeFee2) *model.ExerciseCommand

FinalizeFeeWithPackageID exercises the FinalizeFee choice using the provided package ID instead of package name

func (PerPartyRouter) GetExecutionState 

func (t PerPartyRouter) GetExecutionState(contractID string, args GetExecutionState) *model.ExerciseCommand

GetExecutionState exercises the GetExecutionState choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) GetExecutionStateWithPackageID 

func (t PerPartyRouter) GetExecutionStateWithPackageID(contractID string, packageID string, args GetExecutionState) *model.ExerciseCommand

GetExecutionStateWithPackageID exercises the GetExecutionState choice using the provided package ID instead of package name

func (PerPartyRouter) GetFee 

func (t PerPartyRouter) GetFee(contractID string, args GetFee) *model.ExerciseCommand

GetFee exercises the GetFee choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) GetFeeWithPackageID 

func (t PerPartyRouter) GetFeeWithPackageID(contractID string, packageID string, args GetFee) *model.ExerciseCommand

GetFeeWithPackageID exercises the GetFee choice using the provided package ID instead of package name

func (PerPartyRouter) GetRequiredCCVsForExecute 

func (t PerPartyRouter) GetRequiredCCVsForExecute(contractID string, args GetRequiredCCVsForExecute) *model.ExerciseCommand

GetRequiredCCVsForExecute exercises the GetRequiredCCVsForExecute choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) GetRequiredCCVsForExecuteWithPackageID 

func (t PerPartyRouter) GetRequiredCCVsForExecuteWithPackageID(contractID string, packageID string, args GetRequiredCCVsForExecute) *model.ExerciseCommand

GetRequiredCCVsForExecuteWithPackageID exercises the GetRequiredCCVsForExecute choice using the provided package ID instead of package name

func (PerPartyRouter) GetRequiredCCVsForSend 

func (t PerPartyRouter) GetRequiredCCVsForSend(contractID string, args GetRequiredCCVsForSend) *model.ExerciseCommand

GetRequiredCCVsForSend exercises the GetRequiredCCVsForSend choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) GetRequiredCCVsForSendWithPackageID 

func (t PerPartyRouter) GetRequiredCCVsForSendWithPackageID(contractID string, packageID string, args GetRequiredCCVsForSend) *model.ExerciseCommand

GetRequiredCCVsForSendWithPackageID exercises the GetRequiredCCVsForSend choice using the provided package ID instead of package name

func (PerPartyRouter) GetSequenceNumber 

func (t PerPartyRouter) GetSequenceNumber(contractID string, args GetSequenceNumber) *model.ExerciseCommand

GetSequenceNumber exercises the GetSequenceNumber choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) GetSequenceNumberWithPackageID 

func (t PerPartyRouter) GetSequenceNumberWithPackageID(contractID string, packageID string, args GetSequenceNumber) *model.ExerciseCommand

GetSequenceNumberWithPackageID exercises the GetSequenceNumber choice using the provided package ID instead of package name

func (PerPartyRouter) GetTemplateID 

func (t PerPartyRouter) GetTemplateID() string

GetTemplateID returns the template ID for this template using the package name

func (PerPartyRouter) GetTemplateIDWithPackageID 

func (t PerPartyRouter) GetTemplateIDWithPackageID(packageID string) string

GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name

func (PerPartyRouter) MCMSReceiverEntrypoint 

func (t PerPartyRouter) MCMSReceiverEntrypoint(contractID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypoint exercises the MCMSReceiver_Entrypoint choice on this PerPartyRouter contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (PerPartyRouter) MCMSReceiverEntrypointWithPackageID 

func (t PerPartyRouter) MCMSReceiverEntrypointWithPackageID(contractID string, packageID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypointWithPackageID exercises the MCMSReceiver_Entrypoint choice using the provided package ID instead of package name

func (PerPartyRouter) MarshalHex 

func (t PerPartyRouter) MarshalHex() (string, error)

MarshalHex encodes PerPartyRouter to hex string (Canton MCMS format)

func (PerPartyRouter) MarshalJSON 

func (t PerPartyRouter) MarshalJSON() ([]byte, error)

func (PerPartyRouter) PrepareExecute 

func (t PerPartyRouter) PrepareExecute(contractID string, args PrepareExecute) *model.ExerciseCommand

PrepareExecute exercises the PrepareExecute choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) PrepareExecuteWithPackageID 

func (t PerPartyRouter) PrepareExecuteWithPackageID(contractID string, packageID string, args PrepareExecute) *model.ExerciseCommand

PrepareExecuteWithPackageID exercises the PrepareExecute choice using the provided package ID instead of package name

func (PerPartyRouter) PrepareSend 

func (t PerPartyRouter) PrepareSend(contractID string, args PrepareSend) *model.ExerciseCommand

PrepareSend exercises the PrepareSend choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) PrepareSendWithPackageID 

func (t PerPartyRouter) PrepareSendWithPackageID(contractID string, packageID string, args PrepareSend) *model.ExerciseCommand

PrepareSendWithPackageID exercises the PrepareSend choice using the provided package ID instead of package name

func (PerPartyRouter) RemoveCustomObservers 

func (t PerPartyRouter) RemoveCustomObservers(contractID string, args RemoveCustomObservers2) *model.ExerciseCommand

RemoveCustomObservers exercises the RemoveCustomObservers choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) RemoveCustomObserversWithPackageID 

func (t PerPartyRouter) RemoveCustomObserversWithPackageID(contractID string, packageID string, args RemoveCustomObservers2) *model.ExerciseCommand

RemoveCustomObserversWithPackageID exercises the RemoveCustomObservers choice using the provided package ID instead of package name

func (PerPartyRouter) SetDeps 

func (t PerPartyRouter) SetDeps(contractID string, args SetDeps) *model.ExerciseCommand

SetDeps exercises the SetDeps choice on this PerPartyRouter contract This method uses the package name in the template ID

func (PerPartyRouter) SetDepsWithPackageID 

func (t PerPartyRouter) SetDepsWithPackageID(contractID string, packageID string, args SetDeps) *model.ExerciseCommand

SetDepsWithPackageID exercises the SetDeps choice using the provided package ID instead of package name

func (*PerPartyRouter) UnmarshalHex 

func (t *PerPartyRouter) UnmarshalHex(data string) error

UnmarshalHex decodes PerPartyRouter from hex string (Canton MCMS format)

func (*PerPartyRouter) UnmarshalJSON 

func (t *PerPartyRouter) UnmarshalJSON(data []byte) error

type PerPartyRouterDeps 

type PerPartyRouterDeps struct {
	OnRamp             chainlinkapi.RawInstanceAddress `json:"onRamp"`
	OffRamp            chainlinkapi.RawInstanceAddress `json:"offRamp"`
	GlobalConfig       chainlinkapi.RawInstanceAddress `json:"globalConfig"`
	TokenAdminRegistry chainlinkapi.RawInstanceAddress `json:"tokenAdminRegistry"`
	FeeQuoter          chainlinkapi.RawInstanceAddress `json:"feeQuoter"`
	RmnRemote          chainlinkapi.RawInstanceAddress `json:"rmnRemote"`
}

PerPartyRouterDeps is a Record type

func (PerPartyRouterDeps) MarshalHex 

func (t PerPartyRouterDeps) MarshalHex() (string, error)

MarshalHex encodes PerPartyRouterDeps to hex string (Canton MCMS format)

func (PerPartyRouterDeps) MarshalJSON 

func (t PerPartyRouterDeps) MarshalJSON() ([]byte, error)

func (PerPartyRouterDeps) ToMap 

func (t PerPartyRouterDeps) ToMap() map[string]any

ToMap converts PerPartyRouterDeps to a map for DAML arguments

func (*PerPartyRouterDeps) UnmarshalHex 

func (t *PerPartyRouterDeps) UnmarshalHex(data string) error

UnmarshalHex decodes PerPartyRouterDeps from hex string (Canton MCMS format)

func (*PerPartyRouterDeps) UnmarshalJSON 

func (t *PerPartyRouterDeps) UnmarshalJSON(data []byte) error

type PerPartyRouterFactory 

type PerPartyRouterFactory struct {
	InstanceId        types.TEXT                 `json:"instanceId"`
	CcipOwner         types.PARTY                `json:"ccipOwner"`
	Deps              PerPartyRouterDeps         `json:"deps"`
	RegisteredRouters map[types.PARTY]types.TEXT `json:"registeredRouters"`
}

PerPartyRouterFactory is a Template type

func (PerPartyRouterFactory) Archive 

func (t PerPartyRouterFactory) Archive(contractID string) *model.ExerciseCommand

Archive exercises the Archive choice on this PerPartyRouterFactory contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (PerPartyRouterFactory) ArchiveWithPackageID 

func (t PerPartyRouterFactory) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand

ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name

func (PerPartyRouterFactory) CreateCommand 

func (t PerPartyRouterFactory) CreateCommand() *model.CreateCommand

CreateCommand returns a CreateCommand for this template using the package name

func (PerPartyRouterFactory) CreateCommandWithPackageID 

func (t PerPartyRouterFactory) CreateCommandWithPackageID(packageID string) *model.CreateCommand

CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name

func (PerPartyRouterFactory) CreateRouter 

func (t PerPartyRouterFactory) CreateRouter(contractID string, args CreateRouter) *model.ExerciseCommand

CreateRouter exercises the CreateRouter choice on this PerPartyRouterFactory contract This method uses the package name in the template ID

func (PerPartyRouterFactory) CreateRouterWithPackageID 

func (t PerPartyRouterFactory) CreateRouterWithPackageID(contractID string, packageID string, args CreateRouter) *model.ExerciseCommand

CreateRouterWithPackageID exercises the CreateRouter choice using the provided package ID instead of package name

func (PerPartyRouterFactory) FactorySetDeps 

func (t PerPartyRouterFactory) FactorySetDeps(contractID string, args FactorySetDeps) *model.ExerciseCommand

FactorySetDeps exercises the FactorySetDeps choice on this PerPartyRouterFactory contract This method uses the package name in the template ID

func (PerPartyRouterFactory) FactorySetDepsWithPackageID 

func (t PerPartyRouterFactory) FactorySetDepsWithPackageID(contractID string, packageID string, args FactorySetDeps) *model.ExerciseCommand

FactorySetDepsWithPackageID exercises the FactorySetDeps choice using the provided package ID instead of package name

func (PerPartyRouterFactory) GetTemplateID 

func (t PerPartyRouterFactory) GetTemplateID() string

GetTemplateID returns the template ID for this template using the package name

func (PerPartyRouterFactory) GetTemplateIDWithPackageID 

func (t PerPartyRouterFactory) GetTemplateIDWithPackageID(packageID string) string

GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name

func (PerPartyRouterFactory) HasRouter 

func (t PerPartyRouterFactory) HasRouter(contractID string, args HasRouter) *model.ExerciseCommand

HasRouter exercises the HasRouter choice on this PerPartyRouterFactory contract This method uses the package name in the template ID

func (PerPartyRouterFactory) HasRouterWithPackageID 

func (t PerPartyRouterFactory) HasRouterWithPackageID(contractID string, packageID string, args HasRouter) *model.ExerciseCommand

HasRouterWithPackageID exercises the HasRouter choice using the provided package ID instead of package name

func (PerPartyRouterFactory) MCMSReceiverEntrypoint 

func (t PerPartyRouterFactory) MCMSReceiverEntrypoint(contractID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypoint exercises the MCMSReceiver_Entrypoint choice on this PerPartyRouterFactory contract via the IMCMSReceiver interface This method uses the package name in the template ID

func (PerPartyRouterFactory) MCMSReceiverEntrypointWithPackageID 

func (t PerPartyRouterFactory) MCMSReceiverEntrypointWithPackageID(contractID string, packageID string, args api.MCMSReceiverEntrypoint) *model.ExerciseCommand

MCMSReceiverEntrypointWithPackageID exercises the MCMSReceiver_Entrypoint choice using the provided package ID instead of package name

func (PerPartyRouterFactory) MarshalHex 

func (t PerPartyRouterFactory) MarshalHex() (string, error)

MarshalHex encodes PerPartyRouterFactory to hex string (Canton MCMS format)

func (PerPartyRouterFactory) MarshalJSON 

func (t PerPartyRouterFactory) MarshalJSON() ([]byte, error)

func (*PerPartyRouterFactory) UnmarshalHex 

func (t *PerPartyRouterFactory) UnmarshalHex(data string) error

UnmarshalHex decodes PerPartyRouterFactory from hex string (Canton MCMS format)

func (*PerPartyRouterFactory) UnmarshalJSON 

func (t *PerPartyRouterFactory) UnmarshalJSON(data []byte) error

type PrepareExecute 

type PrepareExecute struct {
	Context                   splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	EncodedMessage            types.TEXT                                 `json:"encodedMessage"`
	ReceiverParty             types.PARTY                                `json:"receiverParty"`
	TokenReceiverParty        *types.PARTY                               `json:"tokenReceiverParty" hex:"optional"`
	ReceiverRequiredCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverRequiredCCVs"`
	ReceiverOptionalCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverOptionalCCVs"`
	ReceiverOptionalThreshold types.INT64                                `json:"receiverOptionalThreshold"`
	ReceiverFinalityConfig    core.FinalityConfig                        `json:"receiverFinalityConfig"`
	Caller                    types.PARTY                                `json:"caller"`
}

PrepareExecute is a Record type

func (PrepareExecute) MarshalHex 

func (t PrepareExecute) MarshalHex() (string, error)

MarshalHex encodes PrepareExecute to hex string (Canton MCMS format)

func (PrepareExecute) MarshalJSON 

func (t PrepareExecute) MarshalJSON() ([]byte, error)

func (PrepareExecute) ToMap 

func (t PrepareExecute) ToMap() map[string]any

ToMap converts PrepareExecute to a map for DAML arguments

func (*PrepareExecute) UnmarshalHex 

func (t *PrepareExecute) UnmarshalHex(data string) error

UnmarshalHex decodes PrepareExecute from hex string (Canton MCMS format)

func (*PrepareExecute) UnmarshalJSON 

func (t *PrepareExecute) UnmarshalJSON(data []byte) error

type PrepareExecuteMCMSParams 

type PrepareExecuteMCMSParams struct {
	Context                   splice_api_token_metadata_v1.ChoiceContext `json:"context"`
	EncodedMessage            types.TEXT                                 `json:"encodedMessage"`
	ReceiverParty             types.PARTY                                `json:"receiverParty"`
	TokenReceiverParty        *types.PARTY                               `json:"tokenReceiverParty" hex:"optional"`
	ReceiverRequiredCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverRequiredCCVs"`
	ReceiverOptionalCCVs      []chainlinkapi.RawInstanceAddress          `json:"receiverOptionalCCVs"`
	ReceiverOptionalThreshold types.INT64                                `json:"receiverOptionalThreshold"`
	ReceiverFinalityConfig    core.FinalityConfig                        `json:"receiverFinalityConfig"`
}

PrepareExecuteMCMSParams is PrepareExecute without the Caller field for MCMS operationData encoding. Use this when encoding choice arguments for MCMS timelock operations.

func (PrepareExecuteMCMSParams) MarshalHex 

func (t PrepareExecuteMCMSParams) MarshalHex() (string, error)

MarshalHex encodes PrepareExecuteMCMSParams to hex string for MCMS operationData.

func (*PrepareExecuteMCMSParams) UnmarshalHex 

func (t *PrepareExecuteMCMSParams) UnmarshalHex(data string) error

UnmarshalHex decodes PrepareExecuteMCMSParams from hex string.

type PrepareSend 

type PrepareSend struct {
	DestinationChainSelector types.NUMERIC                              `json:"destinationChainSelector"`
	Message                  core.Canton2AnyMessage                     `json:"message"`
	Context                  splice_api_token_metadata_v1.ChoiceContext `json:"context"`
}

PrepareSend is a Record type

func (PrepareSend) MarshalHex 

func (t PrepareSend) MarshalHex() (string, error)

MarshalHex encodes PrepareSend to hex string (Canton MCMS format)

func (PrepareSend) MarshalJSON 

func (t PrepareSend) MarshalJSON() ([]byte, error)

func (PrepareSend) ToMap 

func (t PrepareSend) ToMap() map[string]any

ToMap converts PrepareSend to a map for DAML arguments

func (*PrepareSend) UnmarshalHex 

func (t *PrepareSend) UnmarshalHex(data string) error

UnmarshalHex decodes PrepareSend from hex string (Canton MCMS format)

func (*PrepareSend) UnmarshalJSON 

func (t *PrepareSend) UnmarshalJSON(data []byte) error

type PrepareSendFromRouter 

type PrepareSendFromRouter struct {
	DestChainSelector     types.NUMERIC          `json:"destChainSelector"`
	Message               core.Canton2AnyMessage `json:"message"`
	RouterPartyOwner      types.PARTY            `json:"routerPartyOwner"`
	RouterInstanceId      types.TEXT             `json:"routerInstanceId"`
	GlobalConfigCid       types.CONTRACT_ID      `json:"globalConfigCid"`
	TokenAdminRegistryCid types.CONTRACT_ID      `json:"tokenAdminRegistryCid"`
	FeeQuoterCid          types.CONTRACT_ID      `json:"feeQuoterCid"`
	RmnRemoteCid          types.CONTRACT_ID      `json:"rmnRemoteCid"`
	CurrentSequenceNumber types.NUMERIC          `json:"currentSequenceNumber"`
}

PrepareSendFromRouter is a Record type

func (PrepareSendFromRouter) MarshalHex 

func (t PrepareSendFromRouter) MarshalHex() (string, error)

MarshalHex encodes PrepareSendFromRouter to hex string (Canton MCMS format)

func (PrepareSendFromRouter) MarshalJSON 

func (t PrepareSendFromRouter) MarshalJSON() ([]byte, error)

func (PrepareSendFromRouter) ToMap 

func (t PrepareSendFromRouter) ToMap() map[string]any

ToMap converts PrepareSendFromRouter to a map for DAML arguments

func (*PrepareSendFromRouter) UnmarshalHex 

func (t *PrepareSendFromRouter) UnmarshalHex(data string) error

UnmarshalHex decodes PrepareSendFromRouter from hex string (Canton MCMS format)

func (*PrepareSendFromRouter) UnmarshalJSON 

func (t *PrepareSendFromRouter) UnmarshalJSON(data []byte) error

type RemoveCustomObservers2 

type RemoveCustomObservers2 struct {
	Parties []types.PARTY `json:"parties"`
}

RemoveCustomObservers2 is a Record type

func (RemoveCustomObservers2) MarshalHex 

func (t RemoveCustomObservers2) MarshalHex() (string, error)

MarshalHex encodes RemoveCustomObservers2 to hex string (Canton MCMS format)

func (RemoveCustomObservers2) MarshalJSON 

func (t RemoveCustomObservers2) MarshalJSON() ([]byte, error)

func (RemoveCustomObservers2) ToMap 

func (t RemoveCustomObservers2) ToMap() map[string]any

ToMap converts RemoveCustomObservers2 to a map for DAML arguments

func (*RemoveCustomObservers2) UnmarshalHex 

func (t *RemoveCustomObservers2) UnmarshalHex(data string) error

UnmarshalHex decodes RemoveCustomObservers2 from hex string (Canton MCMS format)

func (*RemoveCustomObservers2) UnmarshalJSON 

func (t *RemoveCustomObservers2) UnmarshalJSON(data []byte) error

type RemoveCustomObserversParams2 

type RemoveCustomObserversParams2 struct {
	Parties []types.PARTY `json:"parties"`
}

RemoveCustomObserversParams2 is a Record type

func (RemoveCustomObserversParams2) MarshalHex 

func (t RemoveCustomObserversParams2) MarshalHex() (string, error)

MarshalHex encodes RemoveCustomObserversParams2 to hex string (Canton MCMS format)

func (RemoveCustomObserversParams2) MarshalJSON 

func (t RemoveCustomObserversParams2) MarshalJSON() ([]byte, error)

func (RemoveCustomObserversParams2) ToMap 

func (t RemoveCustomObserversParams2) ToMap() map[string]any

ToMap converts RemoveCustomObserversParams2 to a map for DAML arguments

func (*RemoveCustomObserversParams2) UnmarshalHex 

func (t *RemoveCustomObserversParams2) UnmarshalHex(data string) error

UnmarshalHex decodes RemoveCustomObserversParams2 from hex string (Canton MCMS format)

func (*RemoveCustomObserversParams2) UnmarshalJSON 

func (t *RemoveCustomObserversParams2) UnmarshalJSON(data []byte) error

type SetDeps 

type SetDeps struct {
	NewDeps SetDepsParams `json:"newDeps"`
}

SetDeps is a Record type

func (SetDeps) MarshalHex 

func (t SetDeps) MarshalHex() (string, error)

MarshalHex encodes SetDeps to hex string (Canton MCMS format)

func (SetDeps) MarshalJSON 

func (t SetDeps) MarshalJSON() ([]byte, error)

func (SetDeps) ToMap 

func (t SetDeps) ToMap() map[string]any

ToMap converts SetDeps to a map for DAML arguments

func (*SetDeps) UnmarshalHex 

func (t *SetDeps) UnmarshalHex(data string) error

UnmarshalHex decodes SetDeps from hex string (Canton MCMS format)

func (*SetDeps) UnmarshalJSON 

func (t *SetDeps) UnmarshalJSON(data []byte) error

type SetDepsParams 

type SetDepsParams struct {
	GlobalConfig       *chainlinkapi.RawInstanceAddress `json:"globalConfig" hex:"optional"`
	RmnRemote          *chainlinkapi.RawInstanceAddress `json:"rmnRemote" hex:"optional"`
	TokenAdminRegistry *chainlinkapi.RawInstanceAddress `json:"tokenAdminRegistry" hex:"optional"`
	FeeQuoter          *chainlinkapi.RawInstanceAddress `json:"feeQuoter" hex:"optional"`
	CcvRegistry        *chainlinkapi.RawInstanceAddress `json:"ccvRegistry" hex:"optional"`
}

SetDepsParams is a Record type

func (SetDepsParams) MarshalHex 

func (t SetDepsParams) MarshalHex() (string, error)

MarshalHex encodes SetDepsParams to hex string (Canton MCMS format)

func (SetDepsParams) MarshalJSON 

func (t SetDepsParams) MarshalJSON() ([]byte, error)

func (SetDepsParams) ToMap 

func (t SetDepsParams) ToMap() map[string]any

ToMap converts SetDepsParams to a map for DAML arguments

func (*SetDepsParams) UnmarshalHex 

func (t *SetDepsParams) UnmarshalHex(data string) error

UnmarshalHex decodes SetDepsParams from hex string (Canton MCMS format)

func (*SetDepsParams) UnmarshalJSON 

func (t *SetDepsParams) UnmarshalJSON(data []byte) error

type Template 

type Template interface {
	CreateCommand() *model.CreateCommand
	GetTemplateID() string
}

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.