diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 6137a2906..811c28d85 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -9,6 +9,7 @@ updates: - "/integration-tests" - "/party-ceremony" - "/party-ceremony/integration-tests" + - "/registry-kit" schedule: interval: "weekly" open-pull-requests-limit: 20 diff --git a/.github/workflows/go-lint-all.yml b/.github/workflows/go-lint-all.yml index 93a902b90..57b505257 100644 --- a/.github/workflows/go-lint-all.yml +++ b/.github/workflows/go-lint-all.yml @@ -46,6 +46,7 @@ jobs: - integration-tests - party-ceremony - party-ceremony/integration-tests + - registry-kit runs-on: ubuntu-latest-8cores-32GB steps: - name: Check out code @@ -55,6 +56,9 @@ jobs: with: go-version-file: ${{ matrix.dir }}/go.mod cache-dependency-path: ${{ matrix.dir }}/go.sum + - name: Build Go + working-directory: ${{ matrix.dir }} + run: go build ./... - name: Linting Go uses: golangci/golangci-lint-action@1e7e51e771db61008b38414a730f564565cf7c20 # v9.2.0 with: diff --git a/Makefile b/Makefile index ff937625f..0f42732da 100644 --- a/Makefile +++ b/Makefile @@ -48,7 +48,7 @@ test-daml-contracts: # GolangCI-Lint targets -.PHONY: golangci-lint-main golangci-lint-integration-tests golangci-lint-party-ceremony golangci-lint-party-ceremony-integration-tests +.PHONY: golangci-lint-main golangci-lint-integration-tests golangci-lint-party-ceremony golangci-lint-party-ceremony-integration-tests golangci-lint-registry-kit golangci-lint-main: ## Run golangci-lint on the main module. golangci-lint run golangci-lint-integration-tests: ## Run golangci-lint on the integration-tests module. @@ -57,11 +57,13 @@ golangci-lint-party-ceremony: ## Run golangci-lint on the party-ceremony module. cd party-ceremony && golangci-lint run golangci-lint-party-ceremony-integration-tests: ## Run golangci-lint on the party-ceremony/integration-tests module. cd party-ceremony/integration-tests && golangci-lint run +golangci-lint-registry-kit: ## Run golangci-lint on the registry-kit module. + cd registry-kit && golangci-lint run .PHONY: golangci-lint-all -golangci-lint-all: golangci-lint-main golangci-lint-integration-tests golangci-lint-party-ceremony golangci-lint-party-ceremony-integration-tests ## Run golangci-lint on all modules. +golangci-lint-all: golangci-lint-main golangci-lint-integration-tests golangci-lint-party-ceremony golangci-lint-party-ceremony-integration-tests golangci-lint-registry-kit ## Run golangci-lint on all modules. -.PHONY: golangci-lint-fix-main golangci-lint-fix-integration-tests golangci-lint-fix-party-ceremony golangci-lint-fix-party-ceremony-integration-tests +.PHONY: golangci-lint-fix-main golangci-lint-fix-integration-tests golangci-lint-fix-party-ceremony golangci-lint-fix-party-ceremony-integration-tests golangci-lint-fix-registry-kit golangci-lint-fix-main: ## Run golangci-lint --fix on the main module. golangci-lint run --fix golangci-lint-fix-integration-tests: ## Run golangci-lint --fix on the integration-tests module. @@ -70,9 +72,11 @@ golangci-lint-fix-party-ceremony: ## Run golangci-lint --fix on the party-ceremo cd party-ceremony && golangci-lint run --fix golangci-lint-fix-party-ceremony-integration-tests: ## Run golangci-lint --fix on the party-ceremony/integration-tests module. cd party-ceremony/integration-tests && golangci-lint run --fix +golangci-lint-fix-registry-kit: ## Run golangci-lint --fix on the registry-kit module. + cd registry-kit && golangci-lint run --fix .PHONY: golangci-lint-fix-all -golangci-lint-fix-all: golangci-lint-fix-main golangci-lint-fix-integration-tests golangci-lint-fix-party-ceremony golangci-lint-fix-party-ceremony-integration-tests ## Run golangci-lint --fix on all modules. +golangci-lint-fix-all: golangci-lint-fix-main golangci-lint-fix-integration-tests golangci-lint-fix-party-ceremony golangci-lint-fix-party-ceremony-integration-tests golangci-lint-fix-registry-kit ## Run golangci-lint --fix on all modules. ## Run all fix targets. ## Compiles contracts, generates bindings, runs all go generates, runs go mod tidy, and runs golangci-lint --fix on all modules. diff --git a/bindings/generated/latest/splice/splice_api_featured_app_v1/splice_api_featured_app_v1.go b/bindings/generated/latest/splice/splice_api_featured_app_v1/splice_api_featured_app_v1.go new file mode 100644 index 000000000..4d9ac077c --- /dev/null +++ b/bindings/generated/latest/splice/splice_api_featured_app_v1/splice_api_featured_app_v1.go @@ -0,0 +1,331 @@ +package splice_api_featured_app_v1 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "splice-api-featured-app-v1" + PackageID = "7804375fe5e4c6d5afe067bd314c42fe0b7d005a1300019c73154dd939da4dda" + SDKVersion = "3.3.0-snapshot.20250502.13767.0.v2fc6c7e2" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +// IFeaturedAppActivityMarker is a DAML interface +type IFeaturedAppActivityMarker interface { + + // Archive executes the Archive choice + Archive(contractID string) *model.ExerciseCommand +} + +// IFeaturedAppRight is a DAML interface +type IFeaturedAppRight interface { + + // Archive executes the Archive choice + Archive(contractID string) *model.ExerciseCommand + + // FeaturedAppRightCreateActivityMarker executes the FeaturedAppRight_CreateActivityMarker choice + FeaturedAppRightCreateActivityMarker(contractID string, args FeaturedAppRightCreateActivityMarker) *model.ExerciseCommand +} + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// AppRewardBeneficiary is a Record type +type AppRewardBeneficiary struct { + Beneficiary types.PARTY `json:"beneficiary"` + Weight types.NUMERIC `json:"weight"` +} + +// ToMap converts AppRewardBeneficiary to a map for DAML arguments +func (t AppRewardBeneficiary) ToMap() map[string]any { + m := make(map[string]any) + + m["beneficiary"] = t.Beneficiary.ToMap() + + m["weight"] = t.Weight + + return m +} + +func (t AppRewardBeneficiary) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AppRewardBeneficiary) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AppRewardBeneficiary to hex string (Canton MCMS format) +func (t AppRewardBeneficiary) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AppRewardBeneficiary from hex string (Canton MCMS format) +func (t *AppRewardBeneficiary) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FeaturedAppActivityMarkerView is a Record type +type FeaturedAppActivityMarkerView struct { + Dso types.PARTY `json:"dso"` + Provider types.PARTY `json:"provider"` + Beneficiary types.PARTY `json:"beneficiary"` + Weight types.NUMERIC `json:"weight"` +} + +// ToMap converts FeaturedAppActivityMarkerView to a map for DAML arguments +func (t FeaturedAppActivityMarkerView) ToMap() map[string]any { + m := make(map[string]any) + + m["dso"] = t.Dso.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["beneficiary"] = t.Beneficiary.ToMap() + + m["weight"] = t.Weight + + return m +} + +func (t FeaturedAppActivityMarkerView) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FeaturedAppActivityMarkerView) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FeaturedAppActivityMarkerView to hex string (Canton MCMS format) +func (t FeaturedAppActivityMarkerView) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FeaturedAppActivityMarkerView from hex string (Canton MCMS format) +func (t *FeaturedAppActivityMarkerView) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FeaturedAppRightView is a Record type +type FeaturedAppRightView struct { + Dso types.PARTY `json:"dso"` + Provider types.PARTY `json:"provider"` +} + +// ToMap converts FeaturedAppRightView to a map for DAML arguments +func (t FeaturedAppRightView) ToMap() map[string]any { + m := make(map[string]any) + + m["dso"] = t.Dso.ToMap() + + m["provider"] = t.Provider.ToMap() + + return m +} + +func (t FeaturedAppRightView) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FeaturedAppRightView) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FeaturedAppRightView to hex string (Canton MCMS format) +func (t FeaturedAppRightView) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FeaturedAppRightView from hex string (Canton MCMS format) +func (t *FeaturedAppRightView) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FeaturedAppRightCreateActivityMarker is a Record type +type FeaturedAppRightCreateActivityMarker struct { + Beneficiaries []AppRewardBeneficiary `json:"beneficiaries"` +} + +// ToMap converts FeaturedAppRightCreateActivityMarker to a map for DAML arguments +func (t FeaturedAppRightCreateActivityMarker) ToMap() map[string]any { + m := make(map[string]any) + + m["beneficiaries"] = func() []any { + res := make([]any, 0, len(t.Beneficiaries)) + for _, e := range t.Beneficiaries { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t FeaturedAppRightCreateActivityMarker) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FeaturedAppRightCreateActivityMarker) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FeaturedAppRightCreateActivityMarker to hex string (Canton MCMS format) +func (t FeaturedAppRightCreateActivityMarker) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FeaturedAppRightCreateActivityMarker from hex string (Canton MCMS format) +func (t *FeaturedAppRightCreateActivityMarker) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FeaturedAppRightCreateActivityMarkerResult is a Record type +type FeaturedAppRightCreateActivityMarkerResult struct { + ActivityMarkerCids []types.CONTRACT_ID `json:"activityMarkerCids"` +} + +// ToMap converts FeaturedAppRightCreateActivityMarkerResult to a map for DAML arguments +func (t FeaturedAppRightCreateActivityMarkerResult) ToMap() map[string]any { + m := make(map[string]any) + + m["activityMarkerCids"] = func() []any { + res := make([]any, 0, len(t.ActivityMarkerCids)) + for _, e := range t.ActivityMarkerCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t FeaturedAppRightCreateActivityMarkerResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FeaturedAppRightCreateActivityMarkerResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FeaturedAppRightCreateActivityMarkerResult to hex string (Canton MCMS format) +func (t FeaturedAppRightCreateActivityMarkerResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FeaturedAppRightCreateActivityMarkerResult from hex string (Canton MCMS format) +func (t *FeaturedAppRightCreateActivityMarkerResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// IFeaturedAppActivityMarkerInterfaceID returns the interface ID for the IFeaturedAppActivityMarker interface using the package name +func IFeaturedAppActivityMarkerInterfaceID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Splice.Api.FeaturedAppRightV1", "FeaturedAppActivityMarker") +} + +// IFeaturedAppActivityMarkerInterfaceIDWithPackageID returns the interface ID using the provided package ID instead of package name +func IFeaturedAppActivityMarkerInterfaceIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Splice.Api.FeaturedAppRightV1", "FeaturedAppActivityMarker") +} + +// IFeaturedAppRightInterfaceID returns the interface ID for the IFeaturedAppRight interface using the package name +func IFeaturedAppRightInterfaceID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Splice.Api.FeaturedAppRightV1", "FeaturedAppRight") +} + +// IFeaturedAppRightInterfaceIDWithPackageID returns the interface ID using the provided package ID instead of package name +func IFeaturedAppRightInterfaceIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Splice.Api.FeaturedAppRightV1", "FeaturedAppRight") +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/splice/splice_api_token_allocation_instruction_v1/splice_api_token_allocation_instruction_v1.go b/bindings/generated/latest/splice/splice_api_token_allocation_instruction_v1/splice_api_token_allocation_instruction_v1.go new file mode 100644 index 000000000..ad03500a9 --- /dev/null +++ b/bindings/generated/latest/splice/splice_api_token_allocation_instruction_v1/splice_api_token_allocation_instruction_v1.go @@ -0,0 +1,609 @@ +package splice_api_token_allocation_instruction_v1 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + splice_api_token_allocation_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_allocation_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "splice-api-token-allocation-instruction-v1" + PackageID = "275064aacfe99cea72ee0c80563936129563776f67415ef9f13e4297eecbc520" + SDKVersion = "3.3.0-snapshot.20250502.13767.0.v2fc6c7e2" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +// IAllocationFactory is a DAML interface +type IAllocationFactory interface { + + // Archive executes the Archive choice + Archive(contractID string) *model.ExerciseCommand + + // AllocationFactoryAllocate executes the AllocationFactory_Allocate choice + AllocationFactoryAllocate(contractID string, args AllocationFactoryAllocate) *model.ExerciseCommand + + // AllocationFactoryPublicFetch executes the AllocationFactory_PublicFetch choice + AllocationFactoryPublicFetch(contractID string, args AllocationFactoryPublicFetch) *model.ExerciseCommand +} + +// IAllocationInstruction is a DAML interface +type IAllocationInstruction interface { + + // Archive executes the Archive choice + Archive(contractID string) *model.ExerciseCommand + + // AllocationInstructionWithdraw executes the AllocationInstruction_Withdraw choice + AllocationInstructionWithdraw(contractID string, args AllocationInstructionWithdraw) *model.ExerciseCommand + + // AllocationInstructionUpdate executes the AllocationInstruction_Update choice + AllocationInstructionUpdate(contractID string, args AllocationInstructionUpdate) *model.ExerciseCommand +} + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// AllocationFactoryView is a Record type +type AllocationFactoryView struct { + Admin types.PARTY `json:"admin"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationFactoryView to a map for DAML arguments +func (t AllocationFactoryView) ToMap() map[string]any { + m := make(map[string]any) + + m["admin"] = t.Admin.ToMap() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationFactoryView) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryView) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryView to hex string (Canton MCMS format) +func (t AllocationFactoryView) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryView from hex string (Canton MCMS format) +func (t *AllocationFactoryView) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryAllocate is a Record type +type AllocationFactoryAllocate struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Allocation splice_api_token_allocation_v1.AllocationSpecification `json:"allocation"` + RequestedAt types.TIMESTAMP `json:"requestedAt"` + InputHoldingCids []types.CONTRACT_ID `json:"inputHoldingCids"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationFactoryAllocate to a map for DAML arguments +func (t AllocationFactoryAllocate) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["allocation"] = model.NestedToDAMLValue(t.Allocation) + + m["requestedAt"] = t.RequestedAt + + m["inputHoldingCids"] = func() []any { + res := make([]any, 0, len(t.InputHoldingCids)) + for _, e := range t.InputHoldingCids { + res = append(res, e) + } + return res + }() + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationFactoryAllocate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryAllocate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryAllocate to hex string (Canton MCMS format) +func (t AllocationFactoryAllocate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryAllocate from hex string (Canton MCMS format) +func (t *AllocationFactoryAllocate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryPublicFetch is a Record type +type AllocationFactoryPublicFetch struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AllocationFactoryPublicFetch to a map for DAML arguments +func (t AllocationFactoryPublicFetch) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AllocationFactoryPublicFetch) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryPublicFetch) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryPublicFetch to hex string (Canton MCMS format) +func (t AllocationFactoryPublicFetch) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryPublicFetch from hex string (Canton MCMS format) +func (t *AllocationFactoryPublicFetch) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionResult is a Record type +type AllocationInstructionResult struct { + Output AllocationInstructionResultOutput `json:"output"` + SenderChangeCids []types.CONTRACT_ID `json:"senderChangeCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationInstructionResult to a map for DAML arguments +func (t AllocationInstructionResult) ToMap() map[string]any { + m := make(map[string]any) + + m["output"] = model.NestedToDAMLValue(t.Output) + + m["senderChangeCids"] = func() []any { + res := make([]any, 0, len(t.SenderChangeCids)) + for _, e := range t.SenderChangeCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationInstructionResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionResult to hex string (Canton MCMS format) +func (t AllocationInstructionResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionResult from hex string (Canton MCMS format) +func (t *AllocationInstructionResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionResultCompleted is a Record type +type AllocationInstructionResultCompleted struct { + AllocationCid types.CONTRACT_ID `json:"allocationCid"` +} + +// ToMap converts AllocationInstructionResultCompleted to a map for DAML arguments +func (t AllocationInstructionResultCompleted) ToMap() map[string]any { + m := make(map[string]any) + + m["allocationCid"] = model.NestedToDAMLValue(t.AllocationCid) + + return m +} + +func (t AllocationInstructionResultCompleted) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionResultCompleted) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionResultCompleted to hex string (Canton MCMS format) +func (t AllocationInstructionResultCompleted) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionResultCompleted from hex string (Canton MCMS format) +func (t *AllocationInstructionResultCompleted) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionResultOutput is a variant/union type +type AllocationInstructionResultOutput struct { + AllocationInstructionResultPending *AllocationInstructionResultPending `json:"AllocationInstructionResult_Pending,omitempty"` + AllocationInstructionResultCompleted *AllocationInstructionResultCompleted `json:"AllocationInstructionResult_Completed,omitempty"` + AllocationInstructionResultFailed *types.UNIT `json:"AllocationInstructionResult_Failed,omitempty"` +} + +// MarshalJSON implements custom JSON marshaling for AllocationInstructionResultOutput +func (v AllocationInstructionResultOutput) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(v) +} + +// UnmarshalJSON implements custom JSON unmarshalling for AllocationInstructionResultOutput +func (v *AllocationInstructionResultOutput) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, v) +} + +// MarshalHex encodes AllocationInstructionResultOutput to hex string (Canton MCMS format) +func (v AllocationInstructionResultOutput) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(v) +} + +// UnmarshalHex decodes AllocationInstructionResultOutput from hex string (Canton MCMS format) +func (v *AllocationInstructionResultOutput) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, v) +} + +// GetVariantTag implements types.VARIANT interface +func (v AllocationInstructionResultOutput) GetVariantTag() string { + + if v.AllocationInstructionResultPending != nil { + return "AllocationInstructionResult_Pending" + } + + if v.AllocationInstructionResultCompleted != nil { + return "AllocationInstructionResult_Completed" + } + + if v.AllocationInstructionResultFailed != nil { + return "AllocationInstructionResult_Failed" + } + + return "" +} + +// GetVariantValue implements types.VARIANT interface +func (v AllocationInstructionResultOutput) GetVariantValue() any { + + if v.AllocationInstructionResultPending != nil { + return v.AllocationInstructionResultPending + } + + if v.AllocationInstructionResultCompleted != nil { + return v.AllocationInstructionResultCompleted + } + + if v.AllocationInstructionResultFailed != nil { + return v.AllocationInstructionResultFailed + } + + return nil +} + +var _ types.VARIANT = (*AllocationInstructionResultOutput)(nil) + +// AllocationInstructionResultPending is a Record type +type AllocationInstructionResultPending struct { + AllocationInstructionCid types.CONTRACT_ID `json:"allocationInstructionCid"` +} + +// ToMap converts AllocationInstructionResultPending to a map for DAML arguments +func (t AllocationInstructionResultPending) ToMap() map[string]any { + m := make(map[string]any) + + m["allocationInstructionCid"] = model.NestedToDAMLValue(t.AllocationInstructionCid) + + return m +} + +func (t AllocationInstructionResultPending) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionResultPending) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionResultPending to hex string (Canton MCMS format) +func (t AllocationInstructionResultPending) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionResultPending from hex string (Canton MCMS format) +func (t *AllocationInstructionResultPending) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionView is a Record type +type AllocationInstructionView struct { + OriginalInstructionCid *types.CONTRACT_ID `json:"originalInstructionCid" hex:"optional"` + Allocation splice_api_token_allocation_v1.AllocationSpecification `json:"allocation"` + PendingActions map[types.PARTY]types.TEXT `json:"pendingActions"` + RequestedAt types.TIMESTAMP `json:"requestedAt"` + InputHoldingCids []types.CONTRACT_ID `json:"inputHoldingCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationInstructionView to a map for DAML arguments +func (t AllocationInstructionView) ToMap() map[string]any { + m := make(map[string]any) + + if t.OriginalInstructionCid != nil { + m["originalInstructionCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.OriginalInstructionCid), + } + } else { + m["originalInstructionCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["allocation"] = model.NestedToDAMLValue(t.Allocation) + + m["pendingActions"] = func() any { + if t.PendingActions == nil { + return map[string]any{"_type": "genmap", "value": types.GENMAP{}} + } + return map[string]any{"_type": "genmap", "value": t.PendingActions} + }() + + m["requestedAt"] = t.RequestedAt + + m["inputHoldingCids"] = func() []any { + res := make([]any, 0, len(t.InputHoldingCids)) + for _, e := range t.InputHoldingCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationInstructionView) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionView) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionView to hex string (Canton MCMS format) +func (t AllocationInstructionView) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionView from hex string (Canton MCMS format) +func (t *AllocationInstructionView) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionUpdate is a Record type +type AllocationInstructionUpdate struct { + ExtraActors []types.PARTY `json:"extraActors"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationInstructionUpdate to a map for DAML arguments +func (t AllocationInstructionUpdate) ToMap() map[string]any { + m := make(map[string]any) + + m["extraActors"] = func() []any { + res := make([]any, 0, len(t.ExtraActors)) + for _, e := range t.ExtraActors { + res = append(res, e.ToMap()) + } + return res + }() + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationInstructionUpdate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionUpdate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionUpdate to hex string (Canton MCMS format) +func (t AllocationInstructionUpdate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionUpdate from hex string (Canton MCMS format) +func (t *AllocationInstructionUpdate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationInstructionWithdraw is a Record type +type AllocationInstructionWithdraw struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationInstructionWithdraw to a map for DAML arguments +func (t AllocationInstructionWithdraw) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationInstructionWithdraw) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationInstructionWithdraw) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationInstructionWithdraw to hex string (Canton MCMS format) +func (t AllocationInstructionWithdraw) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationInstructionWithdraw from hex string (Canton MCMS format) +func (t *AllocationInstructionWithdraw) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// IAllocationFactoryInterfaceID returns the interface ID for the IAllocationFactory interface using the package name +func IAllocationFactoryInterfaceID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Splice.Api.Token.AllocationInstructionV1", "AllocationFactory") +} + +// IAllocationFactoryInterfaceIDWithPackageID returns the interface ID using the provided package ID instead of package name +func IAllocationFactoryInterfaceIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Splice.Api.Token.AllocationInstructionV1", "AllocationFactory") +} + +// IAllocationInstructionInterfaceID returns the interface ID for the IAllocationInstruction interface using the package name +func IAllocationInstructionInterfaceID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Splice.Api.Token.AllocationInstructionV1", "AllocationInstruction") +} + +// IAllocationInstructionInterfaceIDWithPackageID returns the interface ID using the provided package ID instead of package name +func IAllocationInstructionInterfaceIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Splice.Api.Token.AllocationInstructionV1", "AllocationInstruction") +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/splice/splice_api_token_allocation_v1/splice_api_token_allocation_v1.go b/bindings/generated/latest/splice/splice_api_token_allocation_v1/splice_api_token_allocation_v1.go new file mode 100644 index 000000000..dd245f912 --- /dev/null +++ b/bindings/generated/latest/splice/splice_api_token_allocation_v1/splice_api_token_allocation_v1.go @@ -0,0 +1,605 @@ +package splice_api_token_allocation_v1 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "splice-api-token-allocation-v1" + PackageID = "93c942ae2b4c2ba674fb152fe38473c507bda4e82b4e4c5da55a552a9d8cce1d" + SDKVersion = "3.3.0-snapshot.20250502.13767.0.v2fc6c7e2" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +// IAllocation is a DAML interface +type IAllocation interface { + + // Archive executes the Archive choice + Archive(contractID string) *model.ExerciseCommand + + // AllocationWithdraw executes the Allocation_Withdraw choice + AllocationWithdraw(contractID string, args AllocationWithdraw) *model.ExerciseCommand + + // AllocationCancel executes the Allocation_Cancel choice + AllocationCancel(contractID string, args AllocationCancel) *model.ExerciseCommand + + // AllocationExecuteTransfer executes the Allocation_ExecuteTransfer choice + AllocationExecuteTransfer(contractID string, args AllocationExecuteTransfer) *model.ExerciseCommand +} + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// AllocationSpecification is a Record type +type AllocationSpecification struct { + Settlement SettlementInfo `json:"settlement"` + TransferLegId types.TEXT `json:"transferLegId"` + TransferLeg TransferLeg `json:"transferLeg"` +} + +// ToMap converts AllocationSpecification to a map for DAML arguments +func (t AllocationSpecification) ToMap() map[string]any { + m := make(map[string]any) + + m["settlement"] = model.NestedToDAMLValue(t.Settlement) + + m["transferLegId"] = string(t.TransferLegId) + + m["transferLeg"] = model.NestedToDAMLValue(t.TransferLeg) + + return m +} + +func (t AllocationSpecification) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationSpecification) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationSpecification to hex string (Canton MCMS format) +func (t AllocationSpecification) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationSpecification from hex string (Canton MCMS format) +func (t *AllocationSpecification) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationView is a Record type +type AllocationView struct { + Allocation AllocationSpecification `json:"allocation"` + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationView to a map for DAML arguments +func (t AllocationView) ToMap() map[string]any { + m := make(map[string]any) + + m["allocation"] = model.NestedToDAMLValue(t.Allocation) + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationView) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationView) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationView to hex string (Canton MCMS format) +func (t AllocationView) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationView from hex string (Canton MCMS format) +func (t *AllocationView) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationCancel is a Record type +type AllocationCancel struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationCancel to a map for DAML arguments +func (t AllocationCancel) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationCancel to hex string (Canton MCMS format) +func (t AllocationCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationCancel from hex string (Canton MCMS format) +func (t *AllocationCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationCancelResult is a Record type +type AllocationCancelResult struct { + SenderHoldingCids []types.CONTRACT_ID `json:"senderHoldingCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationCancelResult to a map for DAML arguments +func (t AllocationCancelResult) ToMap() map[string]any { + m := make(map[string]any) + + m["senderHoldingCids"] = func() []any { + res := make([]any, 0, len(t.SenderHoldingCids)) + for _, e := range t.SenderHoldingCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationCancelResult to hex string (Canton MCMS format) +func (t AllocationCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationCancelResult from hex string (Canton MCMS format) +func (t *AllocationCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationExecuteTransfer is a Record type +type AllocationExecuteTransfer struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationExecuteTransfer to a map for DAML arguments +func (t AllocationExecuteTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationExecuteTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationExecuteTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationExecuteTransfer to hex string (Canton MCMS format) +func (t AllocationExecuteTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationExecuteTransfer from hex string (Canton MCMS format) +func (t *AllocationExecuteTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationExecuteTransferResult is a Record type +type AllocationExecuteTransferResult struct { + SenderHoldingCids []types.CONTRACT_ID `json:"senderHoldingCids"` + ReceiverHoldingCids []types.CONTRACT_ID `json:"receiverHoldingCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationExecuteTransferResult to a map for DAML arguments +func (t AllocationExecuteTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["senderHoldingCids"] = func() []any { + res := make([]any, 0, len(t.SenderHoldingCids)) + for _, e := range t.SenderHoldingCids { + res = append(res, e) + } + return res + }() + + m["receiverHoldingCids"] = func() []any { + res := make([]any, 0, len(t.ReceiverHoldingCids)) + for _, e := range t.ReceiverHoldingCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationExecuteTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationExecuteTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationExecuteTransferResult to hex string (Canton MCMS format) +func (t AllocationExecuteTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationExecuteTransferResult from hex string (Canton MCMS format) +func (t *AllocationExecuteTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationWithdraw is a Record type +type AllocationWithdraw struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationWithdraw to a map for DAML arguments +func (t AllocationWithdraw) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationWithdraw) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationWithdraw) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationWithdraw to hex string (Canton MCMS format) +func (t AllocationWithdraw) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationWithdraw from hex string (Canton MCMS format) +func (t *AllocationWithdraw) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationWithdrawResult is a Record type +type AllocationWithdrawResult struct { + SenderHoldingCids []types.CONTRACT_ID `json:"senderHoldingCids"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationWithdrawResult to a map for DAML arguments +func (t AllocationWithdrawResult) ToMap() map[string]any { + m := make(map[string]any) + + m["senderHoldingCids"] = func() []any { + res := make([]any, 0, len(t.SenderHoldingCids)) + for _, e := range t.SenderHoldingCids { + res = append(res, e) + } + return res + }() + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationWithdrawResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationWithdrawResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationWithdrawResult to hex string (Canton MCMS format) +func (t AllocationWithdrawResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationWithdrawResult from hex string (Canton MCMS format) +func (t *AllocationWithdrawResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Reference is a Record type +type Reference struct { + Id types.TEXT `json:"id"` + Cid *types.CONTRACT_ID `json:"cid" hex:"optional"` +} + +// ToMap converts Reference to a map for DAML arguments +func (t Reference) ToMap() map[string]any { + m := make(map[string]any) + + m["id"] = string(t.Id) + + if t.Cid != nil { + m["cid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Cid), + } + } else { + m["cid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t Reference) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Reference) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Reference to hex string (Canton MCMS format) +func (t Reference) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Reference from hex string (Canton MCMS format) +func (t *Reference) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// SettlementInfo is a Record type +type SettlementInfo struct { + Executor types.PARTY `json:"executor"` + SettlementRef Reference `json:"settlementRef"` + RequestedAt types.TIMESTAMP `json:"requestedAt"` + AllocateBefore types.TIMESTAMP `json:"allocateBefore"` + SettleBefore types.TIMESTAMP `json:"settleBefore"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts SettlementInfo to a map for DAML arguments +func (t SettlementInfo) ToMap() map[string]any { + m := make(map[string]any) + + m["executor"] = t.Executor.ToMap() + + m["settlementRef"] = model.NestedToDAMLValue(t.SettlementRef) + + m["requestedAt"] = t.RequestedAt + + m["allocateBefore"] = t.AllocateBefore + + m["settleBefore"] = t.SettleBefore + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t SettlementInfo) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *SettlementInfo) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes SettlementInfo to hex string (Canton MCMS format) +func (t SettlementInfo) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes SettlementInfo from hex string (Canton MCMS format) +func (t *SettlementInfo) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferLeg is a Record type +type TransferLeg struct { + Sender types.PARTY `json:"sender"` + Receiver types.PARTY `json:"receiver"` + Amount types.NUMERIC `json:"amount"` + InstrumentId splice_api_token_holding_v1.InstrumentId `json:"instrumentId"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts TransferLeg to a map for DAML arguments +func (t TransferLeg) ToMap() map[string]any { + m := make(map[string]any) + + m["sender"] = t.Sender.ToMap() + + m["receiver"] = t.Receiver.ToMap() + + m["amount"] = t.Amount + + m["instrumentId"] = model.NestedToDAMLValue(t.InstrumentId) + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t TransferLeg) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferLeg) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferLeg to hex string (Canton MCMS format) +func (t TransferLeg) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferLeg from hex string (Canton MCMS format) +func (t *TransferLeg) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// IAllocationInterfaceID returns the interface ID for the IAllocation interface using the package name +func IAllocationInterfaceID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Splice.Api.Token.AllocationV1", "Allocation") +} + +// IAllocationInterfaceIDWithPackageID returns the interface ID using the provided package ID instead of package name +func IAllocationInterfaceIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Splice.Api.Token.AllocationV1", "Allocation") +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/utility/credential_v0/credential_v0.go b/bindings/generated/latest/utility/credential_v0/credential_v0.go new file mode 100644 index 000000000..ba4c6fbb5 --- /dev/null +++ b/bindings/generated/latest/utility/credential_v0/credential_v0.go @@ -0,0 +1,626 @@ +package credential_v0 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "utility-credential-v0" + PackageID = "5a29ead611a0abd5f5b3fc3caf7d0f67c0ff802032ab6d392824aa9060e56d70" + SDKVersion = "3.4.9" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// Claim is a Record type +type Claim struct { + Subject types.TEXT `json:"subject" hex:"bytes"` + Property types.TEXT `json:"property"` + Value types.TEXT `json:"value"` +} + +// ToMap converts Claim to a map for DAML arguments +func (t Claim) ToMap() map[string]any { + m := make(map[string]any) + + m["subject"] = string(t.Subject) + + m["property"] = string(t.Property) + + m["value"] = string(t.Value) + + return m +} + +func (t Claim) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Claim) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Claim to hex string (Canton MCMS format) +func (t Claim) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Claim from hex string (Canton MCMS format) +func (t *Claim) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Credential is a Template type +type Credential struct { + Issuer types.PARTY `json:"issuer"` + Holder types.PARTY `json:"holder"` + Id types.TEXT `json:"id"` + Description types.TEXT `json:"description"` + ValidFrom *types.TIMESTAMP `json:"validFrom" hex:"optional"` + ValidUntil *types.TIMESTAMP `json:"validUntil" hex:"optional"` + Claims []Claim `json:"claims"` + Observers types.SET `json:"observers"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t Credential) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Credential.V0.Credential", "Credential") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t Credential) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Credential.V0.Credential", "Credential") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t Credential) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["issuer"] = t.Issuer.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["id"] = string(t.Id) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["description"] = string(t.Description) + + if t.ValidFrom != nil { + args["validFrom"] = map[string]any{ + "_type": "optional", + "value": *t.ValidFrom, + } + } else { + args["validFrom"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.ValidUntil != nil { + args["validUntil"] = map[string]any{ + "_type": "optional", + "value": *t.ValidUntil, + } + } else { + args["validUntil"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["claims"] = func() []any { + res := make([]any, 0, len(t.Claims)) + for _, e := range t.Claims { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["observers"] = model.NestedToDAMLValue(t.Observers) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t Credential) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["issuer"] = t.Issuer.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["id"] = string(t.Id) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["description"] = string(t.Description) + + if t.ValidFrom != nil { + args["validFrom"] = map[string]any{ + "_type": "optional", + "value": *t.ValidFrom, + } + } else { + args["validFrom"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.ValidUntil != nil { + args["validUntil"] = map[string]any{ + "_type": "optional", + "value": *t.ValidUntil, + } + } else { + args["validUntil"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["claims"] = func() []any { + res := make([]any, 0, len(t.Claims)) + for _, e := range t.Claims { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["observers"] = model.NestedToDAMLValue(t.Observers) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t Credential) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Credential) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Credential to hex string (Canton MCMS format) +func (t Credential) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Credential from hex string (Canton MCMS format) +func (t *Credential) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for Credential + +// CredentialRevoke exercises the Credential_Revoke choice on this Credential contract +// This method uses the package name in the template ID +func (t Credential) CredentialRevoke(contractID string, args CredentialRevoke) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Credential_Revoke", + Arguments: argsToMap(args), + } +} + +// CredentialRevokeWithPackageID exercises the Credential_Revoke choice using the provided package ID instead of package name +func (t Credential) CredentialRevokeWithPackageID(contractID string, packageID string, args CredentialRevoke) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Credential_Revoke", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this Credential contract +// This method uses the package name in the template ID +func (t Credential) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t Credential) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// CredentialGet exercises the Credential_Get choice on this Credential contract +// This method uses the package name in the template ID +func (t Credential) CredentialGet(contractID string, args CredentialGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Credential_Get", + Arguments: argsToMap(args), + } +} + +// CredentialGetWithPackageID exercises the Credential_Get choice using the provided package ID instead of package name +func (t Credential) CredentialGetWithPackageID(contractID string, packageID string, args CredentialGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Credential.V0.Credential", "Credential"), + ContractID: contractID, + Choice: "Credential_Get", + Arguments: argsToMap(args), + } +} + +// CredentialGet is a Record type +type CredentialGet struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts CredentialGet to a map for DAML arguments +func (t CredentialGet) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t CredentialGet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *CredentialGet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes CredentialGet to hex string (Canton MCMS format) +func (t CredentialGet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes CredentialGet from hex string (Canton MCMS format) +func (t *CredentialGet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// CredentialGetResult is a Record type +type CredentialGetResult struct { + Credential Credential `json:"credential"` +} + +// ToMap converts CredentialGetResult to a map for DAML arguments +func (t CredentialGetResult) ToMap() map[string]any { + m := make(map[string]any) + + m["credential"] = model.NestedToDAMLValue(t.Credential) + + return m +} + +func (t CredentialGetResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *CredentialGetResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes CredentialGetResult to hex string (Canton MCMS format) +func (t CredentialGetResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes CredentialGetResult from hex string (Canton MCMS format) +func (t *CredentialGetResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// CredentialRevoke is a Record type +type CredentialRevoke struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts CredentialRevoke to a map for DAML arguments +func (t CredentialRevoke) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t CredentialRevoke) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *CredentialRevoke) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes CredentialRevoke to hex string (Canton MCMS format) +func (t CredentialRevoke) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes CredentialRevoke from hex string (Canton MCMS format) +func (t *CredentialRevoke) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// CredentialRevokeResult is a Record type +type CredentialRevokeResult struct { +} + +// ToMap converts CredentialRevokeResult to a map for DAML arguments +func (t CredentialRevokeResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t CredentialRevokeResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *CredentialRevokeResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes CredentialRevokeResult to hex string (Canton MCMS format) +func (t CredentialRevokeResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes CredentialRevokeResult from hex string (Canton MCMS format) +func (t *CredentialRevokeResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// PartyCredentialRequirement is a Record type +type PartyCredentialRequirement struct { + Issuer types.PARTY `json:"issuer"` + RequiredClaims []Tuple2 `json:"requiredClaims"` +} + +// ToMap converts PartyCredentialRequirement to a map for DAML arguments +func (t PartyCredentialRequirement) ToMap() map[string]any { + m := make(map[string]any) + + m["issuer"] = t.Issuer.ToMap() + + m["requiredClaims"] = func() []any { + res := make([]any, 0, len(t.RequiredClaims)) + for _, e := range t.RequiredClaims { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t PartyCredentialRequirement) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *PartyCredentialRequirement) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes PartyCredentialRequirement to hex string (Canton MCMS format) +func (t PartyCredentialRequirement) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes PartyCredentialRequirement from hex string (Canton MCMS format) +func (t *PartyCredentialRequirement) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithIssuer is a Record type +type WithIssuer struct { + Issuer types.PARTY `json:"issuer"` +} + +// ToMap converts WithIssuer to a map for DAML arguments +func (t WithIssuer) ToMap() map[string]any { + m := make(map[string]any) + + m["issuer"] = t.Issuer.ToMap() + + return m +} + +func (t WithIssuer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithIssuer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithIssuer to hex string (Canton MCMS format) +func (t WithIssuer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithIssuer from hex string (Canton MCMS format) +func (t *WithIssuer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithIssuerHolder is a Record type +type WithIssuerHolder struct { + Issuer types.PARTY `json:"issuer"` + Holder types.PARTY `json:"holder"` +} + +// ToMap converts WithIssuerHolder to a map for DAML arguments +func (t WithIssuerHolder) ToMap() map[string]any { + m := make(map[string]any) + + m["issuer"] = t.Issuer.ToMap() + + m["holder"] = t.Holder.ToMap() + + return m +} + +func (t WithIssuerHolder) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithIssuerHolder) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithIssuerHolder to hex string (Canton MCMS format) +func (t WithIssuerHolder) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithIssuerHolder from hex string (Canton MCMS format) +func (t *WithIssuerHolder) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { + CredentialGet(args CredentialGet) (*bind.EncodedChoice, error) + CredentialRevoke(args CredentialRevoke) (*bind.EncodedChoice, error) +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// CredentialGet encodes parameters for the Credential_Get choice. +func (e *encoder) CredentialGet(args CredentialGet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Credential_Get", args) +} + +// CredentialRevoke encodes parameters for the Credential_Revoke choice. +func (e *encoder) CredentialRevoke(args CredentialRevoke) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Credential_Revoke", args) +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/utility/credential_v0/tuple2.go b/bindings/generated/latest/utility/credential_v0/tuple2.go new file mode 100644 index 000000000..55b71227c --- /dev/null +++ b/bindings/generated/latest/utility/credential_v0/tuple2.go @@ -0,0 +1,8 @@ +package credential_v0 +// Code generated by contracts/cmd/bindings. DO NOT EDIT. + +// Tuple2 mirrors GHC.Tuple from daml-prim (referenced by utility DARs, not emitted by codegen). +type Tuple2 struct { + First any `json:"_1"` + Second any `json:"_2"` +} diff --git a/bindings/generated/latest/utility/registry_app_v0/registry_app_v0.go b/bindings/generated/latest/utility/registry_app_v0/registry_app_v0.go new file mode 100644 index 000000000..80eb294cc --- /dev/null +++ b/bindings/generated/latest/utility/registry_app_v0/registry_app_v0.go @@ -0,0 +1,16484 @@ +package registry_app_v0 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + splice_api_token_allocation_instruction_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_allocation_instruction_v1" + splice_api_token_allocation_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_allocation_v1" + splice_api_token_burn_mint_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_burn_mint_v1" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + splice_api_token_transfer_instruction_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_transfer_instruction_v1" + credential_v0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/credential_v0" + registry_holding_v0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_holding_v0" + registry_v0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_v0" + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "utility-registry-app-v0" + PackageID = "7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab" + SDKVersion = "3.4.9" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// AllocationFactory is a Template type +type AllocationFactory struct { + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Operator types.PARTY `json:"operator"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AllocationFactory) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AllocationFactory) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AllocationFactory) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AllocationFactory) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AllocationFactory) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactory) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactory to hex string (Canton MCMS format) +func (t AllocationFactory) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactory from hex string (Canton MCMS format) +func (t *AllocationFactory) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AllocationFactory + +// AllocationFactoryAllocateInternal exercises the AllocationFactory_AllocateInternal choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryAllocateInternal(contractID string, args AllocationFactoryAllocateInternal) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_AllocateInternal", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryAllocateInternalWithPackageID exercises the AllocationFactory_AllocateInternal choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryAllocateInternalWithPackageID(contractID string, packageID string, args AllocationFactoryAllocateInternal) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_AllocateInternal", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryInternalBurnMint exercises the AllocationFactory_InternalBurnMint choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryInternalBurnMint(contractID string, args AllocationFactoryInternalBurnMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_InternalBurnMint", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryInternalBurnMintWithPackageID exercises the AllocationFactory_InternalBurnMint choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryInternalBurnMintWithPackageID(contractID string, packageID string, args AllocationFactoryInternalBurnMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_InternalBurnMint", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryTransferInternal exercises the AllocationFactory_TransferInternal choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryTransferInternal(contractID string, args AllocationFactoryTransferInternal) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_TransferInternal", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryTransferInternalWithPackageID exercises the AllocationFactory_TransferInternal choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryTransferInternalWithPackageID(contractID string, packageID string, args AllocationFactoryTransferInternal) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_TransferInternal", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryRequestBurn exercises the AllocationFactory_RequestBurn choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryRequestBurn(contractID string, args AllocationFactoryRequestBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_RequestBurn", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryRequestBurnWithPackageID exercises the AllocationFactory_RequestBurn choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryRequestBurnWithPackageID(contractID string, packageID string, args AllocationFactoryRequestBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_RequestBurn", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryOfferBurn exercises the AllocationFactory_OfferBurn choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryOfferBurn(contractID string, args AllocationFactoryOfferBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_OfferBurn", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryOfferBurnWithPackageID exercises the AllocationFactory_OfferBurn choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryOfferBurnWithPackageID(contractID string, packageID string, args AllocationFactoryOfferBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_OfferBurn", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryRequestMint exercises the AllocationFactory_RequestMint choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryRequestMint(contractID string, args AllocationFactoryRequestMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_RequestMint", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryRequestMintWithPackageID exercises the AllocationFactory_RequestMint choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryRequestMintWithPackageID(contractID string, packageID string, args AllocationFactoryRequestMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_RequestMint", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryOfferMint exercises the AllocationFactory_OfferMint choice on this AllocationFactory contract +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryOfferMint(contractID string, args AllocationFactoryOfferMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_OfferMint", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryOfferMintWithPackageID exercises the AllocationFactory_OfferMint choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryOfferMintWithPackageID(contractID string, packageID string, args AllocationFactoryOfferMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_OfferMint", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AllocationFactory contract via the IBurnMintFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AllocationFactory) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferFactoryTransfer exercises the TransferFactory_Transfer choice on this AllocationFactory contract via the ITransferFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) TransferFactoryTransfer(contractID string, args splice_api_token_transfer_instruction_v1.TransferFactoryTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferFactoryTransferWithPackageID exercises the TransferFactory_Transfer choice using the provided package ID instead of package name +func (t AllocationFactory) TransferFactoryTransferWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferFactoryTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferFactoryPublicFetch exercises the TransferFactory_PublicFetch choice on this AllocationFactory contract via the ITransferFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) TransferFactoryPublicFetch(contractID string, args splice_api_token_transfer_instruction_v1.TransferFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// TransferFactoryPublicFetchWithPackageID exercises the TransferFactory_PublicFetch choice using the provided package ID instead of package name +func (t AllocationFactory) TransferFactoryPublicFetchWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryAllocate exercises the AllocationFactory_Allocate choice on this AllocationFactory contract via the IAllocationFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryAllocate(contractID string, args splice_api_token_allocation_instruction_v1.AllocationFactoryAllocate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_Allocate", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryAllocateWithPackageID exercises the AllocationFactory_Allocate choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryAllocateWithPackageID(contractID string, packageID string, args splice_api_token_allocation_instruction_v1.AllocationFactoryAllocate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_Allocate", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryPublicFetch exercises the AllocationFactory_PublicFetch choice on this AllocationFactory contract via the IAllocationFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) AllocationFactoryPublicFetch(contractID string, args splice_api_token_allocation_instruction_v1.AllocationFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// AllocationFactoryPublicFetchWithPackageID exercises the AllocationFactory_PublicFetch choice using the provided package ID instead of package name +func (t AllocationFactory) AllocationFactoryPublicFetchWithPackageID(contractID string, packageID string, args splice_api_token_allocation_instruction_v1.AllocationFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "AllocationFactory"), + ContractID: contractID, + Choice: "AllocationFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// BurnMintFactoryPublicFetch exercises the BurnMintFactory_PublicFetch choice on this AllocationFactory contract via the IBurnMintFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) BurnMintFactoryPublicFetch(contractID string, args splice_api_token_burn_mint_v1.BurnMintFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "BurnMintFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// BurnMintFactoryPublicFetchWithPackageID exercises the BurnMintFactory_PublicFetch choice using the provided package ID instead of package name +func (t AllocationFactory) BurnMintFactoryPublicFetchWithPackageID(contractID string, packageID string, args splice_api_token_burn_mint_v1.BurnMintFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "BurnMintFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// BurnMintFactoryBurnMint exercises the BurnMintFactory_BurnMint choice on this AllocationFactory contract via the IBurnMintFactory interface +// This method uses the package name in the template ID +func (t AllocationFactory) BurnMintFactoryBurnMint(contractID string, args splice_api_token_burn_mint_v1.BurnMintFactoryBurnMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "BurnMintFactory_BurnMint", + Arguments: argsToMap(args), + } +} + +// BurnMintFactoryBurnMintWithPackageID exercises the BurnMintFactory_BurnMint choice using the provided package ID instead of package name +func (t AllocationFactory) BurnMintFactoryBurnMintWithPackageID(contractID string, packageID string, args splice_api_token_burn_mint_v1.BurnMintFactoryBurnMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.AllocationFactory", "BurnMintFactory"), + ContractID: contractID, + Choice: "BurnMintFactory_BurnMint", + Arguments: argsToMap(args), + } +} + +// Verify interface implementations for AllocationFactory + +var _ splice_api_token_transfer_instruction_v1.ITransferFactory = (*AllocationFactory)(nil) + +var _ splice_api_token_allocation_instruction_v1.IAllocationFactory = (*AllocationFactory)(nil) + +var _ splice_api_token_burn_mint_v1.IBurnMintFactory = (*AllocationFactory)(nil) + +// AllocationFactoryAllocateInternal is a Record type +type AllocationFactoryAllocateInternal struct { + Payload splice_api_token_allocation_instruction_v1.AllocationFactoryAllocate `json:"payload"` +} + +// ToMap converts AllocationFactoryAllocateInternal to a map for DAML arguments +func (t AllocationFactoryAllocateInternal) ToMap() map[string]any { + m := make(map[string]any) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t AllocationFactoryAllocateInternal) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryAllocateInternal) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryAllocateInternal to hex string (Canton MCMS format) +func (t AllocationFactoryAllocateInternal) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryAllocateInternal from hex string (Canton MCMS format) +func (t *AllocationFactoryAllocateInternal) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryInternalBurnMint is a Record type +type AllocationFactoryInternalBurnMint struct { + Payload splice_api_token_burn_mint_v1.BurnMintFactoryBurnMint `json:"payload"` +} + +// ToMap converts AllocationFactoryInternalBurnMint to a map for DAML arguments +func (t AllocationFactoryInternalBurnMint) ToMap() map[string]any { + m := make(map[string]any) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t AllocationFactoryInternalBurnMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryInternalBurnMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryInternalBurnMint to hex string (Canton MCMS format) +func (t AllocationFactoryInternalBurnMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryInternalBurnMint from hex string (Canton MCMS format) +func (t *AllocationFactoryInternalBurnMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryOfferBurn is a Record type +type AllocationFactoryOfferBurn struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Burn Burn `json:"burn"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationFactoryOfferBurn to a map for DAML arguments +func (t AllocationFactoryOfferBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["burn"] = model.NestedToDAMLValue(t.Burn) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationFactoryOfferBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryOfferBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryOfferBurn to hex string (Canton MCMS format) +func (t AllocationFactoryOfferBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryOfferBurn from hex string (Canton MCMS format) +func (t *AllocationFactoryOfferBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryOfferBurnResult is a Record type +type AllocationFactoryOfferBurnResult struct { + BurnOfferCid types.CONTRACT_ID `json:"burnOfferCid"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationFactoryOfferBurnResult to a map for DAML arguments +func (t AllocationFactoryOfferBurnResult) ToMap() map[string]any { + m := make(map[string]any) + + m["burnOfferCid"] = model.NestedToDAMLValue(t.BurnOfferCid) + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationFactoryOfferBurnResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryOfferBurnResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryOfferBurnResult to hex string (Canton MCMS format) +func (t AllocationFactoryOfferBurnResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryOfferBurnResult from hex string (Canton MCMS format) +func (t *AllocationFactoryOfferBurnResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryOfferMint is a Record type +type AllocationFactoryOfferMint struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Mint Mint `json:"mint"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationFactoryOfferMint to a map for DAML arguments +func (t AllocationFactoryOfferMint) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["mint"] = model.NestedToDAMLValue(t.Mint) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationFactoryOfferMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryOfferMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryOfferMint to hex string (Canton MCMS format) +func (t AllocationFactoryOfferMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryOfferMint from hex string (Canton MCMS format) +func (t *AllocationFactoryOfferMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryOfferMintResult is a Record type +type AllocationFactoryOfferMintResult struct { + MintOfferCid types.CONTRACT_ID `json:"mintOfferCid"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationFactoryOfferMintResult to a map for DAML arguments +func (t AllocationFactoryOfferMintResult) ToMap() map[string]any { + m := make(map[string]any) + + m["mintOfferCid"] = model.NestedToDAMLValue(t.MintOfferCid) + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationFactoryOfferMintResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryOfferMintResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryOfferMintResult to hex string (Canton MCMS format) +func (t AllocationFactoryOfferMintResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryOfferMintResult from hex string (Canton MCMS format) +func (t *AllocationFactoryOfferMintResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryRequestBurn is a Record type +type AllocationFactoryRequestBurn struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Burn Burn `json:"burn"` + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationFactoryRequestBurn to a map for DAML arguments +func (t AllocationFactoryRequestBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["burn"] = model.NestedToDAMLValue(t.Burn) + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationFactoryRequestBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryRequestBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryRequestBurn to hex string (Canton MCMS format) +func (t AllocationFactoryRequestBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryRequestBurn from hex string (Canton MCMS format) +func (t *AllocationFactoryRequestBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryRequestBurnResult is a Record type +type AllocationFactoryRequestBurnResult struct { + BurnRequestCid types.CONTRACT_ID `json:"burnRequestCid"` + Remaining *types.CONTRACT_ID `json:"remaining" hex:"optional"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationFactoryRequestBurnResult to a map for DAML arguments +func (t AllocationFactoryRequestBurnResult) ToMap() map[string]any { + m := make(map[string]any) + + m["burnRequestCid"] = model.NestedToDAMLValue(t.BurnRequestCid) + + if t.Remaining != nil { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Remaining), + } + } else { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationFactoryRequestBurnResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryRequestBurnResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryRequestBurnResult to hex string (Canton MCMS format) +func (t AllocationFactoryRequestBurnResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryRequestBurnResult from hex string (Canton MCMS format) +func (t *AllocationFactoryRequestBurnResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryRequestMint is a Record type +type AllocationFactoryRequestMint struct { + ExpectedAdmin types.PARTY `json:"expectedAdmin"` + Mint Mint `json:"mint"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts AllocationFactoryRequestMint to a map for DAML arguments +func (t AllocationFactoryRequestMint) ToMap() map[string]any { + m := make(map[string]any) + + m["expectedAdmin"] = t.ExpectedAdmin.ToMap() + + m["mint"] = model.NestedToDAMLValue(t.Mint) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t AllocationFactoryRequestMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryRequestMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryRequestMint to hex string (Canton MCMS format) +func (t AllocationFactoryRequestMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryRequestMint from hex string (Canton MCMS format) +func (t *AllocationFactoryRequestMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryRequestMintResult is a Record type +type AllocationFactoryRequestMintResult struct { + MintRequestCid types.CONTRACT_ID `json:"mintRequestCid"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts AllocationFactoryRequestMintResult to a map for DAML arguments +func (t AllocationFactoryRequestMintResult) ToMap() map[string]any { + m := make(map[string]any) + + m["mintRequestCid"] = model.NestedToDAMLValue(t.MintRequestCid) + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t AllocationFactoryRequestMintResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryRequestMintResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryRequestMintResult to hex string (Canton MCMS format) +func (t AllocationFactoryRequestMintResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryRequestMintResult from hex string (Canton MCMS format) +func (t *AllocationFactoryRequestMintResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AllocationFactoryTransferInternal is a Record type +type AllocationFactoryTransferInternal struct { + Payload splice_api_token_transfer_instruction_v1.TransferFactoryTransfer `json:"payload"` +} + +// ToMap converts AllocationFactoryTransferInternal to a map for DAML arguments +func (t AllocationFactoryTransferInternal) ToMap() map[string]any { + m := make(map[string]any) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t AllocationFactoryTransferInternal) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AllocationFactoryTransferInternal) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AllocationFactoryTransferInternal to hex string (Canton MCMS format) +func (t AllocationFactoryTransferInternal) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AllocationFactoryTransferInternal from hex string (Canton MCMS format) +func (t *AllocationFactoryTransferInternal) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Burn is a Record type +type Burn struct { + InstrumentId splice_api_token_holding_v1.InstrumentId `json:"instrumentId"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + RequestedAt types.TIMESTAMP `json:"requestedAt"` + ExecuteBefore types.TIMESTAMP `json:"executeBefore"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts Burn to a map for DAML arguments +func (t Burn) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentId"] = model.NestedToDAMLValue(t.InstrumentId) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["requestedAt"] = t.RequestedAt + + m["executeBefore"] = t.ExecuteBefore + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t Burn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Burn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Burn to hex string (Canton MCMS format) +func (t Burn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Burn from hex string (Canton MCMS format) +func (t *Burn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOffer is a Template type +type BurnOffer struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Burn Burn `json:"burn"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t BurnOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t BurnOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t BurnOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t BurnOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t BurnOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOffer to hex string (Canton MCMS format) +func (t BurnOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOffer from hex string (Canton MCMS format) +func (t *BurnOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for BurnOffer + +// BurnOfferAccept exercises the BurnOffer_Accept choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferAccept(contractID string, args BurnOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Accept", + Arguments: argsToMap(args), + } +} + +// BurnOfferAcceptWithPackageID exercises the BurnOffer_Accept choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferAcceptWithPackageID(contractID string, packageID string, args BurnOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Accept", + Arguments: argsToMap(args), + } +} + +// BurnOfferReject exercises the BurnOffer_Reject choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferReject(contractID string, args BurnOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Reject", + Arguments: argsToMap(args), + } +} + +// BurnOfferRejectWithPackageID exercises the BurnOffer_Reject choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferRejectWithPackageID(contractID string, packageID string, args BurnOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Reject", + Arguments: argsToMap(args), + } +} + +// BurnOfferCancel exercises the BurnOffer_Cancel choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferCancel(contractID string, args BurnOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// BurnOfferCancelWithPackageID exercises the BurnOffer_Cancel choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferCancelWithPackageID(contractID string, packageID string, args BurnOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t BurnOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// BurnOfferAccept is a Record type +type BurnOfferAccept struct { + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts BurnOfferAccept to a map for DAML arguments +func (t BurnOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t BurnOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferAccept to hex string (Canton MCMS format) +func (t BurnOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferAccept from hex string (Canton MCMS format) +func (t *BurnOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferAcceptResult is a Record type +type BurnOfferAcceptResult struct { + ExecutedBurnCid *types.CONTRACT_ID `json:"executedBurnCid" hex:"optional"` + Remaining *types.CONTRACT_ID `json:"remaining" hex:"optional"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts BurnOfferAcceptResult to a map for DAML arguments +func (t BurnOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.ExecutedBurnCid != nil { + m["executedBurnCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExecutedBurnCid), + } + } else { + m["executedBurnCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.Remaining != nil { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Remaining), + } + } else { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t BurnOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferAcceptResult to hex string (Canton MCMS format) +func (t BurnOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferAcceptResult from hex string (Canton MCMS format) +func (t *BurnOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferCancel is a Record type +type BurnOfferCancel struct { +} + +// ToMap converts BurnOfferCancel to a map for DAML arguments +func (t BurnOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferCancel to hex string (Canton MCMS format) +func (t BurnOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferCancel from hex string (Canton MCMS format) +func (t *BurnOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferCancelResult is a Record type +type BurnOfferCancelResult struct { +} + +// ToMap converts BurnOfferCancelResult to a map for DAML arguments +func (t BurnOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferCancelResult to hex string (Canton MCMS format) +func (t BurnOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferCancelResult from hex string (Canton MCMS format) +func (t *BurnOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferReject is a Record type +type BurnOfferReject struct { + Reason types.TEXT `json:"reason"` + ExtraArgs *splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs" hex:"optional"` +} + +// ToMap converts BurnOfferReject to a map for DAML arguments +func (t BurnOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + if t.ExtraArgs != nil { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExtraArgs), + } + } else { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t BurnOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferReject to hex string (Canton MCMS format) +func (t BurnOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferReject from hex string (Canton MCMS format) +func (t *BurnOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferRejectResult is a Record type +type BurnOfferRejectResult struct { + RejectedBurnCid *types.CONTRACT_ID `json:"rejectedBurnCid" hex:"optional"` +} + +// ToMap converts BurnOfferRejectResult to a map for DAML arguments +func (t BurnOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.RejectedBurnCid != nil { + m["rejectedBurnCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.RejectedBurnCid), + } + } else { + m["rejectedBurnCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t BurnOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferRejectResult to hex string (Canton MCMS format) +func (t BurnOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferRejectResult from hex string (Canton MCMS format) +func (t *BurnOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequest is a Template type +type BurnRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Burn Burn `json:"burn"` + LockedHoldingCid types.CONTRACT_ID `json:"lockedHoldingCid"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t BurnRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t BurnRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t BurnRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lockedHoldingCid"] = model.NestedToDAMLValue(t.LockedHoldingCid) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t BurnRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lockedHoldingCid"] = model.NestedToDAMLValue(t.LockedHoldingCid) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t BurnRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequest to hex string (Canton MCMS format) +func (t BurnRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequest from hex string (Canton MCMS format) +func (t *BurnRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for BurnRequest + +// BurnRequestAccept exercises the BurnRequest_Accept choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestAccept(contractID string, args BurnRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Accept", + Arguments: argsToMap(args), + } +} + +// BurnRequestAcceptWithPackageID exercises the BurnRequest_Accept choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestAcceptWithPackageID(contractID string, packageID string, args BurnRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Accept", + Arguments: argsToMap(args), + } +} + +// BurnRequestReject exercises the BurnRequest_Reject choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestReject(contractID string, args BurnRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Reject", + Arguments: argsToMap(args), + } +} + +// BurnRequestRejectWithPackageID exercises the BurnRequest_Reject choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestRejectWithPackageID(contractID string, packageID string, args BurnRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Reject", + Arguments: argsToMap(args), + } +} + +// BurnRequestCancel exercises the BurnRequest_Cancel choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestCancel(contractID string, args BurnRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// BurnRequestCancelWithPackageID exercises the BurnRequest_Cancel choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestCancelWithPackageID(contractID string, packageID string, args BurnRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t BurnRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// BurnRequestAccept is a Record type +type BurnRequestAccept struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts BurnRequestAccept to a map for DAML arguments +func (t BurnRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t BurnRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestAccept to hex string (Canton MCMS format) +func (t BurnRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestAccept from hex string (Canton MCMS format) +func (t *BurnRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestAcceptResult is a Record type +type BurnRequestAcceptResult struct { + ExecutedBurnCid *types.CONTRACT_ID `json:"executedBurnCid" hex:"optional"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts BurnRequestAcceptResult to a map for DAML arguments +func (t BurnRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.ExecutedBurnCid != nil { + m["executedBurnCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExecutedBurnCid), + } + } else { + m["executedBurnCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t BurnRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestAcceptResult to hex string (Canton MCMS format) +func (t BurnRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestAcceptResult from hex string (Canton MCMS format) +func (t *BurnRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestCancel is a Record type +type BurnRequestCancel struct { +} + +// ToMap converts BurnRequestCancel to a map for DAML arguments +func (t BurnRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestCancel to hex string (Canton MCMS format) +func (t BurnRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestCancel from hex string (Canton MCMS format) +func (t *BurnRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestCancelResult is a Record type +type BurnRequestCancelResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts BurnRequestCancelResult to a map for DAML arguments +func (t BurnRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t BurnRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestCancelResult to hex string (Canton MCMS format) +func (t BurnRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestCancelResult from hex string (Canton MCMS format) +func (t *BurnRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestReject is a Record type +type BurnRequestReject struct { + Reason types.TEXT `json:"reason"` + ExtraArgs *splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs" hex:"optional"` +} + +// ToMap converts BurnRequestReject to a map for DAML arguments +func (t BurnRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + if t.ExtraArgs != nil { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExtraArgs), + } + } else { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t BurnRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestReject to hex string (Canton MCMS format) +func (t BurnRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestReject from hex string (Canton MCMS format) +func (t *BurnRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestRejectResult is a Record type +type BurnRequestRejectResult struct { + RejectedBurnCid *types.CONTRACT_ID `json:"rejectedBurnCid" hex:"optional"` + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts BurnRequestRejectResult to a map for DAML arguments +func (t BurnRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.RejectedBurnCid != nil { + m["rejectedBurnCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.RejectedBurnCid), + } + } else { + m["rejectedBurnCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t BurnRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestRejectResult to hex string (Canton MCMS format) +func (t BurnRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestRejectResult from hex string (Canton MCMS format) +func (t *BurnRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementService is a Template type +type EnforcementService struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t EnforcementService) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t EnforcementService) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t EnforcementService) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t EnforcementService) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t EnforcementService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementService to hex string (Canton MCMS format) +func (t EnforcementService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementService from hex string (Canton MCMS format) +func (t *EnforcementService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for EnforcementService + +// EnforcementServiceTerminate exercises the EnforcementService_Terminate choice on this EnforcementService contract +// This method uses the package name in the template ID +func (t EnforcementService) EnforcementServiceTerminate(contractID string, args EnforcementServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_Terminate", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceTerminateWithPackageID exercises the EnforcementService_Terminate choice using the provided package ID instead of package name +func (t EnforcementService) EnforcementServiceTerminateWithPackageID(contractID string, packageID string, args EnforcementServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_Terminate", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceAcceptForceTransferRequest exercises the EnforcementService_AcceptForceTransferRequest choice on this EnforcementService contract +// This method uses the package name in the template ID +func (t EnforcementService) EnforcementServiceAcceptForceTransferRequest(contractID string, args EnforcementServiceAcceptForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_AcceptForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceAcceptForceTransferRequestWithPackageID exercises the EnforcementService_AcceptForceTransferRequest choice using the provided package ID instead of package name +func (t EnforcementService) EnforcementServiceAcceptForceTransferRequestWithPackageID(contractID string, packageID string, args EnforcementServiceAcceptForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_AcceptForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization exercises the EnforcementService_AcceptForceTransferRequestWithSenderAuthorization choice on this EnforcementService contract +// This method uses the package name in the template ID +func (t EnforcementService) EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization(contractID string, args EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_AcceptForceTransferRequestWithSenderAuthorization", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceAcceptForceTransferRequestWithSenderAuthorizationWithPackageID exercises the EnforcementService_AcceptForceTransferRequestWithSenderAuthorization choice using the provided package ID instead of package name +func (t EnforcementService) EnforcementServiceAcceptForceTransferRequestWithSenderAuthorizationWithPackageID(contractID string, packageID string, args EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "EnforcementService_AcceptForceTransferRequestWithSenderAuthorization", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this EnforcementService contract +// This method uses the package name in the template ID +func (t EnforcementService) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t EnforcementService) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// EnforcementServiceRequest is a Template type +type EnforcementServiceRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t EnforcementServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t EnforcementServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t EnforcementServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t EnforcementServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t EnforcementServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequest to hex string (Canton MCMS format) +func (t EnforcementServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequest from hex string (Canton MCMS format) +func (t *EnforcementServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for EnforcementServiceRequest + +// EnforcementServiceRequestAccept exercises the EnforcementServiceRequest_Accept choice on this EnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t EnforcementServiceRequest) EnforcementServiceRequestAccept(contractID string, args EnforcementServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceRequestAcceptWithPackageID exercises the EnforcementServiceRequest_Accept choice using the provided package ID instead of package name +func (t EnforcementServiceRequest) EnforcementServiceRequestAcceptWithPackageID(contractID string, packageID string, args EnforcementServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceRequestReject exercises the EnforcementServiceRequest_Reject choice on this EnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t EnforcementServiceRequest) EnforcementServiceRequestReject(contractID string, args EnforcementServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceRequestRejectWithPackageID exercises the EnforcementServiceRequest_Reject choice using the provided package ID instead of package name +func (t EnforcementServiceRequest) EnforcementServiceRequestRejectWithPackageID(contractID string, packageID string, args EnforcementServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceRequestCancel exercises the EnforcementServiceRequest_Cancel choice on this EnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t EnforcementServiceRequest) EnforcementServiceRequestCancel(contractID string, args EnforcementServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// EnforcementServiceRequestCancelWithPackageID exercises the EnforcementServiceRequest_Cancel choice using the provided package ID instead of package name +func (t EnforcementServiceRequest) EnforcementServiceRequestCancelWithPackageID(contractID string, packageID string, args EnforcementServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "EnforcementServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this EnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t EnforcementServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t EnforcementServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "EnforcementServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// EnforcementServiceRequestAccept is a Record type +type EnforcementServiceRequestAccept struct { + RegistrarConfigurationCid types.CONTRACT_ID `json:"registrarConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` +} + +// ToMap converts EnforcementServiceRequestAccept to a map for DAML arguments +func (t EnforcementServiceRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarConfigurationCid"] = model.NestedToDAMLValue(t.RegistrarConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t EnforcementServiceRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestAccept to hex string (Canton MCMS format) +func (t EnforcementServiceRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestAccept from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceRequestAcceptResult is a Record type +type EnforcementServiceRequestAcceptResult struct { + EnforcementServiceCid types.CONTRACT_ID `json:"enforcementServiceCid"` +} + +// ToMap converts EnforcementServiceRequestAcceptResult to a map for DAML arguments +func (t EnforcementServiceRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["enforcementServiceCid"] = model.NestedToDAMLValue(t.EnforcementServiceCid) + + return m +} + +func (t EnforcementServiceRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestAcceptResult to hex string (Canton MCMS format) +func (t EnforcementServiceRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestAcceptResult from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceRequestCancel is a Record type +type EnforcementServiceRequestCancel struct { +} + +// ToMap converts EnforcementServiceRequestCancel to a map for DAML arguments +func (t EnforcementServiceRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t EnforcementServiceRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestCancel to hex string (Canton MCMS format) +func (t EnforcementServiceRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestCancel from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceRequestCancelResult is a Record type +type EnforcementServiceRequestCancelResult struct { +} + +// ToMap converts EnforcementServiceRequestCancelResult to a map for DAML arguments +func (t EnforcementServiceRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t EnforcementServiceRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestCancelResult to hex string (Canton MCMS format) +func (t EnforcementServiceRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestCancelResult from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceRequestReject is a Record type +type EnforcementServiceRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts EnforcementServiceRequestReject to a map for DAML arguments +func (t EnforcementServiceRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t EnforcementServiceRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestReject to hex string (Canton MCMS format) +func (t EnforcementServiceRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestReject from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceRequestRejectResult is a Record type +type EnforcementServiceRequestRejectResult struct { + RejectedEnforcementServiceRequestCid types.CONTRACT_ID `json:"rejectedEnforcementServiceRequestCid"` +} + +// ToMap converts EnforcementServiceRequestRejectResult to a map for DAML arguments +func (t EnforcementServiceRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedEnforcementServiceRequestCid"] = model.NestedToDAMLValue(t.RejectedEnforcementServiceRequestCid) + + return m +} + +func (t EnforcementServiceRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceRequestRejectResult to hex string (Canton MCMS format) +func (t EnforcementServiceRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceRequestRejectResult from hex string (Canton MCMS format) +func (t *EnforcementServiceRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceAcceptForceTransferRequest is a Record type +type EnforcementServiceAcceptForceTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ForceTransferRequestAccept `json:"payload"` + ReceiverEnforcementServiceCid types.CONTRACT_ID `json:"receiverEnforcementServiceCid"` +} + +// ToMap converts EnforcementServiceAcceptForceTransferRequest to a map for DAML arguments +func (t EnforcementServiceAcceptForceTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + m["receiverEnforcementServiceCid"] = model.NestedToDAMLValue(t.ReceiverEnforcementServiceCid) + + return m +} + +func (t EnforcementServiceAcceptForceTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceAcceptForceTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceAcceptForceTransferRequest to hex string (Canton MCMS format) +func (t EnforcementServiceAcceptForceTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceAcceptForceTransferRequest from hex string (Canton MCMS format) +func (t *EnforcementServiceAcceptForceTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization is a Record type +type EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ForceTransferRequestAccept `json:"payload"` + Sender types.PARTY `json:"sender"` +} + +// ToMap converts EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization to a map for DAML arguments +func (t EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + m["sender"] = t.Sender.ToMap() + + return m +} + +func (t EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization to hex string (Canton MCMS format) +func (t EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization from hex string (Canton MCMS format) +func (t *EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceTerminate is a Record type +type EnforcementServiceTerminate struct { +} + +// ToMap converts EnforcementServiceTerminate to a map for DAML arguments +func (t EnforcementServiceTerminate) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t EnforcementServiceTerminate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceTerminate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceTerminate to hex string (Canton MCMS format) +func (t EnforcementServiceTerminate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceTerminate from hex string (Canton MCMS format) +func (t *EnforcementServiceTerminate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// EnforcementServiceTerminateResult is a Record type +type EnforcementServiceTerminateResult struct { +} + +// ToMap converts EnforcementServiceTerminateResult to a map for DAML arguments +func (t EnforcementServiceTerminateResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t EnforcementServiceTerminateResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *EnforcementServiceTerminateResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes EnforcementServiceTerminateResult to hex string (Canton MCMS format) +func (t EnforcementServiceTerminateResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes EnforcementServiceTerminateResult from hex string (Canton MCMS format) +func (t *EnforcementServiceTerminateResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedBurn is a Template type +type ExecutedBurn struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Burn Burn `json:"burn"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurn to hex string (Canton MCMS format) +func (t ExecutedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurn from hex string (Canton MCMS format) +func (t *ExecutedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedBurn + +// ExecutedBurnDelete exercises the ExecutedBurn_Delete choice on this ExecutedBurn contract +// This method uses the package name in the template ID +func (t ExecutedBurn) ExecutedBurnDelete(contractID string, args ExecutedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedBurnDeleteWithPackageID exercises the ExecutedBurn_Delete choice using the provided package ID instead of package name +func (t ExecutedBurn) ExecutedBurnDeleteWithPackageID(contractID string, packageID string, args ExecutedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedBurn contract +// This method uses the package name in the template ID +func (t ExecutedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedBurnDelete is a Record type +type ExecutedBurnDelete struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedBurnDelete to a map for DAML arguments +func (t ExecutedBurnDelete) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedBurnDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurnDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurnDelete to hex string (Canton MCMS format) +func (t ExecutedBurnDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurnDelete from hex string (Canton MCMS format) +func (t *ExecutedBurnDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedBurnDeleteResult is a Record type +type ExecutedBurnDeleteResult struct { +} + +// ToMap converts ExecutedBurnDeleteResult to a map for DAML arguments +func (t ExecutedBurnDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedBurnDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurnDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurnDeleteResult to hex string (Canton MCMS format) +func (t ExecutedBurnDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurnDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedBurnDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedMint is a Template type +type ExecutedMint struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Mint Mint `json:"mint"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMint to hex string (Canton MCMS format) +func (t ExecutedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMint from hex string (Canton MCMS format) +func (t *ExecutedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedMint + +// ExecutedMintDelete exercises the ExecutedMint_Delete choice on this ExecutedMint contract +// This method uses the package name in the template ID +func (t ExecutedMint) ExecutedMintDelete(contractID string, args ExecutedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedMintDeleteWithPackageID exercises the ExecutedMint_Delete choice using the provided package ID instead of package name +func (t ExecutedMint) ExecutedMintDeleteWithPackageID(contractID string, packageID string, args ExecutedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedMint contract +// This method uses the package name in the template ID +func (t ExecutedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedMintDelete is a Record type +type ExecutedMintDelete struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedMintDelete to a map for DAML arguments +func (t ExecutedMintDelete) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedMintDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMintDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMintDelete to hex string (Canton MCMS format) +func (t ExecutedMintDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMintDelete from hex string (Canton MCMS format) +func (t *ExecutedMintDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedMintDeleteResult is a Record type +type ExecutedMintDeleteResult struct { +} + +// ToMap converts ExecutedMintDeleteResult to a map for DAML arguments +func (t ExecutedMintDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedMintDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMintDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMintDeleteResult to hex string (Canton MCMS format) +func (t ExecutedMintDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMintDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedMintDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderService is a Template type +type HolderService struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Holder types.PARTY `json:"holder"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t HolderService) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t HolderService) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t HolderService) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t HolderService) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t HolderService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderService to hex string (Canton MCMS format) +func (t HolderService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderService from hex string (Canton MCMS format) +func (t *HolderService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for HolderService + +// HolderServiceClean exercises the HolderService_Clean choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceClean(contractID string, args HolderServiceClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_Clean", + Arguments: argsToMap(args), + } +} + +// HolderServiceCleanWithPackageID exercises the HolderService_Clean choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCleanWithPackageID(contractID string, packageID string, args HolderServiceClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_Clean", + Arguments: argsToMap(args), + } +} + +// HolderServiceTerminate exercises the HolderService_Terminate choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceTerminate(contractID string, args HolderServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_Terminate", + Arguments: argsToMap(args), + } +} + +// HolderServiceTerminateWithPackageID exercises the HolderService_Terminate choice using the provided package ID instead of package name +func (t HolderService) HolderServiceTerminateWithPackageID(contractID string, packageID string, args HolderServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_Terminate", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestEnforcementService exercises the HolderService_RequestEnforcementService choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestEnforcementService(contractID string, args HolderServiceRequestEnforcementService) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestEnforcementService", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestEnforcementServiceWithPackageID exercises the HolderService_RequestEnforcementService choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestEnforcementServiceWithPackageID(contractID string, packageID string, args HolderServiceRequestEnforcementService) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestEnforcementService", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelEnforcementServiceRequest exercises the HolderService_CancelEnforcementServiceRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelEnforcementServiceRequest(contractID string, args HolderServiceCancelEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelEnforcementServiceRequestWithPackageID exercises the HolderService_CancelEnforcementServiceRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelEnforcementServiceRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestForceTransfer exercises the HolderService_RequestForceTransfer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestForceTransfer(contractID string, args HolderServiceRequestForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestForceTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestForceTransferWithPackageID exercises the HolderService_RequestForceTransfer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestForceTransferWithPackageID(contractID string, packageID string, args HolderServiceRequestForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestForceTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelForceTransferRequest exercises the HolderService_CancelForceTransferRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelForceTransferRequest(contractID string, args HolderServiceCancelForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelForceTransferRequestWithPackageID exercises the HolderService_CancelForceTransferRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelForceTransferRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestMint exercises the HolderService_RequestMint choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestMint(contractID string, args HolderServiceRequestMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestMint", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestMintWithPackageID exercises the HolderService_RequestMint choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestMintWithPackageID(contractID string, packageID string, args HolderServiceRequestMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestMint", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelMintRequest exercises the HolderService_CancelMintRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelMintRequest(contractID string, args HolderServiceCancelMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelMintRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelMintRequestWithPackageID exercises the HolderService_CancelMintRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelMintRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelMintRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptMintOffer exercises the HolderService_AcceptMintOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptMintOffer(contractID string, args HolderServiceAcceptMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptMintOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptMintOfferWithPackageID exercises the HolderService_AcceptMintOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptMintOfferWithPackageID(contractID string, packageID string, args HolderServiceAcceptMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptMintOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectMintOffer exercises the HolderService_RejectMintOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectMintOffer(contractID string, args HolderServiceRejectMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectMintOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectMintOfferWithPackageID exercises the HolderService_RejectMintOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectMintOfferWithPackageID(contractID string, packageID string, args HolderServiceRejectMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectMintOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestBurn exercises the HolderService_RequestBurn choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestBurn(contractID string, args HolderServiceRequestBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestBurn", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestBurnWithPackageID exercises the HolderService_RequestBurn choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestBurnWithPackageID(contractID string, packageID string, args HolderServiceRequestBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestBurn", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelBurnRequest exercises the HolderService_CancelBurnRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelBurnRequest(contractID string, args HolderServiceCancelBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelBurnRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelBurnRequestWithPackageID exercises the HolderService_CancelBurnRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelBurnRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelBurnRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptBurnOffer exercises the HolderService_AcceptBurnOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptBurnOffer(contractID string, args HolderServiceAcceptBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptBurnOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptBurnOfferWithPackageID exercises the HolderService_AcceptBurnOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptBurnOfferWithPackageID(contractID string, packageID string, args HolderServiceAcceptBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptBurnOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectBurnOffer exercises the HolderService_RejectBurnOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectBurnOffer(contractID string, args HolderServiceRejectBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectBurnOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectBurnOfferWithPackageID exercises the HolderService_RejectBurnOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectBurnOfferWithPackageID(contractID string, packageID string, args HolderServiceRejectBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectBurnOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferTransfer exercises the HolderService_OfferTransfer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceOfferTransfer(contractID string, args HolderServiceOfferTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferTransferWithPackageID exercises the HolderService_OfferTransfer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceOfferTransferWithPackageID(contractID string, packageID string, args HolderServiceOfferTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelTransferOffer exercises the HolderService_CancelTransferOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelTransferOffer(contractID string, args HolderServiceCancelTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelTransferOfferWithPackageID exercises the HolderService_CancelTransferOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelTransferOfferWithPackageID(contractID string, packageID string, args HolderServiceCancelTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptTransferOffer exercises the HolderService_AcceptTransferOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptTransferOffer(contractID string, args HolderServiceAcceptTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptTransferOfferWithPackageID exercises the HolderService_AcceptTransferOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptTransferOfferWithPackageID(contractID string, packageID string, args HolderServiceAcceptTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectTransferOffer exercises the HolderService_RejectTransferOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectTransferOffer(contractID string, args HolderServiceRejectTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectTransferOfferWithPackageID exercises the HolderService_RejectTransferOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectTransferOfferWithPackageID(contractID string, packageID string, args HolderServiceRejectTransferOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectTransferOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestTransfer exercises the HolderService_RequestTransfer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestTransfer(contractID string, args HolderServiceRequestTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestTransferWithPackageID exercises the HolderService_RequestTransfer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestTransferWithPackageID(contractID string, packageID string, args HolderServiceRequestTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestTransfer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelTransferRequest exercises the HolderService_CancelTransferRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelTransferRequest(contractID string, args HolderServiceCancelTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelTransferRequestWithPackageID exercises the HolderService_CancelTransferRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelTransferRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptTransferRequest exercises the HolderService_AcceptTransferRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptTransferRequest(contractID string, args HolderServiceAcceptTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptTransferRequestWithPackageID exercises the HolderService_AcceptTransferRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptTransferRequestWithPackageID(contractID string, packageID string, args HolderServiceAcceptTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectTransferRequest exercises the HolderService_RejectTransferRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectTransferRequest(contractID string, args HolderServiceRejectTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectTransferRequestWithPackageID exercises the HolderService_RejectTransferRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectTransferRequestWithPackageID(contractID string, packageID string, args HolderServiceRejectTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectTransferRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferLock exercises the HolderService_OfferLock choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceOfferLock(contractID string, args HolderServiceOfferLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferLock", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferLockWithPackageID exercises the HolderService_OfferLock choice using the provided package ID instead of package name +func (t HolderService) HolderServiceOfferLockWithPackageID(contractID string, packageID string, args HolderServiceOfferLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferLock", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelLockOffer exercises the HolderService_CancelLockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelLockOffer(contractID string, args HolderServiceCancelLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelLockOfferWithPackageID exercises the HolderService_CancelLockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelLockOfferWithPackageID(contractID string, packageID string, args HolderServiceCancelLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptLockOffer exercises the HolderService_AcceptLockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptLockOffer(contractID string, args HolderServiceAcceptLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptLockOfferWithPackageID exercises the HolderService_AcceptLockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptLockOfferWithPackageID(contractID string, packageID string, args HolderServiceAcceptLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectLockOffer exercises the HolderService_RejectLockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectLockOffer(contractID string, args HolderServiceRejectLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectLockOfferWithPackageID exercises the HolderService_RejectLockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectLockOfferWithPackageID(contractID string, packageID string, args HolderServiceRejectLockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectLockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestLock exercises the HolderService_RequestLock choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestLock(contractID string, args HolderServiceRequestLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestLock", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestLockWithPackageID exercises the HolderService_RequestLock choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestLockWithPackageID(contractID string, packageID string, args HolderServiceRequestLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestLock", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelLockRequest exercises the HolderService_CancelLockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelLockRequest(contractID string, args HolderServiceCancelLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelLockRequestWithPackageID exercises the HolderService_CancelLockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelLockRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptLockRequest exercises the HolderService_AcceptLockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptLockRequest(contractID string, args HolderServiceAcceptLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptLockRequestWithPackageID exercises the HolderService_AcceptLockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptLockRequestWithPackageID(contractID string, packageID string, args HolderServiceAcceptLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectLockRequest exercises the HolderService_RejectLockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectLockRequest(contractID string, args HolderServiceRejectLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectLockRequestWithPackageID exercises the HolderService_RejectLockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectLockRequestWithPackageID(contractID string, packageID string, args HolderServiceRejectLockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectLockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferUnlock exercises the HolderService_OfferUnlock choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceOfferUnlock(contractID string, args HolderServiceOfferUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferUnlock", + Arguments: argsToMap(args), + } +} + +// HolderServiceOfferUnlockWithPackageID exercises the HolderService_OfferUnlock choice using the provided package ID instead of package name +func (t HolderService) HolderServiceOfferUnlockWithPackageID(contractID string, packageID string, args HolderServiceOfferUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_OfferUnlock", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelUnlockOffer exercises the HolderService_CancelUnlockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelUnlockOffer(contractID string, args HolderServiceCancelUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelUnlockOfferWithPackageID exercises the HolderService_CancelUnlockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelUnlockOfferWithPackageID(contractID string, packageID string, args HolderServiceCancelUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptUnlockOffer exercises the HolderService_AcceptUnlockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptUnlockOffer(contractID string, args HolderServiceAcceptUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptUnlockOfferWithPackageID exercises the HolderService_AcceptUnlockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptUnlockOfferWithPackageID(contractID string, packageID string, args HolderServiceAcceptUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectUnlockOffer exercises the HolderService_RejectUnlockOffer choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectUnlockOffer(contractID string, args HolderServiceRejectUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectUnlockOfferWithPackageID exercises the HolderService_RejectUnlockOffer choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectUnlockOfferWithPackageID(contractID string, packageID string, args HolderServiceRejectUnlockOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectUnlockOffer", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestUnlock exercises the HolderService_RequestUnlock choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRequestUnlock(contractID string, args HolderServiceRequestUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestUnlock", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestUnlockWithPackageID exercises the HolderService_RequestUnlock choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRequestUnlockWithPackageID(contractID string, packageID string, args HolderServiceRequestUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RequestUnlock", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelUnlockRequest exercises the HolderService_CancelUnlockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCancelUnlockRequest(contractID string, args HolderServiceCancelUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCancelUnlockRequestWithPackageID exercises the HolderService_CancelUnlockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCancelUnlockRequestWithPackageID(contractID string, packageID string, args HolderServiceCancelUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CancelUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptUnlockRequest exercises the HolderService_AcceptUnlockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceAcceptUnlockRequest(contractID string, args HolderServiceAcceptUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceAcceptUnlockRequestWithPackageID exercises the HolderService_AcceptUnlockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceAcceptUnlockRequestWithPackageID(contractID string, packageID string, args HolderServiceAcceptUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_AcceptUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectUnlockRequest exercises the HolderService_RejectUnlockRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectUnlockRequest(contractID string, args HolderServiceRejectUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectUnlockRequestWithPackageID exercises the HolderService_RejectUnlockRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectUnlockRequestWithPackageID(contractID string, packageID string, args HolderServiceRejectUnlockRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectUnlockRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceCreateAllocation exercises the HolderService_CreateAllocation choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceCreateAllocation(contractID string, args HolderServiceCreateAllocation) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CreateAllocation", + Arguments: argsToMap(args), + } +} + +// HolderServiceCreateAllocationWithPackageID exercises the HolderService_CreateAllocation choice using the provided package ID instead of package name +func (t HolderService) HolderServiceCreateAllocationWithPackageID(contractID string, packageID string, args HolderServiceCreateAllocation) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_CreateAllocation", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectAllocationRequest exercises the HolderService_RejectAllocationRequest choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) HolderServiceRejectAllocationRequest(contractID string, args HolderServiceRejectAllocationRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectAllocationRequest", + Arguments: argsToMap(args), + } +} + +// HolderServiceRejectAllocationRequestWithPackageID exercises the HolderService_RejectAllocationRequest choice using the provided package ID instead of package name +func (t HolderService) HolderServiceRejectAllocationRequestWithPackageID(contractID string, packageID string, args HolderServiceRejectAllocationRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "HolderService_RejectAllocationRequest", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this HolderService contract +// This method uses the package name in the template ID +func (t HolderService) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t HolderService) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// HolderServiceRequest is a Template type +type HolderServiceRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Holder types.PARTY `json:"holder"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t HolderServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t HolderServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t HolderServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t HolderServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holder"] = t.Holder.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t HolderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequest to hex string (Canton MCMS format) +func (t HolderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequest from hex string (Canton MCMS format) +func (t *HolderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for HolderServiceRequest + +// HolderServiceRequestClean exercises the HolderServiceRequest_Clean choice on this HolderServiceRequest contract +// This method uses the package name in the template ID +func (t HolderServiceRequest) HolderServiceRequestClean(contractID string, args HolderServiceRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Clean", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestCleanWithPackageID exercises the HolderServiceRequest_Clean choice using the provided package ID instead of package name +func (t HolderServiceRequest) HolderServiceRequestCleanWithPackageID(contractID string, packageID string, args HolderServiceRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Clean", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestAccept exercises the HolderServiceRequest_Accept choice on this HolderServiceRequest contract +// This method uses the package name in the template ID +func (t HolderServiceRequest) HolderServiceRequestAccept(contractID string, args HolderServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestAcceptWithPackageID exercises the HolderServiceRequest_Accept choice using the provided package ID instead of package name +func (t HolderServiceRequest) HolderServiceRequestAcceptWithPackageID(contractID string, packageID string, args HolderServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestReject exercises the HolderServiceRequest_Reject choice on this HolderServiceRequest contract +// This method uses the package name in the template ID +func (t HolderServiceRequest) HolderServiceRequestReject(contractID string, args HolderServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestRejectWithPackageID exercises the HolderServiceRequest_Reject choice using the provided package ID instead of package name +func (t HolderServiceRequest) HolderServiceRequestRejectWithPackageID(contractID string, packageID string, args HolderServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestCancel exercises the HolderServiceRequest_Cancel choice on this HolderServiceRequest contract +// This method uses the package name in the template ID +func (t HolderServiceRequest) HolderServiceRequestCancel(contractID string, args HolderServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// HolderServiceRequestCancelWithPackageID exercises the HolderServiceRequest_Cancel choice using the provided package ID instead of package name +func (t HolderServiceRequest) HolderServiceRequestCancelWithPackageID(contractID string, packageID string, args HolderServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "HolderServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this HolderServiceRequest contract +// This method uses the package name in the template ID +func (t HolderServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t HolderServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "HolderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// HolderServiceRequestAccept is a Record type +type HolderServiceRequestAccept struct { + ProviderConfigurationCid types.CONTRACT_ID `json:"providerConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` +} + +// ToMap converts HolderServiceRequestAccept to a map for DAML arguments +func (t HolderServiceRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["providerConfigurationCid"] = model.NestedToDAMLValue(t.ProviderConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t HolderServiceRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestAccept to hex string (Canton MCMS format) +func (t HolderServiceRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestAccept from hex string (Canton MCMS format) +func (t *HolderServiceRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestAcceptResult is a Record type +type HolderServiceRequestAcceptResult struct { + HolderServiceCid types.CONTRACT_ID `json:"holderServiceCid"` +} + +// ToMap converts HolderServiceRequestAcceptResult to a map for DAML arguments +func (t HolderServiceRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holderServiceCid"] = model.NestedToDAMLValue(t.HolderServiceCid) + + return m +} + +func (t HolderServiceRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestAcceptResult to hex string (Canton MCMS format) +func (t HolderServiceRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestAcceptResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestCancel is a Record type +type HolderServiceRequestCancel struct { +} + +// ToMap converts HolderServiceRequestCancel to a map for DAML arguments +func (t HolderServiceRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t HolderServiceRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestCancel to hex string (Canton MCMS format) +func (t HolderServiceRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestCancel from hex string (Canton MCMS format) +func (t *HolderServiceRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestCancelResult is a Record type +type HolderServiceRequestCancelResult struct { +} + +// ToMap converts HolderServiceRequestCancelResult to a map for DAML arguments +func (t HolderServiceRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t HolderServiceRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestCancelResult to hex string (Canton MCMS format) +func (t HolderServiceRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestCancelResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestClean is a Record type +type HolderServiceRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts HolderServiceRequestClean to a map for DAML arguments +func (t HolderServiceRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t HolderServiceRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestClean to hex string (Canton MCMS format) +func (t HolderServiceRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestClean from hex string (Canton MCMS format) +func (t *HolderServiceRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestReject is a Record type +type HolderServiceRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts HolderServiceRequestReject to a map for DAML arguments +func (t HolderServiceRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t HolderServiceRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestReject to hex string (Canton MCMS format) +func (t HolderServiceRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestReject from hex string (Canton MCMS format) +func (t *HolderServiceRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestRejectResult is a Record type +type HolderServiceRequestRejectResult struct { + RejectedHolderServiceRequestCid types.CONTRACT_ID `json:"rejectedHolderServiceRequestCid"` +} + +// ToMap converts HolderServiceRequestRejectResult to a map for DAML arguments +func (t HolderServiceRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedHolderServiceRequestCid"] = model.NestedToDAMLValue(t.RejectedHolderServiceRequestCid) + + return m +} + +func (t HolderServiceRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestRejectResult to hex string (Canton MCMS format) +func (t HolderServiceRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestRejectResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptBurnOffer is a Record type +type HolderServiceAcceptBurnOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnOfferAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptBurnOffer to a map for DAML arguments +func (t HolderServiceAcceptBurnOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptBurnOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptBurnOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptBurnOffer to hex string (Canton MCMS format) +func (t HolderServiceAcceptBurnOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptBurnOffer from hex string (Canton MCMS format) +func (t *HolderServiceAcceptBurnOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptLockOffer is a Record type +type HolderServiceAcceptLockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockOfferAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptLockOffer to a map for DAML arguments +func (t HolderServiceAcceptLockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptLockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptLockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptLockOffer to hex string (Canton MCMS format) +func (t HolderServiceAcceptLockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptLockOffer from hex string (Canton MCMS format) +func (t *HolderServiceAcceptLockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptLockRequest is a Record type +type HolderServiceAcceptLockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockRequestAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptLockRequest to a map for DAML arguments +func (t HolderServiceAcceptLockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptLockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptLockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptLockRequest to hex string (Canton MCMS format) +func (t HolderServiceAcceptLockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptLockRequest from hex string (Canton MCMS format) +func (t *HolderServiceAcceptLockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptMintOffer is a Record type +type HolderServiceAcceptMintOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintOfferAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptMintOffer to a map for DAML arguments +func (t HolderServiceAcceptMintOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptMintOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptMintOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptMintOffer to hex string (Canton MCMS format) +func (t HolderServiceAcceptMintOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptMintOffer from hex string (Canton MCMS format) +func (t *HolderServiceAcceptMintOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptTransferOffer is a Record type +type HolderServiceAcceptTransferOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferOfferAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptTransferOffer to a map for DAML arguments +func (t HolderServiceAcceptTransferOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptTransferOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptTransferOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptTransferOffer to hex string (Canton MCMS format) +func (t HolderServiceAcceptTransferOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptTransferOffer from hex string (Canton MCMS format) +func (t *HolderServiceAcceptTransferOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptTransferOfferResult is a Record type +type HolderServiceAcceptTransferOfferResult struct { + AcceptedTransferCid types.CONTRACT_ID `json:"acceptedTransferCid"` +} + +// ToMap converts HolderServiceAcceptTransferOfferResult to a map for DAML arguments +func (t HolderServiceAcceptTransferOfferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedTransferCid"] = model.NestedToDAMLValue(t.AcceptedTransferCid) + + return m +} + +func (t HolderServiceAcceptTransferOfferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptTransferOfferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptTransferOfferResult to hex string (Canton MCMS format) +func (t HolderServiceAcceptTransferOfferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptTransferOfferResult from hex string (Canton MCMS format) +func (t *HolderServiceAcceptTransferOfferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptTransferRequest is a Record type +type HolderServiceAcceptTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferRequestAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptTransferRequest to a map for DAML arguments +func (t HolderServiceAcceptTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptTransferRequest to hex string (Canton MCMS format) +func (t HolderServiceAcceptTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptTransferRequest from hex string (Canton MCMS format) +func (t *HolderServiceAcceptTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptUnlockOffer is a Record type +type HolderServiceAcceptUnlockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockOfferAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptUnlockOffer to a map for DAML arguments +func (t HolderServiceAcceptUnlockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptUnlockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptUnlockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptUnlockOffer to hex string (Canton MCMS format) +func (t HolderServiceAcceptUnlockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptUnlockOffer from hex string (Canton MCMS format) +func (t *HolderServiceAcceptUnlockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceAcceptUnlockRequest is a Record type +type HolderServiceAcceptUnlockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockRequestAccept `json:"payload"` +} + +// ToMap converts HolderServiceAcceptUnlockRequest to a map for DAML arguments +func (t HolderServiceAcceptUnlockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceAcceptUnlockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceAcceptUnlockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceAcceptUnlockRequest to hex string (Canton MCMS format) +func (t HolderServiceAcceptUnlockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceAcceptUnlockRequest from hex string (Canton MCMS format) +func (t *HolderServiceAcceptUnlockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelBurnRequest is a Record type +type HolderServiceCancelBurnRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelBurnRequest to a map for DAML arguments +func (t HolderServiceCancelBurnRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelBurnRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelBurnRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelBurnRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelBurnRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelBurnRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelBurnRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelEnforcementServiceRequest is a Record type +type HolderServiceCancelEnforcementServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload EnforcementServiceRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelEnforcementServiceRequest to a map for DAML arguments +func (t HolderServiceCancelEnforcementServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelEnforcementServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelEnforcementServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelEnforcementServiceRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelEnforcementServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelEnforcementServiceRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelEnforcementServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelForceTransferRequest is a Record type +type HolderServiceCancelForceTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ForceTransferRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelForceTransferRequest to a map for DAML arguments +func (t HolderServiceCancelForceTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelForceTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelForceTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelForceTransferRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelForceTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelForceTransferRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelForceTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelLockOffer is a Record type +type HolderServiceCancelLockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockOfferCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelLockOffer to a map for DAML arguments +func (t HolderServiceCancelLockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelLockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelLockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelLockOffer to hex string (Canton MCMS format) +func (t HolderServiceCancelLockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelLockOffer from hex string (Canton MCMS format) +func (t *HolderServiceCancelLockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelLockRequest is a Record type +type HolderServiceCancelLockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelLockRequest to a map for DAML arguments +func (t HolderServiceCancelLockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelLockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelLockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelLockRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelLockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelLockRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelLockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelMintRequest is a Record type +type HolderServiceCancelMintRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelMintRequest to a map for DAML arguments +func (t HolderServiceCancelMintRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelMintRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelMintRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelMintRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelMintRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelMintRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelMintRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelTransferOffer is a Record type +type HolderServiceCancelTransferOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferOfferCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelTransferOffer to a map for DAML arguments +func (t HolderServiceCancelTransferOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelTransferOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelTransferOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelTransferOffer to hex string (Canton MCMS format) +func (t HolderServiceCancelTransferOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelTransferOffer from hex string (Canton MCMS format) +func (t *HolderServiceCancelTransferOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelTransferRequest is a Record type +type HolderServiceCancelTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelTransferRequest to a map for DAML arguments +func (t HolderServiceCancelTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelTransferRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelTransferRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelUnlockOffer is a Record type +type HolderServiceCancelUnlockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockOfferCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelUnlockOffer to a map for DAML arguments +func (t HolderServiceCancelUnlockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelUnlockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelUnlockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelUnlockOffer to hex string (Canton MCMS format) +func (t HolderServiceCancelUnlockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelUnlockOffer from hex string (Canton MCMS format) +func (t *HolderServiceCancelUnlockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCancelUnlockRequest is a Record type +type HolderServiceCancelUnlockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockRequestCancel `json:"payload"` +} + +// ToMap converts HolderServiceCancelUnlockRequest to a map for DAML arguments +func (t HolderServiceCancelUnlockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceCancelUnlockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCancelUnlockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCancelUnlockRequest to hex string (Canton MCMS format) +func (t HolderServiceCancelUnlockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCancelUnlockRequest from hex string (Canton MCMS format) +func (t *HolderServiceCancelUnlockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceClean is a Record type +type HolderServiceClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts HolderServiceClean to a map for DAML arguments +func (t HolderServiceClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t HolderServiceClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceClean to hex string (Canton MCMS format) +func (t HolderServiceClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceClean from hex string (Canton MCMS format) +func (t *HolderServiceClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceCreateAllocation is a Record type +type HolderServiceCreateAllocation struct { + Registrar types.PARTY `json:"registrar"` + AllocationFactoryCid types.CONTRACT_ID `json:"allocationFactoryCid"` + Allocation splice_api_token_allocation_v1.AllocationSpecification `json:"allocation"` + InputHoldings []types.CONTRACT_ID `json:"inputHoldings"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts HolderServiceCreateAllocation to a map for DAML arguments +func (t HolderServiceCreateAllocation) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["allocationFactoryCid"] = model.NestedToDAMLValue(t.AllocationFactoryCid) + + m["allocation"] = model.NestedToDAMLValue(t.Allocation) + + m["inputHoldings"] = func() []any { + res := make([]any, 0, len(t.InputHoldings)) + for _, e := range t.InputHoldings { + res = append(res, e) + } + return res + }() + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t HolderServiceCreateAllocation) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceCreateAllocation) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceCreateAllocation to hex string (Canton MCMS format) +func (t HolderServiceCreateAllocation) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceCreateAllocation from hex string (Canton MCMS format) +func (t *HolderServiceCreateAllocation) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferLock is a Record type +type HolderServiceOfferLock struct { + Registrar types.PARTY `json:"registrar"` + Locker types.PARTY `json:"locker"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Context types.TEXT `json:"context"` + HoldingLabel types.TEXT `json:"holdingLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceOfferLock to a map for DAML arguments +func (t HolderServiceOfferLock) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["locker"] = t.Locker.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["context"] = string(t.Context) + + m["holdingLabel"] = string(t.HoldingLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceOfferLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferLock to hex string (Canton MCMS format) +func (t HolderServiceOfferLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferLock from hex string (Canton MCMS format) +func (t *HolderServiceOfferLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferLockResult is a Record type +type HolderServiceOfferLockResult struct { + LockOfferCid types.CONTRACT_ID `json:"lockOfferCid"` +} + +// ToMap converts HolderServiceOfferLockResult to a map for DAML arguments +func (t HolderServiceOfferLockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["lockOfferCid"] = model.NestedToDAMLValue(t.LockOfferCid) + + return m +} + +func (t HolderServiceOfferLockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferLockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferLockResult to hex string (Canton MCMS format) +func (t HolderServiceOfferLockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferLockResult from hex string (Canton MCMS format) +func (t *HolderServiceOfferLockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferTransfer is a Record type +type HolderServiceOfferTransfer struct { + Registrar types.PARTY `json:"registrar"` + Receiver types.PARTY `json:"receiver"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + SenderLabel types.TEXT `json:"senderLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceOfferTransfer to a map for DAML arguments +func (t HolderServiceOfferTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["receiver"] = t.Receiver.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["senderLabel"] = string(t.SenderLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceOfferTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferTransfer to hex string (Canton MCMS format) +func (t HolderServiceOfferTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferTransfer from hex string (Canton MCMS format) +func (t *HolderServiceOfferTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferTransferResult is a Record type +type HolderServiceOfferTransferResult struct { + TransferOfferCid types.CONTRACT_ID `json:"transferOfferCid"` +} + +// ToMap converts HolderServiceOfferTransferResult to a map for DAML arguments +func (t HolderServiceOfferTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["transferOfferCid"] = model.NestedToDAMLValue(t.TransferOfferCid) + + return m +} + +func (t HolderServiceOfferTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferTransferResult to hex string (Canton MCMS format) +func (t HolderServiceOfferTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferTransferResult from hex string (Canton MCMS format) +func (t *HolderServiceOfferTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferUnlock is a Record type +type HolderServiceOfferUnlock struct { + Registrar types.PARTY `json:"registrar"` + Locker types.PARTY `json:"locker"` + LockContext types.TEXT `json:"lockContext"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + HoldingLabel types.TEXT `json:"holdingLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceOfferUnlock to a map for DAML arguments +func (t HolderServiceOfferUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["locker"] = t.Locker.ToMap() + + m["lockContext"] = string(t.LockContext) + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holdingLabel"] = string(t.HoldingLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceOfferUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferUnlock to hex string (Canton MCMS format) +func (t HolderServiceOfferUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferUnlock from hex string (Canton MCMS format) +func (t *HolderServiceOfferUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceOfferUnlockResult is a Record type +type HolderServiceOfferUnlockResult struct { + UnlockOfferCid types.CONTRACT_ID `json:"unlockOfferCid"` +} + +// ToMap converts HolderServiceOfferUnlockResult to a map for DAML arguments +func (t HolderServiceOfferUnlockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["unlockOfferCid"] = model.NestedToDAMLValue(t.UnlockOfferCid) + + return m +} + +func (t HolderServiceOfferUnlockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceOfferUnlockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceOfferUnlockResult to hex string (Canton MCMS format) +func (t HolderServiceOfferUnlockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceOfferUnlockResult from hex string (Canton MCMS format) +func (t *HolderServiceOfferUnlockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectAllocationRequest is a Record type +type HolderServiceRejectAllocationRequest struct { + AllocationRequestCid types.CONTRACT_ID `json:"allocationRequestCid"` +} + +// ToMap converts HolderServiceRejectAllocationRequest to a map for DAML arguments +func (t HolderServiceRejectAllocationRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["allocationRequestCid"] = model.NestedToDAMLValue(t.AllocationRequestCid) + + return m +} + +func (t HolderServiceRejectAllocationRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectAllocationRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectAllocationRequest to hex string (Canton MCMS format) +func (t HolderServiceRejectAllocationRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectAllocationRequest from hex string (Canton MCMS format) +func (t *HolderServiceRejectAllocationRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectBurnOffer is a Record type +type HolderServiceRejectBurnOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnOfferReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectBurnOffer to a map for DAML arguments +func (t HolderServiceRejectBurnOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectBurnOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectBurnOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectBurnOffer to hex string (Canton MCMS format) +func (t HolderServiceRejectBurnOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectBurnOffer from hex string (Canton MCMS format) +func (t *HolderServiceRejectBurnOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectLockOffer is a Record type +type HolderServiceRejectLockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockOfferReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectLockOffer to a map for DAML arguments +func (t HolderServiceRejectLockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectLockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectLockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectLockOffer to hex string (Canton MCMS format) +func (t HolderServiceRejectLockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectLockOffer from hex string (Canton MCMS format) +func (t *HolderServiceRejectLockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectLockRequest is a Record type +type HolderServiceRejectLockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.LockRequestReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectLockRequest to a map for DAML arguments +func (t HolderServiceRejectLockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectLockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectLockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectLockRequest to hex string (Canton MCMS format) +func (t HolderServiceRejectLockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectLockRequest from hex string (Canton MCMS format) +func (t *HolderServiceRejectLockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectMintOffer is a Record type +type HolderServiceRejectMintOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintOfferReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectMintOffer to a map for DAML arguments +func (t HolderServiceRejectMintOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectMintOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectMintOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectMintOffer to hex string (Canton MCMS format) +func (t HolderServiceRejectMintOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectMintOffer from hex string (Canton MCMS format) +func (t *HolderServiceRejectMintOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectTransferOffer is a Record type +type HolderServiceRejectTransferOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferOfferReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectTransferOffer to a map for DAML arguments +func (t HolderServiceRejectTransferOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectTransferOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectTransferOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectTransferOffer to hex string (Canton MCMS format) +func (t HolderServiceRejectTransferOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectTransferOffer from hex string (Canton MCMS format) +func (t *HolderServiceRejectTransferOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectTransferRequest is a Record type +type HolderServiceRejectTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.TransferRequestReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectTransferRequest to a map for DAML arguments +func (t HolderServiceRejectTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectTransferRequest to hex string (Canton MCMS format) +func (t HolderServiceRejectTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectTransferRequest from hex string (Canton MCMS format) +func (t *HolderServiceRejectTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectUnlockOffer is a Record type +type HolderServiceRejectUnlockOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockOfferReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectUnlockOffer to a map for DAML arguments +func (t HolderServiceRejectUnlockOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectUnlockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectUnlockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectUnlockOffer to hex string (Canton MCMS format) +func (t HolderServiceRejectUnlockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectUnlockOffer from hex string (Canton MCMS format) +func (t *HolderServiceRejectUnlockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRejectUnlockRequest is a Record type +type HolderServiceRejectUnlockRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.UnlockRequestReject `json:"payload"` +} + +// ToMap converts HolderServiceRejectUnlockRequest to a map for DAML arguments +func (t HolderServiceRejectUnlockRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t HolderServiceRejectUnlockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRejectUnlockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRejectUnlockRequest to hex string (Canton MCMS format) +func (t HolderServiceRejectUnlockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRejectUnlockRequest from hex string (Canton MCMS format) +func (t *HolderServiceRejectUnlockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestBurn is a Record type +type HolderServiceRequestBurn struct { + Registrar types.PARTY `json:"registrar"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + HoldingLabel types.TEXT `json:"holdingLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceRequestBurn to a map for DAML arguments +func (t HolderServiceRequestBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holdingLabel"] = string(t.HoldingLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceRequestBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestBurn to hex string (Canton MCMS format) +func (t HolderServiceRequestBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestBurn from hex string (Canton MCMS format) +func (t *HolderServiceRequestBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestBurnResult is a Record type +type HolderServiceRequestBurnResult struct { + BurnRequestCid types.CONTRACT_ID `json:"burnRequestCid"` +} + +// ToMap converts HolderServiceRequestBurnResult to a map for DAML arguments +func (t HolderServiceRequestBurnResult) ToMap() map[string]any { + m := make(map[string]any) + + m["burnRequestCid"] = model.NestedToDAMLValue(t.BurnRequestCid) + + return m +} + +func (t HolderServiceRequestBurnResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestBurnResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestBurnResult to hex string (Canton MCMS format) +func (t HolderServiceRequestBurnResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestBurnResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestBurnResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestEnforcementService is a Record type +type HolderServiceRequestEnforcementService struct { + Registrar types.PARTY `json:"registrar"` +} + +// ToMap converts HolderServiceRequestEnforcementService to a map for DAML arguments +func (t HolderServiceRequestEnforcementService) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + return m +} + +func (t HolderServiceRequestEnforcementService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestEnforcementService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestEnforcementService to hex string (Canton MCMS format) +func (t HolderServiceRequestEnforcementService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestEnforcementService from hex string (Canton MCMS format) +func (t *HolderServiceRequestEnforcementService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestEnforcementServiceResult is a Record type +type HolderServiceRequestEnforcementServiceResult struct { + EnforcementServiceRequestCid types.CONTRACT_ID `json:"enforcementServiceRequestCid"` +} + +// ToMap converts HolderServiceRequestEnforcementServiceResult to a map for DAML arguments +func (t HolderServiceRequestEnforcementServiceResult) ToMap() map[string]any { + m := make(map[string]any) + + m["enforcementServiceRequestCid"] = model.NestedToDAMLValue(t.EnforcementServiceRequestCid) + + return m +} + +func (t HolderServiceRequestEnforcementServiceResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestEnforcementServiceResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestEnforcementServiceResult to hex string (Canton MCMS format) +func (t HolderServiceRequestEnforcementServiceResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestEnforcementServiceResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestEnforcementServiceResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestForceTransfer is a Record type +type HolderServiceRequestForceTransfer struct { + RequestorRationale types.TEXT `json:"requestorRationale"` + Registrar types.PARTY `json:"registrar"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` + Sender types.PARTY `json:"sender"` + SenderLabel types.TEXT `json:"senderLabel"` + Receiver types.PARTY `json:"receiver"` + ReceiverLabel types.TEXT `json:"receiverLabel"` +} + +// ToMap converts HolderServiceRequestForceTransfer to a map for DAML arguments +func (t HolderServiceRequestForceTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["requestorRationale"] = string(t.RequestorRationale) + + m["registrar"] = t.Registrar.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + m["sender"] = t.Sender.ToMap() + + m["senderLabel"] = string(t.SenderLabel) + + m["receiver"] = t.Receiver.ToMap() + + m["receiverLabel"] = string(t.ReceiverLabel) + + return m +} + +func (t HolderServiceRequestForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestForceTransfer to hex string (Canton MCMS format) +func (t HolderServiceRequestForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestForceTransfer from hex string (Canton MCMS format) +func (t *HolderServiceRequestForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestForceTransferResult is a Record type +type HolderServiceRequestForceTransferResult struct { + ForceTransferRequestCid types.CONTRACT_ID `json:"forceTransferRequestCid"` +} + +// ToMap converts HolderServiceRequestForceTransferResult to a map for DAML arguments +func (t HolderServiceRequestForceTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["forceTransferRequestCid"] = model.NestedToDAMLValue(t.ForceTransferRequestCid) + + return m +} + +func (t HolderServiceRequestForceTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestForceTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestForceTransferResult to hex string (Canton MCMS format) +func (t HolderServiceRequestForceTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestForceTransferResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestForceTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestLock is a Record type +type HolderServiceRequestLock struct { + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Context types.TEXT `json:"context"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceRequestLock to a map for DAML arguments +func (t HolderServiceRequestLock) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["context"] = string(t.Context) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceRequestLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestLock to hex string (Canton MCMS format) +func (t HolderServiceRequestLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestLock from hex string (Canton MCMS format) +func (t *HolderServiceRequestLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestLockResult is a Record type +type HolderServiceRequestLockResult struct { + LockRequestCid types.CONTRACT_ID `json:"lockRequestCid"` +} + +// ToMap converts HolderServiceRequestLockResult to a map for DAML arguments +func (t HolderServiceRequestLockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["lockRequestCid"] = model.NestedToDAMLValue(t.LockRequestCid) + + return m +} + +func (t HolderServiceRequestLockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestLockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestLockResult to hex string (Canton MCMS format) +func (t HolderServiceRequestLockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestLockResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestLockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestMint is a Record type +type HolderServiceRequestMint struct { + Registrar types.PARTY `json:"registrar"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// ToMap converts HolderServiceRequestMint to a map for DAML arguments +func (t HolderServiceRequestMint) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + m["holdingLabel"] = string(t.HoldingLabel) + + return m +} + +func (t HolderServiceRequestMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestMint to hex string (Canton MCMS format) +func (t HolderServiceRequestMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestMint from hex string (Canton MCMS format) +func (t *HolderServiceRequestMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestMintResult is a Record type +type HolderServiceRequestMintResult struct { + MintRequestCid types.CONTRACT_ID `json:"mintRequestCid"` +} + +// ToMap converts HolderServiceRequestMintResult to a map for DAML arguments +func (t HolderServiceRequestMintResult) ToMap() map[string]any { + m := make(map[string]any) + + m["mintRequestCid"] = model.NestedToDAMLValue(t.MintRequestCid) + + return m +} + +func (t HolderServiceRequestMintResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestMintResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestMintResult to hex string (Canton MCMS format) +func (t HolderServiceRequestMintResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestMintResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestMintResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestTransfer is a Record type +type HolderServiceRequestTransfer struct { + Registrar types.PARTY `json:"registrar"` + Sender types.PARTY `json:"sender"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + ReceiverLabel types.TEXT `json:"receiverLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceRequestTransfer to a map for DAML arguments +func (t HolderServiceRequestTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["sender"] = t.Sender.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["receiverLabel"] = string(t.ReceiverLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceRequestTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestTransfer to hex string (Canton MCMS format) +func (t HolderServiceRequestTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestTransfer from hex string (Canton MCMS format) +func (t *HolderServiceRequestTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestTransferResult is a Record type +type HolderServiceRequestTransferResult struct { + TransferRequestCid types.CONTRACT_ID `json:"transferRequestCid"` +} + +// ToMap converts HolderServiceRequestTransferResult to a map for DAML arguments +func (t HolderServiceRequestTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["transferRequestCid"] = model.NestedToDAMLValue(t.TransferRequestCid) + + return m +} + +func (t HolderServiceRequestTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestTransferResult to hex string (Canton MCMS format) +func (t HolderServiceRequestTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestTransferResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestUnlock is a Record type +type HolderServiceRequestUnlock struct { + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + LockContext types.TEXT `json:"lockContext"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + HoldingLabel types.TEXT `json:"holdingLabel"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts HolderServiceRequestUnlock to a map for DAML arguments +func (t HolderServiceRequestUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["lockContext"] = string(t.LockContext) + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holdingLabel"] = string(t.HoldingLabel) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t HolderServiceRequestUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestUnlock to hex string (Canton MCMS format) +func (t HolderServiceRequestUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestUnlock from hex string (Canton MCMS format) +func (t *HolderServiceRequestUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceRequestUnlockResult is a Record type +type HolderServiceRequestUnlockResult struct { + UnlockRequestCid types.CONTRACT_ID `json:"unlockRequestCid"` +} + +// ToMap converts HolderServiceRequestUnlockResult to a map for DAML arguments +func (t HolderServiceRequestUnlockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["unlockRequestCid"] = model.NestedToDAMLValue(t.UnlockRequestCid) + + return m +} + +func (t HolderServiceRequestUnlockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceRequestUnlockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceRequestUnlockResult to hex string (Canton MCMS format) +func (t HolderServiceRequestUnlockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceRequestUnlockResult from hex string (Canton MCMS format) +func (t *HolderServiceRequestUnlockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceTerminate is a Record type +type HolderServiceTerminate struct { +} + +// ToMap converts HolderServiceTerminate to a map for DAML arguments +func (t HolderServiceTerminate) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t HolderServiceTerminate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceTerminate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceTerminate to hex string (Canton MCMS format) +func (t HolderServiceTerminate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceTerminate from hex string (Canton MCMS format) +func (t *HolderServiceTerminate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HolderServiceTerminateResult is a Record type +type HolderServiceTerminateResult struct { +} + +// ToMap converts HolderServiceTerminateResult to a map for DAML arguments +func (t HolderServiceTerminateResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t HolderServiceTerminateResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HolderServiceTerminateResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HolderServiceTerminateResult to hex string (Canton MCMS format) +func (t HolderServiceTerminateResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HolderServiceTerminateResult from hex string (Canton MCMS format) +func (t *HolderServiceTerminateResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// InstrumentAllowance is a Record type +type InstrumentAllowance struct { + Id types.TEXT `json:"id"` +} + +// ToMap converts InstrumentAllowance to a map for DAML arguments +func (t InstrumentAllowance) ToMap() map[string]any { + m := make(map[string]any) + + m["id"] = string(t.Id) + + return m +} + +func (t InstrumentAllowance) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentAllowance) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentAllowance to hex string (Canton MCMS format) +func (t InstrumentAllowance) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentAllowance from hex string (Canton MCMS format) +func (t *InstrumentAllowance) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Mint is a Record type +type Mint struct { + InstrumentId splice_api_token_holding_v1.InstrumentId `json:"instrumentId"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + RequestedAt types.TIMESTAMP `json:"requestedAt"` + ExecuteBefore types.TIMESTAMP `json:"executeBefore"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts Mint to a map for DAML arguments +func (t Mint) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentId"] = model.NestedToDAMLValue(t.InstrumentId) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["requestedAt"] = t.RequestedAt + + m["executeBefore"] = t.ExecuteBefore + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t Mint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Mint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Mint to hex string (Canton MCMS format) +func (t Mint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Mint from hex string (Canton MCMS format) +func (t *Mint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOffer is a Template type +type MintOffer struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Mint Mint `json:"mint"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t MintOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t MintOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t MintOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t MintOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t MintOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOffer to hex string (Canton MCMS format) +func (t MintOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOffer from hex string (Canton MCMS format) +func (t *MintOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for MintOffer + +// MintOfferAccept exercises the MintOffer_Accept choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferAccept(contractID string, args MintOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Accept", + Arguments: argsToMap(args), + } +} + +// MintOfferAcceptWithPackageID exercises the MintOffer_Accept choice using the provided package ID instead of package name +func (t MintOffer) MintOfferAcceptWithPackageID(contractID string, packageID string, args MintOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Accept", + Arguments: argsToMap(args), + } +} + +// MintOfferReject exercises the MintOffer_Reject choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferReject(contractID string, args MintOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Reject", + Arguments: argsToMap(args), + } +} + +// MintOfferRejectWithPackageID exercises the MintOffer_Reject choice using the provided package ID instead of package name +func (t MintOffer) MintOfferRejectWithPackageID(contractID string, packageID string, args MintOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Reject", + Arguments: argsToMap(args), + } +} + +// MintOfferCancel exercises the MintOffer_Cancel choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferCancel(contractID string, args MintOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// MintOfferCancelWithPackageID exercises the MintOffer_Cancel choice using the provided package ID instead of package name +func (t MintOffer) MintOfferCancelWithPackageID(contractID string, packageID string, args MintOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t MintOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// MintOfferAccept is a Record type +type MintOfferAccept struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts MintOfferAccept to a map for DAML arguments +func (t MintOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t MintOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferAccept to hex string (Canton MCMS format) +func (t MintOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferAccept from hex string (Canton MCMS format) +func (t *MintOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferAcceptResult is a Record type +type MintOfferAcceptResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + ExecutedMintCid *types.CONTRACT_ID `json:"executedMintCid" hex:"optional"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts MintOfferAcceptResult to a map for DAML arguments +func (t MintOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + if t.ExecutedMintCid != nil { + m["executedMintCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExecutedMintCid), + } + } else { + m["executedMintCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t MintOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferAcceptResult to hex string (Canton MCMS format) +func (t MintOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferAcceptResult from hex string (Canton MCMS format) +func (t *MintOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferCancel is a Record type +type MintOfferCancel struct { +} + +// ToMap converts MintOfferCancel to a map for DAML arguments +func (t MintOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferCancel to hex string (Canton MCMS format) +func (t MintOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferCancel from hex string (Canton MCMS format) +func (t *MintOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferCancelResult is a Record type +type MintOfferCancelResult struct { +} + +// ToMap converts MintOfferCancelResult to a map for DAML arguments +func (t MintOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferCancelResult to hex string (Canton MCMS format) +func (t MintOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferCancelResult from hex string (Canton MCMS format) +func (t *MintOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferReject is a Record type +type MintOfferReject struct { + Reason types.TEXT `json:"reason"` + ExtraArgs *splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs" hex:"optional"` +} + +// ToMap converts MintOfferReject to a map for DAML arguments +func (t MintOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + if t.ExtraArgs != nil { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExtraArgs), + } + } else { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t MintOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferReject to hex string (Canton MCMS format) +func (t MintOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferReject from hex string (Canton MCMS format) +func (t *MintOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferRejectResult is a Record type +type MintOfferRejectResult struct { + RejectedMintCid *types.CONTRACT_ID `json:"rejectedMintCid" hex:"optional"` +} + +// ToMap converts MintOfferRejectResult to a map for DAML arguments +func (t MintOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.RejectedMintCid != nil { + m["rejectedMintCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.RejectedMintCid), + } + } else { + m["rejectedMintCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t MintOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferRejectResult to hex string (Canton MCMS format) +func (t MintOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferRejectResult from hex string (Canton MCMS format) +func (t *MintOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequest is a Template type +type MintRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Mint Mint `json:"mint"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t MintRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t MintRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t MintRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t MintRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t MintRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequest to hex string (Canton MCMS format) +func (t MintRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequest from hex string (Canton MCMS format) +func (t *MintRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for MintRequest + +// MintRequestAccept exercises the MintRequest_Accept choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestAccept(contractID string, args MintRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Accept", + Arguments: argsToMap(args), + } +} + +// MintRequestAcceptWithPackageID exercises the MintRequest_Accept choice using the provided package ID instead of package name +func (t MintRequest) MintRequestAcceptWithPackageID(contractID string, packageID string, args MintRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Accept", + Arguments: argsToMap(args), + } +} + +// MintRequestReject exercises the MintRequest_Reject choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestReject(contractID string, args MintRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Reject", + Arguments: argsToMap(args), + } +} + +// MintRequestRejectWithPackageID exercises the MintRequest_Reject choice using the provided package ID instead of package name +func (t MintRequest) MintRequestRejectWithPackageID(contractID string, packageID string, args MintRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Reject", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t MintRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// MintRequestCancel exercises the MintRequest_Cancel choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestCancel(contractID string, args MintRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// MintRequestCancelWithPackageID exercises the MintRequest_Cancel choice using the provided package ID instead of package name +func (t MintRequest) MintRequestCancelWithPackageID(contractID string, packageID string, args MintRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// MintRequestAccept is a Record type +type MintRequestAccept struct { + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` +} + +// ToMap converts MintRequestAccept to a map for DAML arguments +func (t MintRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + return m +} + +func (t MintRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestAccept to hex string (Canton MCMS format) +func (t MintRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestAccept from hex string (Canton MCMS format) +func (t *MintRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestAcceptResult is a Record type +type MintRequestAcceptResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + ExecutedMintCid *types.CONTRACT_ID `json:"executedMintCid" hex:"optional"` + Meta splice_api_token_metadata_v1.Metadata `json:"meta"` +} + +// ToMap converts MintRequestAcceptResult to a map for DAML arguments +func (t MintRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + if t.ExecutedMintCid != nil { + m["executedMintCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExecutedMintCid), + } + } else { + m["executedMintCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + m["meta"] = model.NestedToDAMLValue(t.Meta) + + return m +} + +func (t MintRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestAcceptResult to hex string (Canton MCMS format) +func (t MintRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestAcceptResult from hex string (Canton MCMS format) +func (t *MintRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestCancel is a Record type +type MintRequestCancel struct { +} + +// ToMap converts MintRequestCancel to a map for DAML arguments +func (t MintRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestCancel to hex string (Canton MCMS format) +func (t MintRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestCancel from hex string (Canton MCMS format) +func (t *MintRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestCancelResult is a Record type +type MintRequestCancelResult struct { +} + +// ToMap converts MintRequestCancelResult to a map for DAML arguments +func (t MintRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestCancelResult to hex string (Canton MCMS format) +func (t MintRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestCancelResult from hex string (Canton MCMS format) +func (t *MintRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestReject is a Record type +type MintRequestReject struct { + Reason types.TEXT `json:"reason"` + ExtraArgs *splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs" hex:"optional"` +} + +// ToMap converts MintRequestReject to a map for DAML arguments +func (t MintRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + if t.ExtraArgs != nil { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ExtraArgs), + } + } else { + m["extraArgs"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t MintRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestReject to hex string (Canton MCMS format) +func (t MintRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestReject from hex string (Canton MCMS format) +func (t *MintRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestRejectResult is a Record type +type MintRequestRejectResult struct { + RejectedMintCid *types.CONTRACT_ID `json:"rejectedMintCid" hex:"optional"` +} + +// ToMap converts MintRequestRejectResult to a map for DAML arguments +func (t MintRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.RejectedMintCid != nil { + m["rejectedMintCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.RejectedMintCid), + } + } else { + m["rejectedMintCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t MintRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestRejectResult to hex string (Canton MCMS format) +func (t MintRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestRejectResult from hex string (Canton MCMS format) +func (t *MintRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// OperatorConfiguration is a Template type +type OperatorConfiguration struct { + Operator types.PARTY `json:"operator"` + ProviderRequirements []credential_v0.PartyCredentialRequirement `json:"providerRequirements"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t OperatorConfiguration) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t OperatorConfiguration) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t OperatorConfiguration) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["providerRequirements"] = func() []any { + res := make([]any, 0, len(t.ProviderRequirements)) + for _, e := range t.ProviderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t OperatorConfiguration) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["providerRequirements"] = func() []any { + res := make([]any, 0, len(t.ProviderRequirements)) + for _, e := range t.ProviderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t OperatorConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *OperatorConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes OperatorConfiguration to hex string (Canton MCMS format) +func (t OperatorConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes OperatorConfiguration from hex string (Canton MCMS format) +func (t *OperatorConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for OperatorConfiguration + +// OperatorConfigurationGet exercises the OperatorConfiguration_Get choice on this OperatorConfiguration contract +// This method uses the package name in the template ID +func (t OperatorConfiguration) OperatorConfigurationGet(contractID string, args OperatorConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "OperatorConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// OperatorConfigurationGetWithPackageID exercises the OperatorConfiguration_Get choice using the provided package ID instead of package name +func (t OperatorConfiguration) OperatorConfigurationGetWithPackageID(contractID string, packageID string, args OperatorConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "OperatorConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this OperatorConfiguration contract +// This method uses the package name in the template ID +func (t OperatorConfiguration) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t OperatorConfiguration) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// OperatorConfigurationModify exercises the OperatorConfiguration_Modify choice on this OperatorConfiguration contract +// This method uses the package name in the template ID +func (t OperatorConfiguration) OperatorConfigurationModify(contractID string, args OperatorConfigurationModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "OperatorConfiguration_Modify", + Arguments: argsToMap(args), + } +} + +// OperatorConfigurationModifyWithPackageID exercises the OperatorConfiguration_Modify choice using the provided package ID instead of package name +func (t OperatorConfiguration) OperatorConfigurationModifyWithPackageID(contractID string, packageID string, args OperatorConfigurationModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Operator", "OperatorConfiguration"), + ContractID: contractID, + Choice: "OperatorConfiguration_Modify", + Arguments: argsToMap(args), + } +} + +// OperatorConfigurationGet is a Record type +type OperatorConfigurationGet struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts OperatorConfigurationGet to a map for DAML arguments +func (t OperatorConfigurationGet) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t OperatorConfigurationGet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *OperatorConfigurationGet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes OperatorConfigurationGet to hex string (Canton MCMS format) +func (t OperatorConfigurationGet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes OperatorConfigurationGet from hex string (Canton MCMS format) +func (t *OperatorConfigurationGet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// OperatorConfigurationGetResult is a Record type +type OperatorConfigurationGetResult struct { + OperatorConfiguration OperatorConfiguration `json:"operatorConfiguration"` +} + +// ToMap converts OperatorConfigurationGetResult to a map for DAML arguments +func (t OperatorConfigurationGetResult) ToMap() map[string]any { + m := make(map[string]any) + + m["operatorConfiguration"] = model.NestedToDAMLValue(t.OperatorConfiguration) + + return m +} + +func (t OperatorConfigurationGetResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *OperatorConfigurationGetResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes OperatorConfigurationGetResult to hex string (Canton MCMS format) +func (t OperatorConfigurationGetResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes OperatorConfigurationGetResult from hex string (Canton MCMS format) +func (t *OperatorConfigurationGetResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// OperatorConfigurationModify is a Record type +type OperatorConfigurationModify struct { + NewProviderRequirements []credential_v0.PartyCredentialRequirement `json:"newProviderRequirements"` +} + +// ToMap converts OperatorConfigurationModify to a map for DAML arguments +func (t OperatorConfigurationModify) ToMap() map[string]any { + m := make(map[string]any) + + m["newProviderRequirements"] = func() []any { + res := make([]any, 0, len(t.NewProviderRequirements)) + for _, e := range t.NewProviderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t OperatorConfigurationModify) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *OperatorConfigurationModify) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes OperatorConfigurationModify to hex string (Canton MCMS format) +func (t OperatorConfigurationModify) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes OperatorConfigurationModify from hex string (Canton MCMS format) +func (t *OperatorConfigurationModify) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// OperatorConfigurationModifyResult is a Record type +type OperatorConfigurationModifyResult struct { + OperatorConfigurationCid types.CONTRACT_ID `json:"operatorConfigurationCid"` +} + +// ToMap converts OperatorConfigurationModifyResult to a map for DAML arguments +func (t OperatorConfigurationModifyResult) ToMap() map[string]any { + m := make(map[string]any) + + m["operatorConfigurationCid"] = model.NestedToDAMLValue(t.OperatorConfigurationCid) + + return m +} + +func (t OperatorConfigurationModifyResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *OperatorConfigurationModifyResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes OperatorConfigurationModifyResult to hex string (Canton MCMS format) +func (t OperatorConfigurationModifyResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes OperatorConfigurationModifyResult from hex string (Canton MCMS format) +func (t *OperatorConfigurationModifyResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderConfiguration is a Template type +type ProviderConfiguration struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + RegistrarRequirements []credential_v0.PartyCredentialRequirement `json:"registrarRequirements"` + HolderRequirements []credential_v0.PartyCredentialRequirement `json:"holderRequirements"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ProviderConfiguration) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ProviderConfiguration) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ProviderConfiguration) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRequirements"] = func() []any { + res := make([]any, 0, len(t.RegistrarRequirements)) + for _, e := range t.RegistrarRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ProviderConfiguration) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRequirements"] = func() []any { + res := make([]any, 0, len(t.RegistrarRequirements)) + for _, e := range t.RegistrarRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ProviderConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderConfiguration to hex string (Canton MCMS format) +func (t ProviderConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderConfiguration from hex string (Canton MCMS format) +func (t *ProviderConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ProviderConfiguration + +// Archive exercises the Archive choice on this ProviderConfiguration contract +// This method uses the package name in the template ID +func (t ProviderConfiguration) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ProviderConfiguration) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ProviderConfigurationGet exercises the ProviderConfiguration_Get choice on this ProviderConfiguration contract +// This method uses the package name in the template ID +func (t ProviderConfiguration) ProviderConfigurationGet(contractID string, args ProviderConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration"), + ContractID: contractID, + Choice: "ProviderConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// ProviderConfigurationGetWithPackageID exercises the ProviderConfiguration_Get choice using the provided package ID instead of package name +func (t ProviderConfiguration) ProviderConfigurationGetWithPackageID(contractID string, packageID string, args ProviderConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Provider", "ProviderConfiguration"), + ContractID: contractID, + Choice: "ProviderConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// ProviderConfigurationGet is a Record type +type ProviderConfigurationGet struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ProviderConfigurationGet to a map for DAML arguments +func (t ProviderConfigurationGet) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ProviderConfigurationGet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderConfigurationGet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderConfigurationGet to hex string (Canton MCMS format) +func (t ProviderConfigurationGet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderConfigurationGet from hex string (Canton MCMS format) +func (t *ProviderConfigurationGet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderConfigurationGetResult is a Record type +type ProviderConfigurationGetResult struct { + ProviderConfiguration ProviderConfiguration `json:"providerConfiguration"` +} + +// ToMap converts ProviderConfigurationGetResult to a map for DAML arguments +func (t ProviderConfigurationGetResult) ToMap() map[string]any { + m := make(map[string]any) + + m["providerConfiguration"] = model.NestedToDAMLValue(t.ProviderConfiguration) + + return m +} + +func (t ProviderConfigurationGetResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderConfigurationGetResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderConfigurationGetResult to hex string (Canton MCMS format) +func (t ProviderConfigurationGetResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderConfigurationGetResult from hex string (Canton MCMS format) +func (t *ProviderConfigurationGetResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderService is a Template type +type ProviderService struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ProviderService) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ProviderService) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ProviderService) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ProviderService) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ProviderService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderService to hex string (Canton MCMS format) +func (t ProviderService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderService from hex string (Canton MCMS format) +func (t *ProviderService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ProviderService + +// ProviderServiceTerminate exercises the ProviderService_Terminate choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceTerminate(contractID string, args ProviderServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_Terminate", + Arguments: argsToMap(args), + } +} + +// ProviderServiceTerminateWithPackageID exercises the ProviderService_Terminate choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceTerminateWithPackageID(contractID string, packageID string, args ProviderServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_Terminate", + Arguments: argsToMap(args), + } +} + +// ProviderServiceCreateProviderConfiguration exercises the ProviderService_CreateProviderConfiguration choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceCreateProviderConfiguration(contractID string, args ProviderServiceCreateProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_CreateProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceCreateProviderConfigurationWithPackageID exercises the ProviderService_CreateProviderConfiguration choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceCreateProviderConfigurationWithPackageID(contractID string, packageID string, args ProviderServiceCreateProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_CreateProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceArchiveProviderConfiguration exercises the ProviderService_ArchiveProviderConfiguration choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceArchiveProviderConfiguration(contractID string, args ProviderServiceArchiveProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_ArchiveProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceArchiveProviderConfigurationWithPackageID exercises the ProviderService_ArchiveProviderConfiguration choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceArchiveProviderConfigurationWithPackageID(contractID string, packageID string, args ProviderServiceArchiveProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_ArchiveProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceArchiveAndCreateProviderConfiguration exercises the ProviderService_ArchiveAndCreateProviderConfiguration choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceArchiveAndCreateProviderConfiguration(contractID string, args ProviderServiceArchiveAndCreateProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_ArchiveAndCreateProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceArchiveAndCreateProviderConfigurationWithPackageID exercises the ProviderService_ArchiveAndCreateProviderConfiguration choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceArchiveAndCreateProviderConfigurationWithPackageID(contractID string, packageID string, args ProviderServiceArchiveAndCreateProviderConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_ArchiveAndCreateProviderConfiguration", + Arguments: argsToMap(args), + } +} + +// ProviderServiceAcceptRegistrarServiceRequest exercises the ProviderService_AcceptRegistrarServiceRequest choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceAcceptRegistrarServiceRequest(contractID string, args ProviderServiceAcceptRegistrarServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_AcceptRegistrarServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceAcceptRegistrarServiceRequestWithPackageID exercises the ProviderService_AcceptRegistrarServiceRequest choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceAcceptRegistrarServiceRequestWithPackageID(contractID string, packageID string, args ProviderServiceAcceptRegistrarServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_AcceptRegistrarServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRejectRegistrarServiceRequest exercises the ProviderService_RejectRegistrarServiceRequest choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceRejectRegistrarServiceRequest(contractID string, args ProviderServiceRejectRegistrarServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_RejectRegistrarServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRejectRegistrarServiceRequestWithPackageID exercises the ProviderService_RejectRegistrarServiceRequest choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceRejectRegistrarServiceRequestWithPackageID(contractID string, packageID string, args ProviderServiceRejectRegistrarServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_RejectRegistrarServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceAcceptHolderServiceRequest exercises the ProviderService_AcceptHolderServiceRequest choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceAcceptHolderServiceRequest(contractID string, args ProviderServiceAcceptHolderServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_AcceptHolderServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceAcceptHolderServiceRequestWithPackageID exercises the ProviderService_AcceptHolderServiceRequest choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceAcceptHolderServiceRequestWithPackageID(contractID string, packageID string, args ProviderServiceAcceptHolderServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_AcceptHolderServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRejectHolderServiceRequest exercises the ProviderService_RejectHolderServiceRequest choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) ProviderServiceRejectHolderServiceRequest(contractID string, args ProviderServiceRejectHolderServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_RejectHolderServiceRequest", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRejectHolderServiceRequestWithPackageID exercises the ProviderService_RejectHolderServiceRequest choice using the provided package ID instead of package name +func (t ProviderService) ProviderServiceRejectHolderServiceRequestWithPackageID(contractID string, packageID string, args ProviderServiceRejectHolderServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "ProviderService_RejectHolderServiceRequest", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ProviderService contract +// This method uses the package name in the template ID +func (t ProviderService) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ProviderService) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ProviderServiceRequest is a Template type +type ProviderServiceRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ProviderServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ProviderServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ProviderServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ProviderServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ProviderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequest to hex string (Canton MCMS format) +func (t ProviderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequest from hex string (Canton MCMS format) +func (t *ProviderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ProviderServiceRequest + +// ProviderServiceRequestAccept exercises the ProviderServiceRequest_Accept choice on this ProviderServiceRequest contract +// This method uses the package name in the template ID +func (t ProviderServiceRequest) ProviderServiceRequestAccept(contractID string, args ProviderServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRequestAcceptWithPackageID exercises the ProviderServiceRequest_Accept choice using the provided package ID instead of package name +func (t ProviderServiceRequest) ProviderServiceRequestAcceptWithPackageID(contractID string, packageID string, args ProviderServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRequestReject exercises the ProviderServiceRequest_Reject choice on this ProviderServiceRequest contract +// This method uses the package name in the template ID +func (t ProviderServiceRequest) ProviderServiceRequestReject(contractID string, args ProviderServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRequestRejectWithPackageID exercises the ProviderServiceRequest_Reject choice using the provided package ID instead of package name +func (t ProviderServiceRequest) ProviderServiceRequestRejectWithPackageID(contractID string, packageID string, args ProviderServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRequestCancel exercises the ProviderServiceRequest_Cancel choice on this ProviderServiceRequest contract +// This method uses the package name in the template ID +func (t ProviderServiceRequest) ProviderServiceRequestCancel(contractID string, args ProviderServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// ProviderServiceRequestCancelWithPackageID exercises the ProviderServiceRequest_Cancel choice using the provided package ID instead of package name +func (t ProviderServiceRequest) ProviderServiceRequestCancelWithPackageID(contractID string, packageID string, args ProviderServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "ProviderServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ProviderServiceRequest contract +// This method uses the package name in the template ID +func (t ProviderServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ProviderServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "ProviderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ProviderServiceRequestAccept is a Record type +type ProviderServiceRequestAccept struct { + OperatorConfigurationCid types.CONTRACT_ID `json:"operatorConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` + AppRewardConfigurationDetails *registry_v0.AppRewardConfigurationDetails `json:"appRewardConfigurationDetails" hex:"optional"` +} + +// ToMap converts ProviderServiceRequestAccept to a map for DAML arguments +func (t ProviderServiceRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["operatorConfigurationCid"] = model.NestedToDAMLValue(t.OperatorConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + if t.AppRewardConfigurationDetails != nil { + m["appRewardConfigurationDetails"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.AppRewardConfigurationDetails), + } + } else { + m["appRewardConfigurationDetails"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t ProviderServiceRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestAccept to hex string (Canton MCMS format) +func (t ProviderServiceRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestAccept from hex string (Canton MCMS format) +func (t *ProviderServiceRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRequestAcceptResult is a Record type +type ProviderServiceRequestAcceptResult struct { + ProviderServiceCid types.CONTRACT_ID `json:"providerServiceCid"` + AppRewardConfigurationCid *types.CONTRACT_ID `json:"appRewardConfigurationCid" hex:"optional"` +} + +// ToMap converts ProviderServiceRequestAcceptResult to a map for DAML arguments +func (t ProviderServiceRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["providerServiceCid"] = model.NestedToDAMLValue(t.ProviderServiceCid) + + if t.AppRewardConfigurationCid != nil { + m["appRewardConfigurationCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.AppRewardConfigurationCid), + } + } else { + m["appRewardConfigurationCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t ProviderServiceRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestAcceptResult to hex string (Canton MCMS format) +func (t ProviderServiceRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestAcceptResult from hex string (Canton MCMS format) +func (t *ProviderServiceRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRequestCancel is a Record type +type ProviderServiceRequestCancel struct { +} + +// ToMap converts ProviderServiceRequestCancel to a map for DAML arguments +func (t ProviderServiceRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ProviderServiceRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestCancel to hex string (Canton MCMS format) +func (t ProviderServiceRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestCancel from hex string (Canton MCMS format) +func (t *ProviderServiceRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRequestCancelResult is a Record type +type ProviderServiceRequestCancelResult struct { +} + +// ToMap converts ProviderServiceRequestCancelResult to a map for DAML arguments +func (t ProviderServiceRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ProviderServiceRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestCancelResult to hex string (Canton MCMS format) +func (t ProviderServiceRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestCancelResult from hex string (Canton MCMS format) +func (t *ProviderServiceRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRequestReject is a Record type +type ProviderServiceRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts ProviderServiceRequestReject to a map for DAML arguments +func (t ProviderServiceRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t ProviderServiceRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestReject to hex string (Canton MCMS format) +func (t ProviderServiceRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestReject from hex string (Canton MCMS format) +func (t *ProviderServiceRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRequestRejectResult is a Record type +type ProviderServiceRequestRejectResult struct { + RejectedProviderServiceRequestCid types.CONTRACT_ID `json:"rejectedProviderServiceRequestCid"` +} + +// ToMap converts ProviderServiceRequestRejectResult to a map for DAML arguments +func (t ProviderServiceRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedProviderServiceRequestCid"] = model.NestedToDAMLValue(t.RejectedProviderServiceRequestCid) + + return m +} + +func (t ProviderServiceRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRequestRejectResult to hex string (Canton MCMS format) +func (t ProviderServiceRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRequestRejectResult from hex string (Canton MCMS format) +func (t *ProviderServiceRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceAcceptHolderServiceRequest is a Record type +type ProviderServiceAcceptHolderServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload HolderServiceRequestAccept `json:"payload"` +} + +// ToMap converts ProviderServiceAcceptHolderServiceRequest to a map for DAML arguments +func (t ProviderServiceAcceptHolderServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t ProviderServiceAcceptHolderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceAcceptHolderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceAcceptHolderServiceRequest to hex string (Canton MCMS format) +func (t ProviderServiceAcceptHolderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceAcceptHolderServiceRequest from hex string (Canton MCMS format) +func (t *ProviderServiceAcceptHolderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceAcceptRegistrarServiceRequest is a Record type +type ProviderServiceAcceptRegistrarServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload RegistrarServiceRequestAccept `json:"payload"` +} + +// ToMap converts ProviderServiceAcceptRegistrarServiceRequest to a map for DAML arguments +func (t ProviderServiceAcceptRegistrarServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t ProviderServiceAcceptRegistrarServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceAcceptRegistrarServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceAcceptRegistrarServiceRequest to hex string (Canton MCMS format) +func (t ProviderServiceAcceptRegistrarServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceAcceptRegistrarServiceRequest from hex string (Canton MCMS format) +func (t *ProviderServiceAcceptRegistrarServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceArchiveAndCreateProviderConfiguration is a Record type +type ProviderServiceArchiveAndCreateProviderConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload ProviderServiceCreateProviderConfiguration `json:"payload"` +} + +// ToMap converts ProviderServiceArchiveAndCreateProviderConfiguration to a map for DAML arguments +func (t ProviderServiceArchiveAndCreateProviderConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t ProviderServiceArchiveAndCreateProviderConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceArchiveAndCreateProviderConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceArchiveAndCreateProviderConfiguration to hex string (Canton MCMS format) +func (t ProviderServiceArchiveAndCreateProviderConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceArchiveAndCreateProviderConfiguration from hex string (Canton MCMS format) +func (t *ProviderServiceArchiveAndCreateProviderConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceArchiveAndCreateProviderConfigurationResult is a Record type +type ProviderServiceArchiveAndCreateProviderConfigurationResult struct { + ArchiveResult ProviderServiceArchiveProviderConfigurationResult `json:"archiveResult"` + CreateResult ProviderServiceCreateProviderConfigurationResult `json:"createResult"` +} + +// ToMap converts ProviderServiceArchiveAndCreateProviderConfigurationResult to a map for DAML arguments +func (t ProviderServiceArchiveAndCreateProviderConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["archiveResult"] = model.NestedToDAMLValue(t.ArchiveResult) + + m["createResult"] = model.NestedToDAMLValue(t.CreateResult) + + return m +} + +func (t ProviderServiceArchiveAndCreateProviderConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceArchiveAndCreateProviderConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceArchiveAndCreateProviderConfigurationResult to hex string (Canton MCMS format) +func (t ProviderServiceArchiveAndCreateProviderConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceArchiveAndCreateProviderConfigurationResult from hex string (Canton MCMS format) +func (t *ProviderServiceArchiveAndCreateProviderConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceArchiveProviderConfiguration is a Record type +type ProviderServiceArchiveProviderConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` +} + +// ToMap converts ProviderServiceArchiveProviderConfiguration to a map for DAML arguments +func (t ProviderServiceArchiveProviderConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + return m +} + +func (t ProviderServiceArchiveProviderConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceArchiveProviderConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceArchiveProviderConfiguration to hex string (Canton MCMS format) +func (t ProviderServiceArchiveProviderConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceArchiveProviderConfiguration from hex string (Canton MCMS format) +func (t *ProviderServiceArchiveProviderConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceArchiveProviderConfigurationResult is a Record type +type ProviderServiceArchiveProviderConfigurationResult struct { +} + +// ToMap converts ProviderServiceArchiveProviderConfigurationResult to a map for DAML arguments +func (t ProviderServiceArchiveProviderConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ProviderServiceArchiveProviderConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceArchiveProviderConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceArchiveProviderConfigurationResult to hex string (Canton MCMS format) +func (t ProviderServiceArchiveProviderConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceArchiveProviderConfigurationResult from hex string (Canton MCMS format) +func (t *ProviderServiceArchiveProviderConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceCreateProviderConfiguration is a Record type +type ProviderServiceCreateProviderConfiguration struct { + RegistrarRequirements []credential_v0.PartyCredentialRequirement `json:"registrarRequirements"` + HolderRequirements []credential_v0.PartyCredentialRequirement `json:"holderRequirements"` +} + +// ToMap converts ProviderServiceCreateProviderConfiguration to a map for DAML arguments +func (t ProviderServiceCreateProviderConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarRequirements"] = func() []any { + res := make([]any, 0, len(t.RegistrarRequirements)) + for _, e := range t.RegistrarRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + m["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t ProviderServiceCreateProviderConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceCreateProviderConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceCreateProviderConfiguration to hex string (Canton MCMS format) +func (t ProviderServiceCreateProviderConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceCreateProviderConfiguration from hex string (Canton MCMS format) +func (t *ProviderServiceCreateProviderConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceCreateProviderConfigurationResult is a Record type +type ProviderServiceCreateProviderConfigurationResult struct { + ProviderConfigurationCid types.CONTRACT_ID `json:"providerConfigurationCid"` +} + +// ToMap converts ProviderServiceCreateProviderConfigurationResult to a map for DAML arguments +func (t ProviderServiceCreateProviderConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["providerConfigurationCid"] = model.NestedToDAMLValue(t.ProviderConfigurationCid) + + return m +} + +func (t ProviderServiceCreateProviderConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceCreateProviderConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceCreateProviderConfigurationResult to hex string (Canton MCMS format) +func (t ProviderServiceCreateProviderConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceCreateProviderConfigurationResult from hex string (Canton MCMS format) +func (t *ProviderServiceCreateProviderConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceCreateResult is a Record type +type ProviderServiceCreateResult struct { + ProviderServiceCid types.CONTRACT_ID `json:"providerServiceCid"` +} + +// ToMap converts ProviderServiceCreateResult to a map for DAML arguments +func (t ProviderServiceCreateResult) ToMap() map[string]any { + m := make(map[string]any) + + m["providerServiceCid"] = model.NestedToDAMLValue(t.ProviderServiceCid) + + return m +} + +func (t ProviderServiceCreateResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceCreateResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceCreateResult to hex string (Canton MCMS format) +func (t ProviderServiceCreateResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceCreateResult from hex string (Canton MCMS format) +func (t *ProviderServiceCreateResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRejectHolderServiceRequest is a Record type +type ProviderServiceRejectHolderServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload HolderServiceRequestReject `json:"payload"` +} + +// ToMap converts ProviderServiceRejectHolderServiceRequest to a map for DAML arguments +func (t ProviderServiceRejectHolderServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t ProviderServiceRejectHolderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRejectHolderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRejectHolderServiceRequest to hex string (Canton MCMS format) +func (t ProviderServiceRejectHolderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRejectHolderServiceRequest from hex string (Canton MCMS format) +func (t *ProviderServiceRejectHolderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceRejectRegistrarServiceRequest is a Record type +type ProviderServiceRejectRegistrarServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload RegistrarServiceRequestReject `json:"payload"` +} + +// ToMap converts ProviderServiceRejectRegistrarServiceRequest to a map for DAML arguments +func (t ProviderServiceRejectRegistrarServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t ProviderServiceRejectRegistrarServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceRejectRegistrarServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceRejectRegistrarServiceRequest to hex string (Canton MCMS format) +func (t ProviderServiceRejectRegistrarServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceRejectRegistrarServiceRequest from hex string (Canton MCMS format) +func (t *ProviderServiceRejectRegistrarServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceTerminate is a Record type +type ProviderServiceTerminate struct { +} + +// ToMap converts ProviderServiceTerminate to a map for DAML arguments +func (t ProviderServiceTerminate) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ProviderServiceTerminate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceTerminate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceTerminate to hex string (Canton MCMS format) +func (t ProviderServiceTerminate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceTerminate from hex string (Canton MCMS format) +func (t *ProviderServiceTerminate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ProviderServiceTerminateResult is a Record type +type ProviderServiceTerminateResult struct { +} + +// ToMap converts ProviderServiceTerminateResult to a map for DAML arguments +func (t ProviderServiceTerminateResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ProviderServiceTerminateResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ProviderServiceTerminateResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ProviderServiceTerminateResult to hex string (Canton MCMS format) +func (t ProviderServiceTerminateResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ProviderServiceTerminateResult from hex string (Canton MCMS format) +func (t *ProviderServiceTerminateResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarConfiguration is a Template type +type RegistrarConfiguration struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + EnforcementRequirements []credential_v0.PartyCredentialRequirement `json:"enforcementRequirements"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RegistrarConfiguration) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RegistrarConfiguration) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RegistrarConfiguration) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["enforcementRequirements"] = func() []any { + res := make([]any, 0, len(t.EnforcementRequirements)) + for _, e := range t.EnforcementRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RegistrarConfiguration) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["enforcementRequirements"] = func() []any { + res := make([]any, 0, len(t.EnforcementRequirements)) + for _, e := range t.EnforcementRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RegistrarConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarConfiguration to hex string (Canton MCMS format) +func (t RegistrarConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarConfiguration from hex string (Canton MCMS format) +func (t *RegistrarConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RegistrarConfiguration + +// Archive exercises the Archive choice on this RegistrarConfiguration contract +// This method uses the package name in the template ID +func (t RegistrarConfiguration) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RegistrarConfiguration) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RegistrarConfigurationGet exercises the RegistrarConfiguration_Get choice on this RegistrarConfiguration contract +// This method uses the package name in the template ID +func (t RegistrarConfiguration) RegistrarConfigurationGet(contractID string, args RegistrarConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration"), + ContractID: contractID, + Choice: "RegistrarConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// RegistrarConfigurationGetWithPackageID exercises the RegistrarConfiguration_Get choice using the provided package ID instead of package name +func (t RegistrarConfiguration) RegistrarConfigurationGetWithPackageID(contractID string, packageID string, args RegistrarConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Configuration.Registrar", "RegistrarConfiguration"), + ContractID: contractID, + Choice: "RegistrarConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// RegistrarConfigurationGet is a Record type +type RegistrarConfigurationGet struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarConfigurationGet to a map for DAML arguments +func (t RegistrarConfigurationGet) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarConfigurationGet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarConfigurationGet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarConfigurationGet to hex string (Canton MCMS format) +func (t RegistrarConfigurationGet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarConfigurationGet from hex string (Canton MCMS format) +func (t *RegistrarConfigurationGet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarConfigurationGetResult is a Record type +type RegistrarConfigurationGetResult struct { + RegistrarConfiguration RegistrarConfiguration `json:"registrarConfiguration"` +} + +// ToMap converts RegistrarConfigurationGetResult to a map for DAML arguments +func (t RegistrarConfigurationGetResult) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarConfiguration"] = model.NestedToDAMLValue(t.RegistrarConfiguration) + + return m +} + +func (t RegistrarConfigurationGetResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarConfigurationGetResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarConfigurationGetResult to hex string (Canton MCMS format) +func (t RegistrarConfigurationGetResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarConfigurationGetResult from hex string (Canton MCMS format) +func (t *RegistrarConfigurationGetResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarService is a Template type +type RegistrarService struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + EnableResultContracts *types.BOOL `json:"enableResultContracts" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RegistrarService) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RegistrarService) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RegistrarService) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + if t.EnableResultContracts != nil { + args["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": bool(*t.EnableResultContracts), + } + } else { + args["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RegistrarService) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + if t.EnableResultContracts != nil { + args["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": bool(*t.EnableResultContracts), + } + } else { + args["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RegistrarService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarService to hex string (Canton MCMS format) +func (t RegistrarService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarService from hex string (Canton MCMS format) +func (t *RegistrarService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RegistrarService + +// RegistrarServiceSet exercises the RegistrarService_Set choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceSet(contractID string, args RegistrarServiceSet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_Set", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceSetWithPackageID exercises the RegistrarService_Set choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceSetWithPackageID(contractID string, packageID string, args RegistrarServiceSet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_Set", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceTerminate exercises the RegistrarService_Terminate choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceTerminate(contractID string, args RegistrarServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_Terminate", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceTerminateWithPackageID exercises the RegistrarService_Terminate choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceTerminateWithPackageID(contractID string, packageID string, args RegistrarServiceTerminate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_Terminate", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptEnforcementServiceRequest exercises the RegistrarService_AcceptEnforcementServiceRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceAcceptEnforcementServiceRequest(contractID string, args RegistrarServiceAcceptEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptEnforcementServiceRequestWithPackageID exercises the RegistrarService_AcceptEnforcementServiceRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceAcceptEnforcementServiceRequestWithPackageID(contractID string, packageID string, args RegistrarServiceAcceptEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectEnforcementServiceRequest exercises the RegistrarService_RejectEnforcementServiceRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceRejectEnforcementServiceRequest(contractID string, args RegistrarServiceRejectEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectEnforcementServiceRequestWithPackageID exercises the RegistrarService_RejectEnforcementServiceRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceRejectEnforcementServiceRequestWithPackageID(contractID string, packageID string, args RegistrarServiceRejectEnforcementServiceRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectEnforcementServiceRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceTerminateEnforcementService exercises the RegistrarService_TerminateEnforcementService choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceTerminateEnforcementService(contractID string, args RegistrarServiceTerminateEnforcementService) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_TerminateEnforcementService", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceTerminateEnforcementServiceWithPackageID exercises the RegistrarService_TerminateEnforcementService choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceTerminateEnforcementServiceWithPackageID(contractID string, packageID string, args RegistrarServiceTerminateEnforcementService) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_TerminateEnforcementService", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateRegistrarConfiguration exercises the RegistrarService_CreateRegistrarConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCreateRegistrarConfiguration(contractID string, args RegistrarServiceCreateRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateRegistrarConfigurationWithPackageID exercises the RegistrarService_CreateRegistrarConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCreateRegistrarConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceCreateRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptForceTransferRequest exercises the RegistrarService_AcceptForceTransferRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceAcceptForceTransferRequest(contractID string, args RegistrarServiceAcceptForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptForceTransferRequestWithPackageID exercises the RegistrarService_AcceptForceTransferRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceAcceptForceTransferRequestWithPackageID(contractID string, packageID string, args RegistrarServiceAcceptForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedForceTransfer exercises the RegistrarService_ExecuteAcceptedForceTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedForceTransfer(contractID string, args RegistrarServiceExecuteAcceptedForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedForceTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedForceTransferWithPackageID exercises the RegistrarService_ExecuteAcceptedForceTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedForceTransferWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedForceTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedForceTransfer exercises the RegistrarService_FailAcceptedForceTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedForceTransfer(contractID string, args RegistrarServiceFailAcceptedForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedForceTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedForceTransferWithPackageID exercises the RegistrarService_FailAcceptedForceTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedForceTransferWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedForceTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedForceTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectForceTransferRequest exercises the RegistrarService_RejectForceTransferRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceRejectForceTransferRequest(contractID string, args RegistrarServiceRejectForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectForceTransferRequestWithPackageID exercises the RegistrarService_RejectForceTransferRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceRejectForceTransferRequestWithPackageID(contractID string, packageID string, args RegistrarServiceRejectForceTransferRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectForceTransferRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveRegistrarConfiguration exercises the RegistrarService_ArchiveRegistrarConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveRegistrarConfiguration(contractID string, args RegistrarServiceArchiveRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveRegistrarConfigurationWithPackageID exercises the RegistrarService_ArchiveRegistrarConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveRegistrarConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAndCreateRegistrarConfiguration exercises the RegistrarService_ArchiveAndCreateRegistrarConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveAndCreateRegistrarConfiguration(contractID string, args RegistrarServiceArchiveAndCreateRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAndCreateRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAndCreateRegistrarConfigurationWithPackageID exercises the RegistrarService_ArchiveAndCreateRegistrarConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveAndCreateRegistrarConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveAndCreateRegistrarConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAndCreateRegistrarConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateInstrumentConfiguration exercises the RegistrarService_CreateInstrumentConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCreateInstrumentConfiguration(contractID string, args RegistrarServiceCreateInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateInstrumentConfigurationWithPackageID exercises the RegistrarService_CreateInstrumentConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCreateInstrumentConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceCreateInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveInstrumentConfiguration exercises the RegistrarService_ArchiveInstrumentConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveInstrumentConfiguration(contractID string, args RegistrarServiceArchiveInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveInstrumentConfigurationWithPackageID exercises the RegistrarService_ArchiveInstrumentConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveInstrumentConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAndCreateInstrumentConfiguration exercises the RegistrarService_ArchiveAndCreateInstrumentConfiguration choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveAndCreateInstrumentConfiguration(contractID string, args RegistrarServiceArchiveAndCreateInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAndCreateInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAndCreateInstrumentConfigurationWithPackageID exercises the RegistrarService_ArchiveAndCreateInstrumentConfiguration choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveAndCreateInstrumentConfigurationWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveAndCreateInstrumentConfiguration) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAndCreateInstrumentConfiguration", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceOfferMint exercises the RegistrarService_OfferMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceOfferMint(contractID string, args RegistrarServiceOfferMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_OfferMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceOfferMintWithPackageID exercises the RegistrarService_OfferMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceOfferMintWithPackageID(contractID string, packageID string, args RegistrarServiceOfferMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_OfferMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCancelMintOffer exercises the RegistrarService_CancelMintOffer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCancelMintOffer(contractID string, args RegistrarServiceCancelMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CancelMintOffer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCancelMintOfferWithPackageID exercises the RegistrarService_CancelMintOffer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCancelMintOfferWithPackageID(contractID string, packageID string, args RegistrarServiceCancelMintOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CancelMintOffer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptMintRequest exercises the RegistrarService_AcceptMintRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceAcceptMintRequest(contractID string, args RegistrarServiceAcceptMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptMintRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptMintRequestWithPackageID exercises the RegistrarService_AcceptMintRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceAcceptMintRequestWithPackageID(contractID string, packageID string, args RegistrarServiceAcceptMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptMintRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectMintRequest exercises the RegistrarService_RejectMintRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceRejectMintRequest(contractID string, args RegistrarServiceRejectMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectMintRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectMintRequestWithPackageID exercises the RegistrarService_RejectMintRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceRejectMintRequestWithPackageID(contractID string, packageID string, args RegistrarServiceRejectMintRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectMintRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceOfferBurn exercises the RegistrarService_OfferBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceOfferBurn(contractID string, args RegistrarServiceOfferBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_OfferBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceOfferBurnWithPackageID exercises the RegistrarService_OfferBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceOfferBurnWithPackageID(contractID string, packageID string, args RegistrarServiceOfferBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_OfferBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCancelBurnOffer exercises the RegistrarService_CancelBurnOffer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCancelBurnOffer(contractID string, args RegistrarServiceCancelBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CancelBurnOffer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCancelBurnOfferWithPackageID exercises the RegistrarService_CancelBurnOffer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCancelBurnOfferWithPackageID(contractID string, packageID string, args RegistrarServiceCancelBurnOffer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CancelBurnOffer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptBurnRequest exercises the RegistrarService_AcceptBurnRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceAcceptBurnRequest(contractID string, args RegistrarServiceAcceptBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptBurnRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceAcceptBurnRequestWithPackageID exercises the RegistrarService_AcceptBurnRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceAcceptBurnRequestWithPackageID(contractID string, packageID string, args RegistrarServiceAcceptBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_AcceptBurnRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectBurnRequest exercises the RegistrarService_RejectBurnRequest choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceRejectBurnRequest(contractID string, args RegistrarServiceRejectBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectBurnRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRejectBurnRequestWithPackageID exercises the RegistrarService_RejectBurnRequest choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceRejectBurnRequestWithPackageID(contractID string, packageID string, args RegistrarServiceRejectBurnRequest) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_RejectBurnRequest", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceSplitHolding exercises the RegistrarService_SplitHolding choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceSplitHolding(contractID string, args RegistrarServiceSplitHolding) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_SplitHolding", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceSplitHoldingWithPackageID exercises the RegistrarService_SplitHolding choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceSplitHoldingWithPackageID(contractID string, packageID string, args RegistrarServiceSplitHolding) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_SplitHolding", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceMergeHolding exercises the RegistrarService_MergeHolding choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceMergeHolding(contractID string, args RegistrarServiceMergeHolding) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_MergeHolding", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceMergeHoldingWithPackageID exercises the RegistrarService_MergeHolding choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceMergeHoldingWithPackageID(contractID string, packageID string, args RegistrarServiceMergeHolding) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_MergeHolding", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedTransfer exercises the RegistrarService_ExecuteAcceptedTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedTransfer(contractID string, args RegistrarServiceExecuteAcceptedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedTransferWithPackageID exercises the RegistrarService_ExecuteAcceptedTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedTransferWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedTransfer exercises the RegistrarService_FailAcceptedTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedTransfer(contractID string, args RegistrarServiceFailAcceptedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedTransferWithPackageID exercises the RegistrarService_FailAcceptedTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedTransferWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedLock exercises the RegistrarService_ExecuteAcceptedLock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedLock(contractID string, args RegistrarServiceExecuteAcceptedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedLockWithPackageID exercises the RegistrarService_ExecuteAcceptedLock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedLockWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedLock exercises the RegistrarService_FailAcceptedLock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedLock(contractID string, args RegistrarServiceFailAcceptedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedLockWithPackageID exercises the RegistrarService_FailAcceptedLock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedLockWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedUnlock exercises the RegistrarService_ExecuteAcceptedUnlock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedUnlock(contractID string, args RegistrarServiceExecuteAcceptedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedUnlockWithPackageID exercises the RegistrarService_ExecuteAcceptedUnlock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedUnlockWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedUnlock exercises the RegistrarService_FailAcceptedUnlock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedUnlock(contractID string, args RegistrarServiceFailAcceptedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedUnlockWithPackageID exercises the RegistrarService_FailAcceptedUnlock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedUnlockWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedMint exercises the RegistrarService_ExecuteAcceptedMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedMint(contractID string, args RegistrarServiceExecuteAcceptedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedMintWithPackageID exercises the RegistrarService_ExecuteAcceptedMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedMintWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedMint exercises the RegistrarService_FailAcceptedMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedMint(contractID string, args RegistrarServiceFailAcceptedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedMintWithPackageID exercises the RegistrarService_FailAcceptedMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedMintWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedBurn exercises the RegistrarService_ExecuteAcceptedBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceExecuteAcceptedBurn(contractID string, args RegistrarServiceExecuteAcceptedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceExecuteAcceptedBurnWithPackageID exercises the RegistrarService_ExecuteAcceptedBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceExecuteAcceptedBurnWithPackageID(contractID string, packageID string, args RegistrarServiceExecuteAcceptedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ExecuteAcceptedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedBurn exercises the RegistrarService_FailAcceptedBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceFailAcceptedBurn(contractID string, args RegistrarServiceFailAcceptedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceFailAcceptedBurnWithPackageID exercises the RegistrarService_FailAcceptedBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceFailAcceptedBurnWithPackageID(contractID string, packageID string, args RegistrarServiceFailAcceptedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_FailAcceptedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedMint exercises the RegistrarService_DeleteRejectedMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedMint(contractID string, args RegistrarServiceDeleteRejectedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedMintWithPackageID exercises the RegistrarService_DeleteRejectedMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedMintWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedMint exercises the RegistrarService_DeleteFailedMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedMint(contractID string, args RegistrarServiceDeleteFailedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedMintWithPackageID exercises the RegistrarService_DeleteFailedMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedMintWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedMint exercises the RegistrarService_DeleteExecutedMint choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedMint(contractID string, args RegistrarServiceDeleteExecutedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedMintWithPackageID exercises the RegistrarService_DeleteExecutedMint choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedMintWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedMint) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedMint", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedBurn exercises the RegistrarService_DeleteRejectedBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedBurn(contractID string, args RegistrarServiceDeleteRejectedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedBurnWithPackageID exercises the RegistrarService_DeleteRejectedBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedBurnWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedBurn exercises the RegistrarService_DeleteFailedBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedBurn(contractID string, args RegistrarServiceDeleteFailedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedBurnWithPackageID exercises the RegistrarService_DeleteFailedBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedBurnWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedBurn exercises the RegistrarService_DeleteExecutedBurn choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedBurn(contractID string, args RegistrarServiceDeleteExecutedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedBurnWithPackageID exercises the RegistrarService_DeleteExecutedBurn choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedBurnWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedBurn) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedBurn", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedLock exercises the RegistrarService_DeleteRejectedLock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedLock(contractID string, args RegistrarServiceDeleteRejectedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedLockWithPackageID exercises the RegistrarService_DeleteRejectedLock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedLockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedLock exercises the RegistrarService_DeleteFailedLock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedLock(contractID string, args RegistrarServiceDeleteFailedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedLockWithPackageID exercises the RegistrarService_DeleteFailedLock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedLockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedLock exercises the RegistrarService_DeleteExecutedLock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedLock(contractID string, args RegistrarServiceDeleteExecutedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedLockWithPackageID exercises the RegistrarService_DeleteExecutedLock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedLockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedLock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedUnlock exercises the RegistrarService_DeleteRejectedUnlock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedUnlock(contractID string, args RegistrarServiceDeleteRejectedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedUnlockWithPackageID exercises the RegistrarService_DeleteRejectedUnlock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedUnlockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedUnlock exercises the RegistrarService_DeleteFailedUnlock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedUnlock(contractID string, args RegistrarServiceDeleteFailedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedUnlockWithPackageID exercises the RegistrarService_DeleteFailedUnlock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedUnlockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedUnlock exercises the RegistrarService_DeleteExecutedUnlock choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedUnlock(contractID string, args RegistrarServiceDeleteExecutedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedUnlockWithPackageID exercises the RegistrarService_DeleteExecutedUnlock choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedUnlockWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedUnlock", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedTransfer exercises the RegistrarService_DeleteRejectedTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedTransfer(contractID string, args RegistrarServiceDeleteRejectedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedTransferWithPackageID exercises the RegistrarService_DeleteRejectedTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedTransferWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedTransfers exercises the RegistrarService_DeleteRejectedTransfers choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteRejectedTransfers(contractID string, args RegistrarServiceDeleteRejectedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteRejectedTransfersWithPackageID exercises the RegistrarService_DeleteRejectedTransfers choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteRejectedTransfersWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteRejectedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteRejectedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedTransfer exercises the RegistrarService_DeleteFailedTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedTransfer(contractID string, args RegistrarServiceDeleteFailedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedTransferWithPackageID exercises the RegistrarService_DeleteFailedTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedTransferWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedTransfers exercises the RegistrarService_DeleteFailedTransfers choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteFailedTransfers(contractID string, args RegistrarServiceDeleteFailedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteFailedTransfersWithPackageID exercises the RegistrarService_DeleteFailedTransfers choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteFailedTransfersWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteFailedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteFailedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedTransfer exercises the RegistrarService_DeleteExecutedTransfer choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedTransfer(contractID string, args RegistrarServiceDeleteExecutedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedTransferWithPackageID exercises the RegistrarService_DeleteExecutedTransfer choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedTransferWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedTransfer", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedTransfers exercises the RegistrarService_DeleteExecutedTransfers choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceDeleteExecutedTransfers(contractID string, args RegistrarServiceDeleteExecutedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceDeleteExecutedTransfersWithPackageID exercises the RegistrarService_DeleteExecutedTransfers choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceDeleteExecutedTransfersWithPackageID(contractID string, packageID string, args RegistrarServiceDeleteExecutedTransfers) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_DeleteExecutedTransfers", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateAllocationFactory exercises the RegistrarService_CreateAllocationFactory choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCreateAllocationFactory(contractID string, args RegistrarServiceCreateAllocationFactory) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateAllocationFactory", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateAllocationFactoryWithPackageID exercises the RegistrarService_CreateAllocationFactory choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCreateAllocationFactoryWithPackageID(contractID string, packageID string, args RegistrarServiceCreateAllocationFactory) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateAllocationFactory", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAllocationFactory exercises the RegistrarService_ArchiveAllocationFactory choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveAllocationFactory(contractID string, args RegistrarServiceArchiveAllocationFactory) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAllocationFactory", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveAllocationFactoryWithPackageID exercises the RegistrarService_ArchiveAllocationFactory choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveAllocationFactoryWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveAllocationFactory) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveAllocationFactory", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateTransferRule exercises the RegistrarService_CreateTransferRule choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceCreateTransferRule(contractID string, args RegistrarServiceCreateTransferRule) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateTransferRule", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceCreateTransferRuleWithPackageID exercises the RegistrarService_CreateTransferRule choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceCreateTransferRuleWithPackageID(contractID string, packageID string, args RegistrarServiceCreateTransferRule) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_CreateTransferRule", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveTransferRule exercises the RegistrarService_ArchiveTransferRule choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) RegistrarServiceArchiveTransferRule(contractID string, args RegistrarServiceArchiveTransferRule) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveTransferRule", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceArchiveTransferRuleWithPackageID exercises the RegistrarService_ArchiveTransferRule choice using the provided package ID instead of package name +func (t RegistrarService) RegistrarServiceArchiveTransferRuleWithPackageID(contractID string, packageID string, args RegistrarServiceArchiveTransferRule) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "RegistrarService_ArchiveTransferRule", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RegistrarService contract +// This method uses the package name in the template ID +func (t RegistrarService) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RegistrarService) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarService"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RegistrarServiceRequest is a Template type +type RegistrarServiceRequest struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + CreateTransferRule *types.BOOL `json:"createTransferRule" hex:"optional"` + CreateAllocationFactory *types.BOOL `json:"createAllocationFactory" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RegistrarServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RegistrarServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RegistrarServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + if t.CreateTransferRule != nil { + args["createTransferRule"] = map[string]any{ + "_type": "optional", + "value": bool(*t.CreateTransferRule), + } + } else { + args["createTransferRule"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.CreateAllocationFactory != nil { + args["createAllocationFactory"] = map[string]any{ + "_type": "optional", + "value": bool(*t.CreateAllocationFactory), + } + } else { + args["createAllocationFactory"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RegistrarServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + if t.CreateTransferRule != nil { + args["createTransferRule"] = map[string]any{ + "_type": "optional", + "value": bool(*t.CreateTransferRule), + } + } else { + args["createTransferRule"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.CreateAllocationFactory != nil { + args["createAllocationFactory"] = map[string]any{ + "_type": "optional", + "value": bool(*t.CreateAllocationFactory), + } + } else { + args["createAllocationFactory"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RegistrarServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequest to hex string (Canton MCMS format) +func (t RegistrarServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RegistrarServiceRequest + +// RegistrarServiceRequestAccept exercises the RegistrarServiceRequest_Accept choice on this RegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RegistrarServiceRequest) RegistrarServiceRequestAccept(contractID string, args RegistrarServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRequestAcceptWithPackageID exercises the RegistrarServiceRequest_Accept choice using the provided package ID instead of package name +func (t RegistrarServiceRequest) RegistrarServiceRequestAcceptWithPackageID(contractID string, packageID string, args RegistrarServiceRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Accept", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRequestReject exercises the RegistrarServiceRequest_Reject choice on this RegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RegistrarServiceRequest) RegistrarServiceRequestReject(contractID string, args RegistrarServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRequestRejectWithPackageID exercises the RegistrarServiceRequest_Reject choice using the provided package ID instead of package name +func (t RegistrarServiceRequest) RegistrarServiceRequestRejectWithPackageID(contractID string, packageID string, args RegistrarServiceRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Reject", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRequestCancel exercises the RegistrarServiceRequest_Cancel choice on this RegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RegistrarServiceRequest) RegistrarServiceRequestCancel(contractID string, args RegistrarServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// RegistrarServiceRequestCancelWithPackageID exercises the RegistrarServiceRequest_Cancel choice using the provided package ID instead of package name +func (t RegistrarServiceRequest) RegistrarServiceRequestCancelWithPackageID(contractID string, packageID string, args RegistrarServiceRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "RegistrarServiceRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RegistrarServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RegistrarServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RegistrarServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RegistrarServiceRequestAccept is a Record type +type RegistrarServiceRequestAccept struct { + ProviderConfigurationCid types.CONTRACT_ID `json:"providerConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` +} + +// ToMap converts RegistrarServiceRequestAccept to a map for DAML arguments +func (t RegistrarServiceRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["providerConfigurationCid"] = model.NestedToDAMLValue(t.ProviderConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t RegistrarServiceRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestAccept to hex string (Canton MCMS format) +func (t RegistrarServiceRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestAccept from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRequestAcceptResult is a Record type +type RegistrarServiceRequestAcceptResult struct { + RegistrarServiceCid types.CONTRACT_ID `json:"registrarServiceCid"` + TransferRuleCid *types.CONTRACT_ID `json:"transferRuleCid" hex:"optional"` + AllocationFactoryCid *types.CONTRACT_ID `json:"allocationFactoryCid" hex:"optional"` +} + +// ToMap converts RegistrarServiceRequestAcceptResult to a map for DAML arguments +func (t RegistrarServiceRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarServiceCid"] = model.NestedToDAMLValue(t.RegistrarServiceCid) + + if t.TransferRuleCid != nil { + m["transferRuleCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.TransferRuleCid), + } + } else { + m["transferRuleCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.AllocationFactoryCid != nil { + m["allocationFactoryCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.AllocationFactoryCid), + } + } else { + m["allocationFactoryCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t RegistrarServiceRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestAcceptResult to hex string (Canton MCMS format) +func (t RegistrarServiceRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestAcceptResult from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRequestCancel is a Record type +type RegistrarServiceRequestCancel struct { +} + +// ToMap converts RegistrarServiceRequestCancel to a map for DAML arguments +func (t RegistrarServiceRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestCancel to hex string (Canton MCMS format) +func (t RegistrarServiceRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestCancel from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRequestCancelResult is a Record type +type RegistrarServiceRequestCancelResult struct { +} + +// ToMap converts RegistrarServiceRequestCancelResult to a map for DAML arguments +func (t RegistrarServiceRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestCancelResult to hex string (Canton MCMS format) +func (t RegistrarServiceRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestCancelResult from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRequestReject is a Record type +type RegistrarServiceRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts RegistrarServiceRequestReject to a map for DAML arguments +func (t RegistrarServiceRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t RegistrarServiceRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestReject to hex string (Canton MCMS format) +func (t RegistrarServiceRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestReject from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRequestRejectResult is a Record type +type RegistrarServiceRequestRejectResult struct { + RejectedRegistrarServiceRequestCid types.CONTRACT_ID `json:"rejectedRegistrarServiceRequestCid"` +} + +// ToMap converts RegistrarServiceRequestRejectResult to a map for DAML arguments +func (t RegistrarServiceRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedRegistrarServiceRequestCid"] = model.NestedToDAMLValue(t.RejectedRegistrarServiceRequestCid) + + return m +} + +func (t RegistrarServiceRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRequestRejectResult to hex string (Canton MCMS format) +func (t RegistrarServiceRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRequestRejectResult from hex string (Canton MCMS format) +func (t *RegistrarServiceRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceAcceptBurnRequest is a Record type +type RegistrarServiceAcceptBurnRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnRequestAccept `json:"payload"` +} + +// ToMap converts RegistrarServiceAcceptBurnRequest to a map for DAML arguments +func (t RegistrarServiceAcceptBurnRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceAcceptBurnRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceAcceptBurnRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceAcceptBurnRequest to hex string (Canton MCMS format) +func (t RegistrarServiceAcceptBurnRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceAcceptBurnRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceAcceptBurnRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceAcceptEnforcementServiceRequest is a Record type +type RegistrarServiceAcceptEnforcementServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload EnforcementServiceRequestAccept `json:"payload"` +} + +// ToMap converts RegistrarServiceAcceptEnforcementServiceRequest to a map for DAML arguments +func (t RegistrarServiceAcceptEnforcementServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceAcceptEnforcementServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceAcceptEnforcementServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceAcceptEnforcementServiceRequest to hex string (Canton MCMS format) +func (t RegistrarServiceAcceptEnforcementServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceAcceptEnforcementServiceRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceAcceptEnforcementServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceAcceptForceTransferRequest is a Record type +type RegistrarServiceAcceptForceTransferRequest struct { + SenderEnforcementServiceCid types.CONTRACT_ID `json:"senderEnforcementServiceCid"` + ReceiverEnforcementServiceCid types.CONTRACT_ID `json:"receiverEnforcementServiceCid"` + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ForceTransferRequestAccept `json:"payload"` +} + +// ToMap converts RegistrarServiceAcceptForceTransferRequest to a map for DAML arguments +func (t RegistrarServiceAcceptForceTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["senderEnforcementServiceCid"] = model.NestedToDAMLValue(t.SenderEnforcementServiceCid) + + m["receiverEnforcementServiceCid"] = model.NestedToDAMLValue(t.ReceiverEnforcementServiceCid) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceAcceptForceTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceAcceptForceTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceAcceptForceTransferRequest to hex string (Canton MCMS format) +func (t RegistrarServiceAcceptForceTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceAcceptForceTransferRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceAcceptForceTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceAcceptMintRequest is a Record type +type RegistrarServiceAcceptMintRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintRequestAccept `json:"payload"` +} + +// ToMap converts RegistrarServiceAcceptMintRequest to a map for DAML arguments +func (t RegistrarServiceAcceptMintRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceAcceptMintRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceAcceptMintRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceAcceptMintRequest to hex string (Canton MCMS format) +func (t RegistrarServiceAcceptMintRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceAcceptMintRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceAcceptMintRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAllocationFactory is a Record type +type RegistrarServiceArchiveAllocationFactory struct { + AllocationFactoryCid types.CONTRACT_ID `json:"allocationFactoryCid"` +} + +// ToMap converts RegistrarServiceArchiveAllocationFactory to a map for DAML arguments +func (t RegistrarServiceArchiveAllocationFactory) ToMap() map[string]any { + m := make(map[string]any) + + m["allocationFactoryCid"] = model.NestedToDAMLValue(t.AllocationFactoryCid) + + return m +} + +func (t RegistrarServiceArchiveAllocationFactory) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAllocationFactory) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAllocationFactory to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAllocationFactory) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAllocationFactory from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAllocationFactory) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAllocationFactoryResult is a Record type +type RegistrarServiceArchiveAllocationFactoryResult struct { +} + +// ToMap converts RegistrarServiceArchiveAllocationFactoryResult to a map for DAML arguments +func (t RegistrarServiceArchiveAllocationFactoryResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceArchiveAllocationFactoryResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAllocationFactoryResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAllocationFactoryResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAllocationFactoryResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAllocationFactoryResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAllocationFactoryResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAndCreateInstrumentConfiguration is a Record type +type RegistrarServiceArchiveAndCreateInstrumentConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload RegistrarServiceCreateInstrumentConfiguration `json:"payload"` +} + +// ToMap converts RegistrarServiceArchiveAndCreateInstrumentConfiguration to a map for DAML arguments +func (t RegistrarServiceArchiveAndCreateInstrumentConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceArchiveAndCreateInstrumentConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAndCreateInstrumentConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAndCreateInstrumentConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAndCreateInstrumentConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAndCreateInstrumentConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAndCreateInstrumentConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAndCreateInstrumentConfigurationResult is a Record type +type RegistrarServiceArchiveAndCreateInstrumentConfigurationResult struct { + ArchiveResult RegistrarServiceArchiveInstrumentConfigurationResult `json:"archiveResult"` + CreateResult RegistrarServiceCreateInstrumentConfigurationResult `json:"createResult"` +} + +// ToMap converts RegistrarServiceArchiveAndCreateInstrumentConfigurationResult to a map for DAML arguments +func (t RegistrarServiceArchiveAndCreateInstrumentConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["archiveResult"] = model.NestedToDAMLValue(t.ArchiveResult) + + m["createResult"] = model.NestedToDAMLValue(t.CreateResult) + + return m +} + +func (t RegistrarServiceArchiveAndCreateInstrumentConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAndCreateInstrumentConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAndCreateInstrumentConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAndCreateInstrumentConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAndCreateInstrumentConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAndCreateInstrumentConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAndCreateRegistrarConfiguration is a Record type +type RegistrarServiceArchiveAndCreateRegistrarConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload RegistrarServiceCreateRegistrarConfiguration `json:"payload"` +} + +// ToMap converts RegistrarServiceArchiveAndCreateRegistrarConfiguration to a map for DAML arguments +func (t RegistrarServiceArchiveAndCreateRegistrarConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceArchiveAndCreateRegistrarConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAndCreateRegistrarConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAndCreateRegistrarConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAndCreateRegistrarConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAndCreateRegistrarConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAndCreateRegistrarConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveAndCreateRegistrarConfigurationResult is a Record type +type RegistrarServiceArchiveAndCreateRegistrarConfigurationResult struct { + ArchiveResult RegistrarServiceArchiveRegistrarConfigurationResult `json:"archiveResult"` + CreateResult RegistrarServiceCreateRegistrarConfigurationResult `json:"createResult"` +} + +// ToMap converts RegistrarServiceArchiveAndCreateRegistrarConfigurationResult to a map for DAML arguments +func (t RegistrarServiceArchiveAndCreateRegistrarConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["archiveResult"] = model.NestedToDAMLValue(t.ArchiveResult) + + m["createResult"] = model.NestedToDAMLValue(t.CreateResult) + + return m +} + +func (t RegistrarServiceArchiveAndCreateRegistrarConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveAndCreateRegistrarConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveAndCreateRegistrarConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveAndCreateRegistrarConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveAndCreateRegistrarConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveAndCreateRegistrarConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveInstrumentConfiguration is a Record type +type RegistrarServiceArchiveInstrumentConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` +} + +// ToMap converts RegistrarServiceArchiveInstrumentConfiguration to a map for DAML arguments +func (t RegistrarServiceArchiveInstrumentConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + return m +} + +func (t RegistrarServiceArchiveInstrumentConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveInstrumentConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveInstrumentConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveInstrumentConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveInstrumentConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveInstrumentConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveInstrumentConfigurationResult is a Record type +type RegistrarServiceArchiveInstrumentConfigurationResult struct { +} + +// ToMap converts RegistrarServiceArchiveInstrumentConfigurationResult to a map for DAML arguments +func (t RegistrarServiceArchiveInstrumentConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceArchiveInstrumentConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveInstrumentConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveInstrumentConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveInstrumentConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveInstrumentConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveInstrumentConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveRegistrarConfiguration is a Record type +type RegistrarServiceArchiveRegistrarConfiguration struct { + Cid types.CONTRACT_ID `json:"cid"` +} + +// ToMap converts RegistrarServiceArchiveRegistrarConfiguration to a map for DAML arguments +func (t RegistrarServiceArchiveRegistrarConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + return m +} + +func (t RegistrarServiceArchiveRegistrarConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveRegistrarConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveRegistrarConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveRegistrarConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveRegistrarConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveRegistrarConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveRegistrarConfigurationResult is a Record type +type RegistrarServiceArchiveRegistrarConfigurationResult struct { +} + +// ToMap converts RegistrarServiceArchiveRegistrarConfigurationResult to a map for DAML arguments +func (t RegistrarServiceArchiveRegistrarConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceArchiveRegistrarConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveRegistrarConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveRegistrarConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveRegistrarConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveRegistrarConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveRegistrarConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveTransferRule is a Record type +type RegistrarServiceArchiveTransferRule struct { + Cid types.CONTRACT_ID `json:"cid"` +} + +// ToMap converts RegistrarServiceArchiveTransferRule to a map for DAML arguments +func (t RegistrarServiceArchiveTransferRule) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + return m +} + +func (t RegistrarServiceArchiveTransferRule) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveTransferRule) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveTransferRule to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveTransferRule) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveTransferRule from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveTransferRule) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceArchiveTransferRuleResult is a Record type +type RegistrarServiceArchiveTransferRuleResult struct { +} + +// ToMap converts RegistrarServiceArchiveTransferRuleResult to a map for DAML arguments +func (t RegistrarServiceArchiveTransferRuleResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceArchiveTransferRuleResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceArchiveTransferRuleResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceArchiveTransferRuleResult to hex string (Canton MCMS format) +func (t RegistrarServiceArchiveTransferRuleResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceArchiveTransferRuleResult from hex string (Canton MCMS format) +func (t *RegistrarServiceArchiveTransferRuleResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCancelBurnOffer is a Record type +type RegistrarServiceCancelBurnOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnOfferCancel `json:"payload"` +} + +// ToMap converts RegistrarServiceCancelBurnOffer to a map for DAML arguments +func (t RegistrarServiceCancelBurnOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceCancelBurnOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCancelBurnOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCancelBurnOffer to hex string (Canton MCMS format) +func (t RegistrarServiceCancelBurnOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCancelBurnOffer from hex string (Canton MCMS format) +func (t *RegistrarServiceCancelBurnOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCancelMintOffer is a Record type +type RegistrarServiceCancelMintOffer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintOfferCancel `json:"payload"` +} + +// ToMap converts RegistrarServiceCancelMintOffer to a map for DAML arguments +func (t RegistrarServiceCancelMintOffer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceCancelMintOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCancelMintOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCancelMintOffer to hex string (Canton MCMS format) +func (t RegistrarServiceCancelMintOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCancelMintOffer from hex string (Canton MCMS format) +func (t *RegistrarServiceCancelMintOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateAllocationFactory is a Record type +type RegistrarServiceCreateAllocationFactory struct { +} + +// ToMap converts RegistrarServiceCreateAllocationFactory to a map for DAML arguments +func (t RegistrarServiceCreateAllocationFactory) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceCreateAllocationFactory) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateAllocationFactory) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateAllocationFactory to hex string (Canton MCMS format) +func (t RegistrarServiceCreateAllocationFactory) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateAllocationFactory from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateAllocationFactory) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateAllocationFactoryResult is a Record type +type RegistrarServiceCreateAllocationFactoryResult struct { + AllocationFactoryCid types.CONTRACT_ID `json:"allocationFactoryCid"` +} + +// ToMap converts RegistrarServiceCreateAllocationFactoryResult to a map for DAML arguments +func (t RegistrarServiceCreateAllocationFactoryResult) ToMap() map[string]any { + m := make(map[string]any) + + m["allocationFactoryCid"] = model.NestedToDAMLValue(t.AllocationFactoryCid) + + return m +} + +func (t RegistrarServiceCreateAllocationFactoryResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateAllocationFactoryResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateAllocationFactoryResult to hex string (Canton MCMS format) +func (t RegistrarServiceCreateAllocationFactoryResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateAllocationFactoryResult from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateAllocationFactoryResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateInstrumentConfiguration is a Record type +type RegistrarServiceCreateInstrumentConfiguration struct { + InstrumentId types.TEXT `json:"instrumentId"` + AdditionalIdentifiers []registry_holding_v0.InstrumentIdentifier `json:"additionalIdentifiers"` + IssuerRequirements []credential_v0.PartyCredentialRequirement `json:"issuerRequirements"` + HolderRequirements []credential_v0.PartyCredentialRequirement `json:"holderRequirements"` +} + +// ToMap converts RegistrarServiceCreateInstrumentConfiguration to a map for DAML arguments +func (t RegistrarServiceCreateInstrumentConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentId"] = string(t.InstrumentId) + + m["additionalIdentifiers"] = func() []any { + res := make([]any, 0, len(t.AdditionalIdentifiers)) + for _, e := range t.AdditionalIdentifiers { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + m["issuerRequirements"] = func() []any { + res := make([]any, 0, len(t.IssuerRequirements)) + for _, e := range t.IssuerRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + m["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t RegistrarServiceCreateInstrumentConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateInstrumentConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateInstrumentConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceCreateInstrumentConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateInstrumentConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateInstrumentConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateInstrumentConfigurationResult is a Record type +type RegistrarServiceCreateInstrumentConfigurationResult struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` +} + +// ToMap converts RegistrarServiceCreateInstrumentConfigurationResult to a map for DAML arguments +func (t RegistrarServiceCreateInstrumentConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + return m +} + +func (t RegistrarServiceCreateInstrumentConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateInstrumentConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateInstrumentConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceCreateInstrumentConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateInstrumentConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateInstrumentConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateRegistrarConfiguration is a Record type +type RegistrarServiceCreateRegistrarConfiguration struct { + EnforcementRequirements []credential_v0.PartyCredentialRequirement `json:"enforcementRequirements"` +} + +// ToMap converts RegistrarServiceCreateRegistrarConfiguration to a map for DAML arguments +func (t RegistrarServiceCreateRegistrarConfiguration) ToMap() map[string]any { + m := make(map[string]any) + + m["enforcementRequirements"] = func() []any { + res := make([]any, 0, len(t.EnforcementRequirements)) + for _, e := range t.EnforcementRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t RegistrarServiceCreateRegistrarConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateRegistrarConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateRegistrarConfiguration to hex string (Canton MCMS format) +func (t RegistrarServiceCreateRegistrarConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateRegistrarConfiguration from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateRegistrarConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateRegistrarConfigurationResult is a Record type +type RegistrarServiceCreateRegistrarConfigurationResult struct { + RegistrarConfigurationCid types.CONTRACT_ID `json:"registrarConfigurationCid"` +} + +// ToMap converts RegistrarServiceCreateRegistrarConfigurationResult to a map for DAML arguments +func (t RegistrarServiceCreateRegistrarConfigurationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarConfigurationCid"] = model.NestedToDAMLValue(t.RegistrarConfigurationCid) + + return m +} + +func (t RegistrarServiceCreateRegistrarConfigurationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateRegistrarConfigurationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateRegistrarConfigurationResult to hex string (Canton MCMS format) +func (t RegistrarServiceCreateRegistrarConfigurationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateRegistrarConfigurationResult from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateRegistrarConfigurationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateTransferRule is a Record type +type RegistrarServiceCreateTransferRule struct { +} + +// ToMap converts RegistrarServiceCreateTransferRule to a map for DAML arguments +func (t RegistrarServiceCreateTransferRule) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceCreateTransferRule) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateTransferRule) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateTransferRule to hex string (Canton MCMS format) +func (t RegistrarServiceCreateTransferRule) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateTransferRule from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateTransferRule) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceCreateTransferRuleResult is a Record type +type RegistrarServiceCreateTransferRuleResult struct { + TransferRuleCid types.CONTRACT_ID `json:"transferRuleCid"` +} + +// ToMap converts RegistrarServiceCreateTransferRuleResult to a map for DAML arguments +func (t RegistrarServiceCreateTransferRuleResult) ToMap() map[string]any { + m := make(map[string]any) + + m["transferRuleCid"] = model.NestedToDAMLValue(t.TransferRuleCid) + + return m +} + +func (t RegistrarServiceCreateTransferRuleResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceCreateTransferRuleResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceCreateTransferRuleResult to hex string (Canton MCMS format) +func (t RegistrarServiceCreateTransferRuleResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceCreateTransferRuleResult from hex string (Canton MCMS format) +func (t *RegistrarServiceCreateTransferRuleResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedBurn is a Record type +type RegistrarServiceDeleteExecutedBurn struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ExecutedBurnDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteExecutedBurn to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteExecutedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedBurn to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedLock is a Record type +type RegistrarServiceDeleteExecutedLock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ExecutedLockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteExecutedLock to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteExecutedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedLock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedLock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedMint is a Record type +type RegistrarServiceDeleteExecutedMint struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ExecutedMintDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteExecutedMint to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedMint) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteExecutedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedMint to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedMint from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedTransfer is a Record type +type RegistrarServiceDeleteExecutedTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ExecutedTransferDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteExecutedTransfer to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteExecutedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedTransfers is a Record type +type RegistrarServiceDeleteExecutedTransfers struct { + Cids []types.CONTRACT_ID `json:"cids"` + ChoiceObservers []types.PARTY `json:"choiceObservers"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarServiceDeleteExecutedTransfers to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedTransfers) ToMap() map[string]any { + m := make(map[string]any) + + m["cids"] = func() []any { + res := make([]any, 0, len(t.Cids)) + for _, e := range t.Cids { + res = append(res, e) + } + return res + }() + + m["choiceObservers"] = func() []any { + res := make([]any, 0, len(t.ChoiceObservers)) + for _, e := range t.ChoiceObservers { + res = append(res, e.ToMap()) + } + return res + }() + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarServiceDeleteExecutedTransfers) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedTransfers) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedTransfers to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedTransfers) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedTransfers from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedTransfers) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteExecutedUnlock is a Record type +type RegistrarServiceDeleteExecutedUnlock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ExecutedUnlockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteExecutedUnlock to a map for DAML arguments +func (t RegistrarServiceDeleteExecutedUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteExecutedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteExecutedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteExecutedUnlock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteExecutedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteExecutedUnlock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteExecutedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedBurn is a Record type +type RegistrarServiceDeleteFailedBurn struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.FailedBurnDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteFailedBurn to a map for DAML arguments +func (t RegistrarServiceDeleteFailedBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteFailedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedBurn to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedLock is a Record type +type RegistrarServiceDeleteFailedLock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.FailedLockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteFailedLock to a map for DAML arguments +func (t RegistrarServiceDeleteFailedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteFailedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedLock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedLock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedMint is a Record type +type RegistrarServiceDeleteFailedMint struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.FailedMintDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteFailedMint to a map for DAML arguments +func (t RegistrarServiceDeleteFailedMint) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteFailedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedMint to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedMint from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedTransfer is a Record type +type RegistrarServiceDeleteFailedTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.FailedTransferDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteFailedTransfer to a map for DAML arguments +func (t RegistrarServiceDeleteFailedTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteFailedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedTransfers is a Record type +type RegistrarServiceDeleteFailedTransfers struct { + Cids []types.CONTRACT_ID `json:"cids"` + ChoiceObservers []types.PARTY `json:"choiceObservers"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarServiceDeleteFailedTransfers to a map for DAML arguments +func (t RegistrarServiceDeleteFailedTransfers) ToMap() map[string]any { + m := make(map[string]any) + + m["cids"] = func() []any { + res := make([]any, 0, len(t.Cids)) + for _, e := range t.Cids { + res = append(res, e) + } + return res + }() + + m["choiceObservers"] = func() []any { + res := make([]any, 0, len(t.ChoiceObservers)) + for _, e := range t.ChoiceObservers { + res = append(res, e.ToMap()) + } + return res + }() + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarServiceDeleteFailedTransfers) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedTransfers) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedTransfers to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedTransfers) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedTransfers from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedTransfers) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteFailedUnlock is a Record type +type RegistrarServiceDeleteFailedUnlock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.FailedUnlockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteFailedUnlock to a map for DAML arguments +func (t RegistrarServiceDeleteFailedUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteFailedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteFailedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteFailedUnlock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteFailedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteFailedUnlock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteFailedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedBurn is a Record type +type RegistrarServiceDeleteRejectedBurn struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.RejectedBurnDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteRejectedBurn to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteRejectedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedBurn to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedLock is a Record type +type RegistrarServiceDeleteRejectedLock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.RejectedLockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteRejectedLock to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteRejectedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedLock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedLock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedMint is a Record type +type RegistrarServiceDeleteRejectedMint struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.RejectedMintDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteRejectedMint to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedMint) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteRejectedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedMint to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedMint from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedTransfer is a Record type +type RegistrarServiceDeleteRejectedTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.RejectedTransferDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteRejectedTransfer to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteRejectedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedTransfers is a Record type +type RegistrarServiceDeleteRejectedTransfers struct { + Cids []types.CONTRACT_ID `json:"cids"` + ChoiceObservers []types.PARTY `json:"choiceObservers"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarServiceDeleteRejectedTransfers to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedTransfers) ToMap() map[string]any { + m := make(map[string]any) + + m["cids"] = func() []any { + res := make([]any, 0, len(t.Cids)) + for _, e := range t.Cids { + res = append(res, e) + } + return res + }() + + m["choiceObservers"] = func() []any { + res := make([]any, 0, len(t.ChoiceObservers)) + for _, e := range t.ChoiceObservers { + res = append(res, e.ToMap()) + } + return res + }() + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarServiceDeleteRejectedTransfers) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedTransfers) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedTransfers to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedTransfers) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedTransfers from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedTransfers) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceDeleteRejectedUnlock is a Record type +type RegistrarServiceDeleteRejectedUnlock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.RejectedUnlockDelete `json:"payload"` +} + +// ToMap converts RegistrarServiceDeleteRejectedUnlock to a map for DAML arguments +func (t RegistrarServiceDeleteRejectedUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceDeleteRejectedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceDeleteRejectedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceDeleteRejectedUnlock to hex string (Canton MCMS format) +func (t RegistrarServiceDeleteRejectedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceDeleteRejectedUnlock from hex string (Canton MCMS format) +func (t *RegistrarServiceDeleteRejectedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedBurn is a Record type +type RegistrarServiceExecuteAcceptedBurn struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedBurnExecute `json:"payload"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedBurn to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceExecuteAcceptedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedBurn to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedForceTransfer is a Record type +type RegistrarServiceExecuteAcceptedForceTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedForceTransferExecute `json:"payload"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedForceTransfer to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedForceTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarServiceExecuteAcceptedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedForceTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedForceTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedLock is a Record type +type RegistrarServiceExecuteAcceptedLock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedLockExecute `json:"payload"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedLock to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceExecuteAcceptedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedLock to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedLock from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedMint is a Record type +type RegistrarServiceExecuteAcceptedMint struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedMintExecute `json:"payload"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedMint to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedMint) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceExecuteAcceptedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedMint to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedMint from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedTransfer is a Record type +type RegistrarServiceExecuteAcceptedTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedTransferExecute `json:"payload"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedTransfer to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceExecuteAcceptedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceExecuteAcceptedUnlock is a Record type +type RegistrarServiceExecuteAcceptedUnlock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedUnlockExecute `json:"payload"` +} + +// ToMap converts RegistrarServiceExecuteAcceptedUnlock to a map for DAML arguments +func (t RegistrarServiceExecuteAcceptedUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceExecuteAcceptedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceExecuteAcceptedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceExecuteAcceptedUnlock to hex string (Canton MCMS format) +func (t RegistrarServiceExecuteAcceptedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceExecuteAcceptedUnlock from hex string (Canton MCMS format) +func (t *RegistrarServiceExecuteAcceptedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedBurn is a Record type +type RegistrarServiceFailAcceptedBurn struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedBurnFail `json:"payload"` +} + +// ToMap converts RegistrarServiceFailAcceptedBurn to a map for DAML arguments +func (t RegistrarServiceFailAcceptedBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceFailAcceptedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedBurn to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedForceTransfer is a Record type +type RegistrarServiceFailAcceptedForceTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedForceTransferFail `json:"payload"` + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RegistrarServiceFailAcceptedForceTransfer to a map for DAML arguments +func (t RegistrarServiceFailAcceptedForceTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RegistrarServiceFailAcceptedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedForceTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedForceTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedLock is a Record type +type RegistrarServiceFailAcceptedLock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedLockFail `json:"payload"` +} + +// ToMap converts RegistrarServiceFailAcceptedLock to a map for DAML arguments +func (t RegistrarServiceFailAcceptedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceFailAcceptedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedLock to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedLock from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedMint is a Record type +type RegistrarServiceFailAcceptedMint struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedMintFail `json:"payload"` +} + +// ToMap converts RegistrarServiceFailAcceptedMint to a map for DAML arguments +func (t RegistrarServiceFailAcceptedMint) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceFailAcceptedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedMint to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedMint from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedTransfer is a Record type +type RegistrarServiceFailAcceptedTransfer struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedTransferFail `json:"payload"` +} + +// ToMap converts RegistrarServiceFailAcceptedTransfer to a map for DAML arguments +func (t RegistrarServiceFailAcceptedTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceFailAcceptedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedTransfer to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedTransfer from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceFailAcceptedUnlock is a Record type +type RegistrarServiceFailAcceptedUnlock struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.AcceptedUnlockFail `json:"payload"` +} + +// ToMap converts RegistrarServiceFailAcceptedUnlock to a map for DAML arguments +func (t RegistrarServiceFailAcceptedUnlock) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceFailAcceptedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceFailAcceptedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceFailAcceptedUnlock to hex string (Canton MCMS format) +func (t RegistrarServiceFailAcceptedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceFailAcceptedUnlock from hex string (Canton MCMS format) +func (t *RegistrarServiceFailAcceptedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceMergeHolding is a Record type +type RegistrarServiceMergeHolding struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_holding_v0.HoldingMerge `json:"payload"` +} + +// ToMap converts RegistrarServiceMergeHolding to a map for DAML arguments +func (t RegistrarServiceMergeHolding) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceMergeHolding) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceMergeHolding) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceMergeHolding to hex string (Canton MCMS format) +func (t RegistrarServiceMergeHolding) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceMergeHolding from hex string (Canton MCMS format) +func (t *RegistrarServiceMergeHolding) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceOfferBurn is a Record type +type RegistrarServiceOfferBurn struct { + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts RegistrarServiceOfferBurn to a map for DAML arguments +func (t RegistrarServiceOfferBurn) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t RegistrarServiceOfferBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceOfferBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceOfferBurn to hex string (Canton MCMS format) +func (t RegistrarServiceOfferBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceOfferBurn from hex string (Canton MCMS format) +func (t *RegistrarServiceOfferBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceOfferBurnResult is a Record type +type RegistrarServiceOfferBurnResult struct { + BurnOfferCid types.CONTRACT_ID `json:"burnOfferCid"` +} + +// ToMap converts RegistrarServiceOfferBurnResult to a map for DAML arguments +func (t RegistrarServiceOfferBurnResult) ToMap() map[string]any { + m := make(map[string]any) + + m["burnOfferCid"] = model.NestedToDAMLValue(t.BurnOfferCid) + + return m +} + +func (t RegistrarServiceOfferBurnResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceOfferBurnResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceOfferBurnResult to hex string (Canton MCMS format) +func (t RegistrarServiceOfferBurnResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceOfferBurnResult from hex string (Canton MCMS format) +func (t *RegistrarServiceOfferBurnResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceOfferMint is a Record type +type RegistrarServiceOfferMint struct { + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + Batch registry_v0.Batch `json:"batch"` +} + +// ToMap converts RegistrarServiceOfferMint to a map for DAML arguments +func (t RegistrarServiceOfferMint) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t RegistrarServiceOfferMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceOfferMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceOfferMint to hex string (Canton MCMS format) +func (t RegistrarServiceOfferMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceOfferMint from hex string (Canton MCMS format) +func (t *RegistrarServiceOfferMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceOfferMintResult is a Record type +type RegistrarServiceOfferMintResult struct { + MintOfferCid types.CONTRACT_ID `json:"mintOfferCid"` +} + +// ToMap converts RegistrarServiceOfferMintResult to a map for DAML arguments +func (t RegistrarServiceOfferMintResult) ToMap() map[string]any { + m := make(map[string]any) + + m["mintOfferCid"] = model.NestedToDAMLValue(t.MintOfferCid) + + return m +} + +func (t RegistrarServiceOfferMintResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceOfferMintResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceOfferMintResult to hex string (Canton MCMS format) +func (t RegistrarServiceOfferMintResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceOfferMintResult from hex string (Canton MCMS format) +func (t *RegistrarServiceOfferMintResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRejectBurnRequest is a Record type +type RegistrarServiceRejectBurnRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.BurnRequestReject `json:"payload"` +} + +// ToMap converts RegistrarServiceRejectBurnRequest to a map for DAML arguments +func (t RegistrarServiceRejectBurnRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceRejectBurnRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRejectBurnRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRejectBurnRequest to hex string (Canton MCMS format) +func (t RegistrarServiceRejectBurnRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRejectBurnRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceRejectBurnRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRejectEnforcementServiceRequest is a Record type +type RegistrarServiceRejectEnforcementServiceRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload EnforcementServiceRequestReject `json:"payload"` +} + +// ToMap converts RegistrarServiceRejectEnforcementServiceRequest to a map for DAML arguments +func (t RegistrarServiceRejectEnforcementServiceRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceRejectEnforcementServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRejectEnforcementServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRejectEnforcementServiceRequest to hex string (Canton MCMS format) +func (t RegistrarServiceRejectEnforcementServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRejectEnforcementServiceRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceRejectEnforcementServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRejectForceTransferRequest is a Record type +type RegistrarServiceRejectForceTransferRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.ForceTransferRequestReject `json:"payload"` +} + +// ToMap converts RegistrarServiceRejectForceTransferRequest to a map for DAML arguments +func (t RegistrarServiceRejectForceTransferRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceRejectForceTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRejectForceTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRejectForceTransferRequest to hex string (Canton MCMS format) +func (t RegistrarServiceRejectForceTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRejectForceTransferRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceRejectForceTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceRejectMintRequest is a Record type +type RegistrarServiceRejectMintRequest struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_v0.MintRequestReject `json:"payload"` +} + +// ToMap converts RegistrarServiceRejectMintRequest to a map for DAML arguments +func (t RegistrarServiceRejectMintRequest) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceRejectMintRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceRejectMintRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceRejectMintRequest to hex string (Canton MCMS format) +func (t RegistrarServiceRejectMintRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceRejectMintRequest from hex string (Canton MCMS format) +func (t *RegistrarServiceRejectMintRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceSet is a Record type +type RegistrarServiceSet struct { + EnableResultContracts *types.BOOL `json:"enableResultContracts" hex:"optional"` +} + +// ToMap converts RegistrarServiceSet to a map for DAML arguments +func (t RegistrarServiceSet) ToMap() map[string]any { + m := make(map[string]any) + + if t.EnableResultContracts != nil { + m["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": bool(*t.EnableResultContracts), + } + } else { + m["enableResultContracts"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t RegistrarServiceSet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceSet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceSet to hex string (Canton MCMS format) +func (t RegistrarServiceSet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceSet from hex string (Canton MCMS format) +func (t *RegistrarServiceSet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceSplitHolding is a Record type +type RegistrarServiceSplitHolding struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload registry_holding_v0.HoldingSplit `json:"payload"` +} + +// ToMap converts RegistrarServiceSplitHolding to a map for DAML arguments +func (t RegistrarServiceSplitHolding) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceSplitHolding) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceSplitHolding) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceSplitHolding to hex string (Canton MCMS format) +func (t RegistrarServiceSplitHolding) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceSplitHolding from hex string (Canton MCMS format) +func (t *RegistrarServiceSplitHolding) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceTerminate is a Record type +type RegistrarServiceTerminate struct { +} + +// ToMap converts RegistrarServiceTerminate to a map for DAML arguments +func (t RegistrarServiceTerminate) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceTerminate) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceTerminate) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceTerminate to hex string (Canton MCMS format) +func (t RegistrarServiceTerminate) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceTerminate from hex string (Canton MCMS format) +func (t *RegistrarServiceTerminate) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceTerminateEnforcementService is a Record type +type RegistrarServiceTerminateEnforcementService struct { + Cid types.CONTRACT_ID `json:"cid"` + Payload EnforcementServiceTerminate `json:"payload"` +} + +// ToMap converts RegistrarServiceTerminateEnforcementService to a map for DAML arguments +func (t RegistrarServiceTerminateEnforcementService) ToMap() map[string]any { + m := make(map[string]any) + + m["cid"] = model.NestedToDAMLValue(t.Cid) + + m["payload"] = model.NestedToDAMLValue(t.Payload) + + return m +} + +func (t RegistrarServiceTerminateEnforcementService) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceTerminateEnforcementService) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceTerminateEnforcementService to hex string (Canton MCMS format) +func (t RegistrarServiceTerminateEnforcementService) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceTerminateEnforcementService from hex string (Canton MCMS format) +func (t *RegistrarServiceTerminateEnforcementService) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RegistrarServiceTerminateResult is a Record type +type RegistrarServiceTerminateResult struct { +} + +// ToMap converts RegistrarServiceTerminateResult to a map for DAML arguments +func (t RegistrarServiceTerminateResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RegistrarServiceTerminateResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RegistrarServiceTerminateResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RegistrarServiceTerminateResult to hex string (Canton MCMS format) +func (t RegistrarServiceTerminateResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RegistrarServiceTerminateResult from hex string (Canton MCMS format) +func (t *RegistrarServiceTerminateResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedBurn is a Template type +type RejectedBurn struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Burn Burn `json:"burn"` + Reason types.TEXT `json:"reason"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurn to hex string (Canton MCMS format) +func (t RejectedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurn from hex string (Canton MCMS format) +func (t *RejectedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedBurn + +// RejectedBurnDelete exercises the RejectedBurn_Delete choice on this RejectedBurn contract +// This method uses the package name in the template ID +func (t RejectedBurn) RejectedBurnDelete(contractID string, args RejectedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedBurnDeleteWithPackageID exercises the RejectedBurn_Delete choice using the provided package ID instead of package name +func (t RejectedBurn) RejectedBurnDeleteWithPackageID(contractID string, packageID string, args RejectedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedBurn contract +// This method uses the package name in the template ID +func (t RejectedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedBurnDelete is a Record type +type RejectedBurnDelete struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedBurnDelete to a map for DAML arguments +func (t RejectedBurnDelete) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedBurnDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurnDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurnDelete to hex string (Canton MCMS format) +func (t RejectedBurnDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurnDelete from hex string (Canton MCMS format) +func (t *RejectedBurnDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedBurnDeleteResult is a Record type +type RejectedBurnDeleteResult struct { +} + +// ToMap converts RejectedBurnDeleteResult to a map for DAML arguments +func (t RejectedBurnDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedBurnDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurnDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurnDeleteResult to hex string (Canton MCMS format) +func (t RejectedBurnDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurnDeleteResult from hex string (Canton MCMS format) +func (t *RejectedBurnDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedEnforcementServiceRequest is a Template type +type RejectedEnforcementServiceRequest struct { + Request EnforcementServiceRequest `json:"request"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedEnforcementServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedEnforcementServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedEnforcementServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedEnforcementServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedEnforcementServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedEnforcementServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedEnforcementServiceRequest to hex string (Canton MCMS format) +func (t RejectedEnforcementServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedEnforcementServiceRequest from hex string (Canton MCMS format) +func (t *RejectedEnforcementServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedEnforcementServiceRequest + +// Archive exercises the Archive choice on this RejectedEnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedEnforcementServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedEnforcementServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedEnforcementServiceRequestDelete exercises the RejectedEnforcementServiceRequest_Delete choice on this RejectedEnforcementServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedEnforcementServiceRequest) RejectedEnforcementServiceRequestDelete(contractID string, args RejectedEnforcementServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest"), + ContractID: contractID, + Choice: "RejectedEnforcementServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedEnforcementServiceRequestDeleteWithPackageID exercises the RejectedEnforcementServiceRequest_Delete choice using the provided package ID instead of package name +func (t RejectedEnforcementServiceRequest) RejectedEnforcementServiceRequestDeleteWithPackageID(contractID string, packageID string, args RejectedEnforcementServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Enforcement", "RejectedEnforcementServiceRequest"), + ContractID: contractID, + Choice: "RejectedEnforcementServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedEnforcementServiceRequestDelete is a Record type +type RejectedEnforcementServiceRequestDelete struct { +} + +// ToMap converts RejectedEnforcementServiceRequestDelete to a map for DAML arguments +func (t RejectedEnforcementServiceRequestDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedEnforcementServiceRequestDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedEnforcementServiceRequestDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedEnforcementServiceRequestDelete to hex string (Canton MCMS format) +func (t RejectedEnforcementServiceRequestDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedEnforcementServiceRequestDelete from hex string (Canton MCMS format) +func (t *RejectedEnforcementServiceRequestDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedEnforcementServiceRequestDeleteResult is a Record type +type RejectedEnforcementServiceRequestDeleteResult struct { +} + +// ToMap converts RejectedEnforcementServiceRequestDeleteResult to a map for DAML arguments +func (t RejectedEnforcementServiceRequestDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedEnforcementServiceRequestDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedEnforcementServiceRequestDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedEnforcementServiceRequestDeleteResult to hex string (Canton MCMS format) +func (t RejectedEnforcementServiceRequestDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedEnforcementServiceRequestDeleteResult from hex string (Canton MCMS format) +func (t *RejectedEnforcementServiceRequestDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedHolderServiceRequest is a Template type +type RejectedHolderServiceRequest struct { + Request HolderServiceRequest `json:"request"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedHolderServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedHolderServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedHolderServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedHolderServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedHolderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedHolderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedHolderServiceRequest to hex string (Canton MCMS format) +func (t RejectedHolderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedHolderServiceRequest from hex string (Canton MCMS format) +func (t *RejectedHolderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedHolderServiceRequest + +// RejectedHolderServiceRequestClean exercises the RejectedHolderServiceRequest_Clean choice on this RejectedHolderServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedHolderServiceRequest) RejectedHolderServiceRequestClean(contractID string, args RejectedHolderServiceRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "RejectedHolderServiceRequest_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedHolderServiceRequestCleanWithPackageID exercises the RejectedHolderServiceRequest_Clean choice using the provided package ID instead of package name +func (t RejectedHolderServiceRequest) RejectedHolderServiceRequestCleanWithPackageID(contractID string, packageID string, args RejectedHolderServiceRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "RejectedHolderServiceRequest_Clean", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedHolderServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedHolderServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedHolderServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedHolderServiceRequestDelete exercises the RejectedHolderServiceRequest_Delete choice on this RejectedHolderServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedHolderServiceRequest) RejectedHolderServiceRequestDelete(contractID string, args RejectedHolderServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "RejectedHolderServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedHolderServiceRequestDeleteWithPackageID exercises the RejectedHolderServiceRequest_Delete choice using the provided package ID instead of package name +func (t RejectedHolderServiceRequest) RejectedHolderServiceRequestDeleteWithPackageID(contractID string, packageID string, args RejectedHolderServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Holder", "RejectedHolderServiceRequest"), + ContractID: contractID, + Choice: "RejectedHolderServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedHolderServiceRequestClean is a Record type +type RejectedHolderServiceRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedHolderServiceRequestClean to a map for DAML arguments +func (t RejectedHolderServiceRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedHolderServiceRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedHolderServiceRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedHolderServiceRequestClean to hex string (Canton MCMS format) +func (t RejectedHolderServiceRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedHolderServiceRequestClean from hex string (Canton MCMS format) +func (t *RejectedHolderServiceRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedHolderServiceRequestDelete is a Record type +type RejectedHolderServiceRequestDelete struct { +} + +// ToMap converts RejectedHolderServiceRequestDelete to a map for DAML arguments +func (t RejectedHolderServiceRequestDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedHolderServiceRequestDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedHolderServiceRequestDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedHolderServiceRequestDelete to hex string (Canton MCMS format) +func (t RejectedHolderServiceRequestDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedHolderServiceRequestDelete from hex string (Canton MCMS format) +func (t *RejectedHolderServiceRequestDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedHolderServiceRequestDeleteResult is a Record type +type RejectedHolderServiceRequestDeleteResult struct { +} + +// ToMap converts RejectedHolderServiceRequestDeleteResult to a map for DAML arguments +func (t RejectedHolderServiceRequestDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedHolderServiceRequestDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedHolderServiceRequestDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedHolderServiceRequestDeleteResult to hex string (Canton MCMS format) +func (t RejectedHolderServiceRequestDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedHolderServiceRequestDeleteResult from hex string (Canton MCMS format) +func (t *RejectedHolderServiceRequestDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedMint is a Template type +type RejectedMint struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Mint Mint `json:"mint"` + Reason types.TEXT `json:"reason"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "RejectedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "RejectedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMint to hex string (Canton MCMS format) +func (t RejectedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMint from hex string (Canton MCMS format) +func (t *RejectedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedMint + +// RejectedMintDelete exercises the RejectedMint_Delete choice on this RejectedMint contract +// This method uses the package name in the template ID +func (t RejectedMint) RejectedMintDelete(contractID string, args RejectedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedMintDeleteWithPackageID exercises the RejectedMint_Delete choice using the provided package ID instead of package name +func (t RejectedMint) RejectedMintDeleteWithPackageID(contractID string, packageID string, args RejectedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedMint contract +// This method uses the package name in the template ID +func (t RejectedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedMintDelete is a Record type +type RejectedMintDelete struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedMintDelete to a map for DAML arguments +func (t RejectedMintDelete) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedMintDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMintDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMintDelete to hex string (Canton MCMS format) +func (t RejectedMintDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMintDelete from hex string (Canton MCMS format) +func (t *RejectedMintDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedMintDeleteResult is a Record type +type RejectedMintDeleteResult struct { +} + +// ToMap converts RejectedMintDeleteResult to a map for DAML arguments +func (t RejectedMintDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedMintDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMintDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMintDeleteResult to hex string (Canton MCMS format) +func (t RejectedMintDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMintDeleteResult from hex string (Canton MCMS format) +func (t *RejectedMintDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedProviderServiceRequest is a Template type +type RejectedProviderServiceRequest struct { + Request ProviderServiceRequest `json:"request"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedProviderServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedProviderServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedProviderServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedProviderServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedProviderServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedProviderServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedProviderServiceRequest to hex string (Canton MCMS format) +func (t RejectedProviderServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedProviderServiceRequest from hex string (Canton MCMS format) +func (t *RejectedProviderServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedProviderServiceRequest + +// Archive exercises the Archive choice on this RejectedProviderServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedProviderServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedProviderServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedProviderServiceRequestDelete exercises the RejectedProviderServiceRequest_Delete choice on this RejectedProviderServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedProviderServiceRequest) RejectedProviderServiceRequestDelete(contractID string, args RejectedProviderServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest"), + ContractID: contractID, + Choice: "RejectedProviderServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedProviderServiceRequestDeleteWithPackageID exercises the RejectedProviderServiceRequest_Delete choice using the provided package ID instead of package name +func (t RejectedProviderServiceRequest) RejectedProviderServiceRequestDeleteWithPackageID(contractID string, packageID string, args RejectedProviderServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Provider", "RejectedProviderServiceRequest"), + ContractID: contractID, + Choice: "RejectedProviderServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedProviderServiceRequestDelete is a Record type +type RejectedProviderServiceRequestDelete struct { +} + +// ToMap converts RejectedProviderServiceRequestDelete to a map for DAML arguments +func (t RejectedProviderServiceRequestDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedProviderServiceRequestDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedProviderServiceRequestDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedProviderServiceRequestDelete to hex string (Canton MCMS format) +func (t RejectedProviderServiceRequestDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedProviderServiceRequestDelete from hex string (Canton MCMS format) +func (t *RejectedProviderServiceRequestDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedProviderServiceRequestDeleteResult is a Record type +type RejectedProviderServiceRequestDeleteResult struct { +} + +// ToMap converts RejectedProviderServiceRequestDeleteResult to a map for DAML arguments +func (t RejectedProviderServiceRequestDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedProviderServiceRequestDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedProviderServiceRequestDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedProviderServiceRequestDeleteResult to hex string (Canton MCMS format) +func (t RejectedProviderServiceRequestDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedProviderServiceRequestDeleteResult from hex string (Canton MCMS format) +func (t *RejectedProviderServiceRequestDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedRegistrarServiceRequest is a Template type +type RejectedRegistrarServiceRequest struct { + Request RegistrarServiceRequest `json:"request"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedRegistrarServiceRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedRegistrarServiceRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedRegistrarServiceRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedRegistrarServiceRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["request"] = model.NestedToDAMLValue(t.Request) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedRegistrarServiceRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedRegistrarServiceRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedRegistrarServiceRequest to hex string (Canton MCMS format) +func (t RejectedRegistrarServiceRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedRegistrarServiceRequest from hex string (Canton MCMS format) +func (t *RejectedRegistrarServiceRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedRegistrarServiceRequest + +// Archive exercises the Archive choice on this RejectedRegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedRegistrarServiceRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedRegistrarServiceRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedRegistrarServiceRequestDelete exercises the RejectedRegistrarServiceRequest_Delete choice on this RejectedRegistrarServiceRequest contract +// This method uses the package name in the template ID +func (t RejectedRegistrarServiceRequest) RejectedRegistrarServiceRequestDelete(contractID string, args RejectedRegistrarServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest"), + ContractID: contractID, + Choice: "RejectedRegistrarServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedRegistrarServiceRequestDeleteWithPackageID exercises the RejectedRegistrarServiceRequest_Delete choice using the provided package ID instead of package name +func (t RejectedRegistrarServiceRequest) RejectedRegistrarServiceRequestDeleteWithPackageID(contractID string, packageID string, args RejectedRegistrarServiceRequestDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Service.Registrar", "RejectedRegistrarServiceRequest"), + ContractID: contractID, + Choice: "RejectedRegistrarServiceRequest_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedRegistrarServiceRequestDelete is a Record type +type RejectedRegistrarServiceRequestDelete struct { +} + +// ToMap converts RejectedRegistrarServiceRequestDelete to a map for DAML arguments +func (t RejectedRegistrarServiceRequestDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedRegistrarServiceRequestDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedRegistrarServiceRequestDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedRegistrarServiceRequestDelete to hex string (Canton MCMS format) +func (t RejectedRegistrarServiceRequestDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedRegistrarServiceRequestDelete from hex string (Canton MCMS format) +func (t *RejectedRegistrarServiceRequestDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedRegistrarServiceRequestDeleteResult is a Record type +type RejectedRegistrarServiceRequestDeleteResult struct { +} + +// ToMap converts RejectedRegistrarServiceRequestDeleteResult to a map for DAML arguments +func (t RejectedRegistrarServiceRequestDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedRegistrarServiceRequestDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedRegistrarServiceRequestDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedRegistrarServiceRequestDeleteResult to hex string (Canton MCMS format) +func (t RejectedRegistrarServiceRequestDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedRegistrarServiceRequestDeleteResult from hex string (Canton MCMS format) +func (t *RejectedRegistrarServiceRequestDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOffer is a Template type +type TransferOffer struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Transfer splice_api_token_transfer_instruction_v1.Transfer `json:"transfer"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t TransferOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t TransferOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t TransferOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t TransferOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t TransferOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOffer to hex string (Canton MCMS format) +func (t TransferOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOffer from hex string (Canton MCMS format) +func (t *TransferOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for TransferOffer + +// Archive exercises the Archive choice on this TransferOffer contract via the ITransferInstruction interface +// This method uses the package name in the template ID +func (t TransferOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t TransferOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferInstructionAccept exercises the TransferInstruction_Accept choice on this TransferOffer contract via the ITransferInstruction interface +// This method uses the package name in the template ID +func (t TransferOffer) TransferInstructionAccept(contractID string, args splice_api_token_transfer_instruction_v1.TransferInstructionAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Accept", + Arguments: argsToMap(args), + } +} + +// TransferInstructionAcceptWithPackageID exercises the TransferInstruction_Accept choice using the provided package ID instead of package name +func (t TransferOffer) TransferInstructionAcceptWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferInstructionAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Accept", + Arguments: argsToMap(args), + } +} + +// TransferInstructionReject exercises the TransferInstruction_Reject choice on this TransferOffer contract via the ITransferInstruction interface +// This method uses the package name in the template ID +func (t TransferOffer) TransferInstructionReject(contractID string, args splice_api_token_transfer_instruction_v1.TransferInstructionReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Reject", + Arguments: argsToMap(args), + } +} + +// TransferInstructionRejectWithPackageID exercises the TransferInstruction_Reject choice using the provided package ID instead of package name +func (t TransferOffer) TransferInstructionRejectWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferInstructionReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Reject", + Arguments: argsToMap(args), + } +} + +// TransferInstructionWithdraw exercises the TransferInstruction_Withdraw choice on this TransferOffer contract via the ITransferInstruction interface +// This method uses the package name in the template ID +func (t TransferOffer) TransferInstructionWithdraw(contractID string, args splice_api_token_transfer_instruction_v1.TransferInstructionWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Withdraw", + Arguments: argsToMap(args), + } +} + +// TransferInstructionWithdrawWithPackageID exercises the TransferInstruction_Withdraw choice using the provided package ID instead of package name +func (t TransferOffer) TransferInstructionWithdrawWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferInstructionWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Withdraw", + Arguments: argsToMap(args), + } +} + +// TransferInstructionUpdate exercises the TransferInstruction_Update choice on this TransferOffer contract via the ITransferInstruction interface +// This method uses the package name in the template ID +func (t TransferOffer) TransferInstructionUpdate(contractID string, args splice_api_token_transfer_instruction_v1.TransferInstructionUpdate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Update", + Arguments: argsToMap(args), + } +} + +// TransferInstructionUpdateWithPackageID exercises the TransferInstruction_Update choice using the provided package ID instead of package name +func (t TransferOffer) TransferInstructionUpdateWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferInstructionUpdate) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.Transfer", "TransferInstruction"), + ContractID: contractID, + Choice: "TransferInstruction_Update", + Arguments: argsToMap(args), + } +} + +// Verify interface implementations for TransferOffer + +var _ splice_api_token_transfer_instruction_v1.ITransferInstruction = (*TransferOffer)(nil) + +// TransferPreapproval is a Template type +type TransferPreapproval struct { + Operator types.PARTY `json:"operator"` + Receiver types.PARTY `json:"receiver"` + InstrumentAdmin types.PARTY `json:"instrumentAdmin"` + InstrumentAllowances []InstrumentAllowance `json:"instrumentAllowances"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t TransferPreapproval) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t TransferPreapproval) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t TransferPreapproval) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiver"] = t.Receiver.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrumentAdmin"] = t.InstrumentAdmin.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrumentAllowances"] = func() []any { + res := make([]any, 0, len(t.InstrumentAllowances)) + for _, e := range t.InstrumentAllowances { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t TransferPreapproval) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiver"] = t.Receiver.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrumentAdmin"] = t.InstrumentAdmin.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrumentAllowances"] = func() []any { + res := make([]any, 0, len(t.InstrumentAllowances)) + for _, e := range t.InstrumentAllowances { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t TransferPreapproval) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferPreapproval) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferPreapproval to hex string (Canton MCMS format) +func (t TransferPreapproval) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferPreapproval from hex string (Canton MCMS format) +func (t *TransferPreapproval) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for TransferPreapproval + +// TransferPreapprovalWithdraw exercises the TransferPreapproval_Withdraw choice on this TransferPreapproval contract +// This method uses the package name in the template ID +func (t TransferPreapproval) TransferPreapprovalWithdraw(contractID string, args TransferPreapprovalWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval"), + ContractID: contractID, + Choice: "TransferPreapproval_Withdraw", + Arguments: argsToMap(args), + } +} + +// TransferPreapprovalWithdrawWithPackageID exercises the TransferPreapproval_Withdraw choice using the provided package ID instead of package name +func (t TransferPreapproval) TransferPreapprovalWithdrawWithPackageID(contractID string, packageID string, args TransferPreapprovalWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval"), + ContractID: contractID, + Choice: "TransferPreapproval_Withdraw", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this TransferPreapproval contract via the ITransferFactory interface +// This method uses the package name in the template ID +func (t TransferPreapproval) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t TransferPreapproval) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferPreapprovalModify exercises the TransferPreapproval_Modify choice on this TransferPreapproval contract +// This method uses the package name in the template ID +func (t TransferPreapproval) TransferPreapprovalModify(contractID string, args TransferPreapprovalModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval"), + ContractID: contractID, + Choice: "TransferPreapproval_Modify", + Arguments: argsToMap(args), + } +} + +// TransferPreapprovalModifyWithPackageID exercises the TransferPreapproval_Modify choice using the provided package ID instead of package name +func (t TransferPreapproval) TransferPreapprovalModifyWithPackageID(contractID string, packageID string, args TransferPreapprovalModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferPreapproval"), + ContractID: contractID, + Choice: "TransferPreapproval_Modify", + Arguments: argsToMap(args), + } +} + +// TransferFactoryTransfer exercises the TransferFactory_Transfer choice on this TransferPreapproval contract via the ITransferFactory interface +// This method uses the package name in the template ID +func (t TransferPreapproval) TransferFactoryTransfer(contractID string, args splice_api_token_transfer_instruction_v1.TransferFactoryTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferFactoryTransferWithPackageID exercises the TransferFactory_Transfer choice using the provided package ID instead of package name +func (t TransferPreapproval) TransferFactoryTransferWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferFactoryTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferFactoryPublicFetch exercises the TransferFactory_PublicFetch choice on this TransferPreapproval contract via the ITransferFactory interface +// This method uses the package name in the template ID +func (t TransferPreapproval) TransferFactoryPublicFetch(contractID string, args splice_api_token_transfer_instruction_v1.TransferFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// TransferFactoryPublicFetchWithPackageID exercises the TransferFactory_PublicFetch choice using the provided package ID instead of package name +func (t TransferPreapproval) TransferFactoryPublicFetchWithPackageID(contractID string, packageID string, args splice_api_token_transfer_instruction_v1.TransferFactoryPublicFetch) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.App.V0.Model.TransferPreapproval", "TransferFactory"), + ContractID: contractID, + Choice: "TransferFactory_PublicFetch", + Arguments: argsToMap(args), + } +} + +// Verify interface implementations for TransferPreapproval + +var _ splice_api_token_transfer_instruction_v1.ITransferFactory = (*TransferPreapproval)(nil) + +// TransferPreapprovalModify is a Record type +type TransferPreapprovalModify struct { + NewInstrumentAllowances []InstrumentAllowance `json:"newInstrumentAllowances"` +} + +// ToMap converts TransferPreapprovalModify to a map for DAML arguments +func (t TransferPreapprovalModify) ToMap() map[string]any { + m := make(map[string]any) + + m["newInstrumentAllowances"] = func() []any { + res := make([]any, 0, len(t.NewInstrumentAllowances)) + for _, e := range t.NewInstrumentAllowances { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + return m +} + +func (t TransferPreapprovalModify) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferPreapprovalModify) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferPreapprovalModify to hex string (Canton MCMS format) +func (t TransferPreapprovalModify) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferPreapprovalModify from hex string (Canton MCMS format) +func (t *TransferPreapprovalModify) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferPreapprovalModifyResult is a Record type +type TransferPreapprovalModifyResult struct { + TransferPreapprovalCid types.CONTRACT_ID `json:"transferPreapprovalCid"` +} + +// ToMap converts TransferPreapprovalModifyResult to a map for DAML arguments +func (t TransferPreapprovalModifyResult) ToMap() map[string]any { + m := make(map[string]any) + + m["transferPreapprovalCid"] = model.NestedToDAMLValue(t.TransferPreapprovalCid) + + return m +} + +func (t TransferPreapprovalModifyResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferPreapprovalModifyResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferPreapprovalModifyResult to hex string (Canton MCMS format) +func (t TransferPreapprovalModifyResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferPreapprovalModifyResult from hex string (Canton MCMS format) +func (t *TransferPreapprovalModifyResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferPreapprovalWithdraw is a Record type +type TransferPreapprovalWithdraw struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts TransferPreapprovalWithdraw to a map for DAML arguments +func (t TransferPreapprovalWithdraw) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t TransferPreapprovalWithdraw) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferPreapprovalWithdraw) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferPreapprovalWithdraw to hex string (Canton MCMS format) +func (t TransferPreapprovalWithdraw) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferPreapprovalWithdraw from hex string (Canton MCMS format) +func (t *TransferPreapprovalWithdraw) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferPreapprovalWithdrawResult is a Record type +type TransferPreapprovalWithdrawResult struct { +} + +// ToMap converts TransferPreapprovalWithdrawResult to a map for DAML arguments +func (t TransferPreapprovalWithdrawResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t TransferPreapprovalWithdrawResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferPreapprovalWithdrawResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferPreapprovalWithdrawResult to hex string (Canton MCMS format) +func (t TransferPreapprovalWithdrawResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferPreapprovalWithdrawResult from hex string (Canton MCMS format) +func (t *TransferPreapprovalWithdrawResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { + AllocationFactoryAllocateInternal(args AllocationFactoryAllocateInternal) (*bind.EncodedChoice, error) + AllocationFactoryInternalBurnMint(args AllocationFactoryInternalBurnMint) (*bind.EncodedChoice, error) + AllocationFactoryOfferBurn(args AllocationFactoryOfferBurn) (*bind.EncodedChoice, error) + AllocationFactoryOfferMint(args AllocationFactoryOfferMint) (*bind.EncodedChoice, error) + AllocationFactoryRequestBurn(args AllocationFactoryRequestBurn) (*bind.EncodedChoice, error) + AllocationFactoryRequestMint(args AllocationFactoryRequestMint) (*bind.EncodedChoice, error) + AllocationFactoryTransferInternal(args AllocationFactoryTransferInternal) (*bind.EncodedChoice, error) + BurnOfferAccept(args BurnOfferAccept) (*bind.EncodedChoice, error) + BurnOfferCancel(args BurnOfferCancel) (*bind.EncodedChoice, error) + BurnOfferReject(args BurnOfferReject) (*bind.EncodedChoice, error) + BurnRequestAccept(args BurnRequestAccept) (*bind.EncodedChoice, error) + BurnRequestCancel(args BurnRequestCancel) (*bind.EncodedChoice, error) + BurnRequestReject(args BurnRequestReject) (*bind.EncodedChoice, error) + EnforcementServiceRequestAccept(args EnforcementServiceRequestAccept) (*bind.EncodedChoice, error) + EnforcementServiceRequestCancel(args EnforcementServiceRequestCancel) (*bind.EncodedChoice, error) + EnforcementServiceRequestReject(args EnforcementServiceRequestReject) (*bind.EncodedChoice, error) + EnforcementServiceAcceptForceTransferRequest(args EnforcementServiceAcceptForceTransferRequest) (*bind.EncodedChoice, error) + EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization(args EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) (*bind.EncodedChoice, error) + EnforcementServiceTerminate(args EnforcementServiceTerminate) (*bind.EncodedChoice, error) + ExecutedBurnDelete(args ExecutedBurnDelete) (*bind.EncodedChoice, error) + ExecutedMintDelete(args ExecutedMintDelete) (*bind.EncodedChoice, error) + HolderServiceRequestAccept(args HolderServiceRequestAccept) (*bind.EncodedChoice, error) + HolderServiceRequestCancel(args HolderServiceRequestCancel) (*bind.EncodedChoice, error) + HolderServiceRequestClean(args HolderServiceRequestClean) (*bind.EncodedChoice, error) + HolderServiceRequestReject(args HolderServiceRequestReject) (*bind.EncodedChoice, error) + HolderServiceAcceptBurnOffer(args HolderServiceAcceptBurnOffer) (*bind.EncodedChoice, error) + HolderServiceAcceptLockOffer(args HolderServiceAcceptLockOffer) (*bind.EncodedChoice, error) + HolderServiceAcceptLockRequest(args HolderServiceAcceptLockRequest) (*bind.EncodedChoice, error) + HolderServiceAcceptMintOffer(args HolderServiceAcceptMintOffer) (*bind.EncodedChoice, error) + HolderServiceAcceptTransferOffer(args HolderServiceAcceptTransferOffer) (*bind.EncodedChoice, error) + HolderServiceAcceptTransferRequest(args HolderServiceAcceptTransferRequest) (*bind.EncodedChoice, error) + HolderServiceAcceptUnlockOffer(args HolderServiceAcceptUnlockOffer) (*bind.EncodedChoice, error) + HolderServiceAcceptUnlockRequest(args HolderServiceAcceptUnlockRequest) (*bind.EncodedChoice, error) + HolderServiceCancelBurnRequest(args HolderServiceCancelBurnRequest) (*bind.EncodedChoice, error) + HolderServiceCancelEnforcementServiceRequest(args HolderServiceCancelEnforcementServiceRequest) (*bind.EncodedChoice, error) + HolderServiceCancelForceTransferRequest(args HolderServiceCancelForceTransferRequest) (*bind.EncodedChoice, error) + HolderServiceCancelLockOffer(args HolderServiceCancelLockOffer) (*bind.EncodedChoice, error) + HolderServiceCancelLockRequest(args HolderServiceCancelLockRequest) (*bind.EncodedChoice, error) + HolderServiceCancelMintRequest(args HolderServiceCancelMintRequest) (*bind.EncodedChoice, error) + HolderServiceCancelTransferOffer(args HolderServiceCancelTransferOffer) (*bind.EncodedChoice, error) + HolderServiceCancelTransferRequest(args HolderServiceCancelTransferRequest) (*bind.EncodedChoice, error) + HolderServiceCancelUnlockOffer(args HolderServiceCancelUnlockOffer) (*bind.EncodedChoice, error) + HolderServiceCancelUnlockRequest(args HolderServiceCancelUnlockRequest) (*bind.EncodedChoice, error) + HolderServiceClean(args HolderServiceClean) (*bind.EncodedChoice, error) + HolderServiceCreateAllocation(args HolderServiceCreateAllocation) (*bind.EncodedChoice, error) + HolderServiceOfferLock(args HolderServiceOfferLock) (*bind.EncodedChoice, error) + HolderServiceOfferTransfer(args HolderServiceOfferTransfer) (*bind.EncodedChoice, error) + HolderServiceOfferUnlock(args HolderServiceOfferUnlock) (*bind.EncodedChoice, error) + HolderServiceRejectAllocationRequest(args HolderServiceRejectAllocationRequest) (*bind.EncodedChoice, error) + HolderServiceRejectBurnOffer(args HolderServiceRejectBurnOffer) (*bind.EncodedChoice, error) + HolderServiceRejectLockOffer(args HolderServiceRejectLockOffer) (*bind.EncodedChoice, error) + HolderServiceRejectLockRequest(args HolderServiceRejectLockRequest) (*bind.EncodedChoice, error) + HolderServiceRejectMintOffer(args HolderServiceRejectMintOffer) (*bind.EncodedChoice, error) + HolderServiceRejectTransferOffer(args HolderServiceRejectTransferOffer) (*bind.EncodedChoice, error) + HolderServiceRejectTransferRequest(args HolderServiceRejectTransferRequest) (*bind.EncodedChoice, error) + HolderServiceRejectUnlockOffer(args HolderServiceRejectUnlockOffer) (*bind.EncodedChoice, error) + HolderServiceRejectUnlockRequest(args HolderServiceRejectUnlockRequest) (*bind.EncodedChoice, error) + HolderServiceRequestBurn(args HolderServiceRequestBurn) (*bind.EncodedChoice, error) + HolderServiceRequestEnforcementService(args HolderServiceRequestEnforcementService) (*bind.EncodedChoice, error) + HolderServiceRequestForceTransfer(args HolderServiceRequestForceTransfer) (*bind.EncodedChoice, error) + HolderServiceRequestLock(args HolderServiceRequestLock) (*bind.EncodedChoice, error) + HolderServiceRequestMint(args HolderServiceRequestMint) (*bind.EncodedChoice, error) + HolderServiceRequestTransfer(args HolderServiceRequestTransfer) (*bind.EncodedChoice, error) + HolderServiceRequestUnlock(args HolderServiceRequestUnlock) (*bind.EncodedChoice, error) + HolderServiceTerminate(args HolderServiceTerminate) (*bind.EncodedChoice, error) + MintOfferAccept(args MintOfferAccept) (*bind.EncodedChoice, error) + MintOfferCancel(args MintOfferCancel) (*bind.EncodedChoice, error) + MintOfferReject(args MintOfferReject) (*bind.EncodedChoice, error) + MintRequestAccept(args MintRequestAccept) (*bind.EncodedChoice, error) + MintRequestCancel(args MintRequestCancel) (*bind.EncodedChoice, error) + MintRequestReject(args MintRequestReject) (*bind.EncodedChoice, error) + OperatorConfigurationGet(args OperatorConfigurationGet) (*bind.EncodedChoice, error) + OperatorConfigurationModify(args OperatorConfigurationModify) (*bind.EncodedChoice, error) + ProviderConfigurationGet(args ProviderConfigurationGet) (*bind.EncodedChoice, error) + ProviderServiceRequestAccept(args ProviderServiceRequestAccept) (*bind.EncodedChoice, error) + ProviderServiceRequestCancel(args ProviderServiceRequestCancel) (*bind.EncodedChoice, error) + ProviderServiceRequestReject(args ProviderServiceRequestReject) (*bind.EncodedChoice, error) + ProviderServiceAcceptHolderServiceRequest(args ProviderServiceAcceptHolderServiceRequest) (*bind.EncodedChoice, error) + ProviderServiceAcceptRegistrarServiceRequest(args ProviderServiceAcceptRegistrarServiceRequest) (*bind.EncodedChoice, error) + ProviderServiceArchiveAndCreateProviderConfiguration(args ProviderServiceArchiveAndCreateProviderConfiguration) (*bind.EncodedChoice, error) + ProviderServiceArchiveProviderConfiguration(args ProviderServiceArchiveProviderConfiguration) (*bind.EncodedChoice, error) + ProviderServiceCreateProviderConfiguration(args ProviderServiceCreateProviderConfiguration) (*bind.EncodedChoice, error) + ProviderServiceRejectHolderServiceRequest(args ProviderServiceRejectHolderServiceRequest) (*bind.EncodedChoice, error) + ProviderServiceRejectRegistrarServiceRequest(args ProviderServiceRejectRegistrarServiceRequest) (*bind.EncodedChoice, error) + ProviderServiceTerminate(args ProviderServiceTerminate) (*bind.EncodedChoice, error) + RegistrarConfigurationGet(args RegistrarConfigurationGet) (*bind.EncodedChoice, error) + RegistrarServiceRequestAccept(args RegistrarServiceRequestAccept) (*bind.EncodedChoice, error) + RegistrarServiceRequestCancel(args RegistrarServiceRequestCancel) (*bind.EncodedChoice, error) + RegistrarServiceRequestReject(args RegistrarServiceRequestReject) (*bind.EncodedChoice, error) + RegistrarServiceAcceptBurnRequest(args RegistrarServiceAcceptBurnRequest) (*bind.EncodedChoice, error) + RegistrarServiceAcceptEnforcementServiceRequest(args RegistrarServiceAcceptEnforcementServiceRequest) (*bind.EncodedChoice, error) + RegistrarServiceAcceptForceTransferRequest(args RegistrarServiceAcceptForceTransferRequest) (*bind.EncodedChoice, error) + RegistrarServiceAcceptMintRequest(args RegistrarServiceAcceptMintRequest) (*bind.EncodedChoice, error) + RegistrarServiceArchiveAllocationFactory(args RegistrarServiceArchiveAllocationFactory) (*bind.EncodedChoice, error) + RegistrarServiceArchiveAndCreateInstrumentConfiguration(args RegistrarServiceArchiveAndCreateInstrumentConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceArchiveAndCreateRegistrarConfiguration(args RegistrarServiceArchiveAndCreateRegistrarConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceArchiveInstrumentConfiguration(args RegistrarServiceArchiveInstrumentConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceArchiveRegistrarConfiguration(args RegistrarServiceArchiveRegistrarConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceArchiveTransferRule(args RegistrarServiceArchiveTransferRule) (*bind.EncodedChoice, error) + RegistrarServiceCancelBurnOffer(args RegistrarServiceCancelBurnOffer) (*bind.EncodedChoice, error) + RegistrarServiceCancelMintOffer(args RegistrarServiceCancelMintOffer) (*bind.EncodedChoice, error) + RegistrarServiceCreateAllocationFactory(args RegistrarServiceCreateAllocationFactory) (*bind.EncodedChoice, error) + RegistrarServiceCreateInstrumentConfiguration(args RegistrarServiceCreateInstrumentConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceCreateRegistrarConfiguration(args RegistrarServiceCreateRegistrarConfiguration) (*bind.EncodedChoice, error) + RegistrarServiceCreateTransferRule(args RegistrarServiceCreateTransferRule) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedBurn(args RegistrarServiceDeleteExecutedBurn) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedLock(args RegistrarServiceDeleteExecutedLock) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedMint(args RegistrarServiceDeleteExecutedMint) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedTransfer(args RegistrarServiceDeleteExecutedTransfer) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedTransfers(args RegistrarServiceDeleteExecutedTransfers) (*bind.EncodedChoice, error) + RegistrarServiceDeleteExecutedUnlock(args RegistrarServiceDeleteExecutedUnlock) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedBurn(args RegistrarServiceDeleteFailedBurn) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedLock(args RegistrarServiceDeleteFailedLock) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedMint(args RegistrarServiceDeleteFailedMint) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedTransfer(args RegistrarServiceDeleteFailedTransfer) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedTransfers(args RegistrarServiceDeleteFailedTransfers) (*bind.EncodedChoice, error) + RegistrarServiceDeleteFailedUnlock(args RegistrarServiceDeleteFailedUnlock) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedBurn(args RegistrarServiceDeleteRejectedBurn) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedLock(args RegistrarServiceDeleteRejectedLock) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedMint(args RegistrarServiceDeleteRejectedMint) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedTransfer(args RegistrarServiceDeleteRejectedTransfer) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedTransfers(args RegistrarServiceDeleteRejectedTransfers) (*bind.EncodedChoice, error) + RegistrarServiceDeleteRejectedUnlock(args RegistrarServiceDeleteRejectedUnlock) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedBurn(args RegistrarServiceExecuteAcceptedBurn) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedForceTransfer(args RegistrarServiceExecuteAcceptedForceTransfer) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedLock(args RegistrarServiceExecuteAcceptedLock) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedMint(args RegistrarServiceExecuteAcceptedMint) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedTransfer(args RegistrarServiceExecuteAcceptedTransfer) (*bind.EncodedChoice, error) + RegistrarServiceExecuteAcceptedUnlock(args RegistrarServiceExecuteAcceptedUnlock) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedBurn(args RegistrarServiceFailAcceptedBurn) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedForceTransfer(args RegistrarServiceFailAcceptedForceTransfer) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedLock(args RegistrarServiceFailAcceptedLock) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedMint(args RegistrarServiceFailAcceptedMint) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedTransfer(args RegistrarServiceFailAcceptedTransfer) (*bind.EncodedChoice, error) + RegistrarServiceFailAcceptedUnlock(args RegistrarServiceFailAcceptedUnlock) (*bind.EncodedChoice, error) + RegistrarServiceMergeHolding(args RegistrarServiceMergeHolding) (*bind.EncodedChoice, error) + RegistrarServiceOfferBurn(args RegistrarServiceOfferBurn) (*bind.EncodedChoice, error) + RegistrarServiceOfferMint(args RegistrarServiceOfferMint) (*bind.EncodedChoice, error) + RegistrarServiceRejectBurnRequest(args RegistrarServiceRejectBurnRequest) (*bind.EncodedChoice, error) + RegistrarServiceRejectEnforcementServiceRequest(args RegistrarServiceRejectEnforcementServiceRequest) (*bind.EncodedChoice, error) + RegistrarServiceRejectForceTransferRequest(args RegistrarServiceRejectForceTransferRequest) (*bind.EncodedChoice, error) + RegistrarServiceRejectMintRequest(args RegistrarServiceRejectMintRequest) (*bind.EncodedChoice, error) + RegistrarServiceSet(args RegistrarServiceSet) (*bind.EncodedChoice, error) + RegistrarServiceSplitHolding(args RegistrarServiceSplitHolding) (*bind.EncodedChoice, error) + RegistrarServiceTerminate(args RegistrarServiceTerminate) (*bind.EncodedChoice, error) + RegistrarServiceTerminateEnforcementService(args RegistrarServiceTerminateEnforcementService) (*bind.EncodedChoice, error) + RejectedBurnDelete(args RejectedBurnDelete) (*bind.EncodedChoice, error) + RejectedEnforcementServiceRequestDelete(args RejectedEnforcementServiceRequestDelete) (*bind.EncodedChoice, error) + RejectedHolderServiceRequestClean(args RejectedHolderServiceRequestClean) (*bind.EncodedChoice, error) + RejectedHolderServiceRequestDelete(args RejectedHolderServiceRequestDelete) (*bind.EncodedChoice, error) + RejectedMintDelete(args RejectedMintDelete) (*bind.EncodedChoice, error) + RejectedProviderServiceRequestDelete(args RejectedProviderServiceRequestDelete) (*bind.EncodedChoice, error) + RejectedRegistrarServiceRequestDelete(args RejectedRegistrarServiceRequestDelete) (*bind.EncodedChoice, error) + TransferPreapprovalModify(args TransferPreapprovalModify) (*bind.EncodedChoice, error) + TransferPreapprovalWithdraw(args TransferPreapprovalWithdraw) (*bind.EncodedChoice, error) +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// AllocationFactoryAllocateInternal encodes parameters for the AllocationFactory_AllocateInternal choice. +func (e *encoder) AllocationFactoryAllocateInternal(args AllocationFactoryAllocateInternal) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_AllocateInternal", args) +} + +// AllocationFactoryInternalBurnMint encodes parameters for the AllocationFactory_InternalBurnMint choice. +func (e *encoder) AllocationFactoryInternalBurnMint(args AllocationFactoryInternalBurnMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_InternalBurnMint", args) +} + +// AllocationFactoryOfferBurn encodes parameters for the AllocationFactory_OfferBurn choice. +func (e *encoder) AllocationFactoryOfferBurn(args AllocationFactoryOfferBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_OfferBurn", args) +} + +// AllocationFactoryOfferMint encodes parameters for the AllocationFactory_OfferMint choice. +func (e *encoder) AllocationFactoryOfferMint(args AllocationFactoryOfferMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_OfferMint", args) +} + +// AllocationFactoryRequestBurn encodes parameters for the AllocationFactory_RequestBurn choice. +func (e *encoder) AllocationFactoryRequestBurn(args AllocationFactoryRequestBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_RequestBurn", args) +} + +// AllocationFactoryRequestMint encodes parameters for the AllocationFactory_RequestMint choice. +func (e *encoder) AllocationFactoryRequestMint(args AllocationFactoryRequestMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_RequestMint", args) +} + +// AllocationFactoryTransferInternal encodes parameters for the AllocationFactory_TransferInternal choice. +func (e *encoder) AllocationFactoryTransferInternal(args AllocationFactoryTransferInternal) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AllocationFactory_TransferInternal", args) +} + +// BurnOfferAccept encodes parameters for the BurnOffer_Accept choice. +func (e *encoder) BurnOfferAccept(args BurnOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Accept", args) +} + +// BurnOfferCancel encodes parameters for the BurnOffer_Cancel choice. +func (e *encoder) BurnOfferCancel(args BurnOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Cancel", args) +} + +// BurnOfferReject encodes parameters for the BurnOffer_Reject choice. +func (e *encoder) BurnOfferReject(args BurnOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Reject", args) +} + +// BurnRequestAccept encodes parameters for the BurnRequest_Accept choice. +func (e *encoder) BurnRequestAccept(args BurnRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Accept", args) +} + +// BurnRequestCancel encodes parameters for the BurnRequest_Cancel choice. +func (e *encoder) BurnRequestCancel(args BurnRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Cancel", args) +} + +// BurnRequestReject encodes parameters for the BurnRequest_Reject choice. +func (e *encoder) BurnRequestReject(args BurnRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Reject", args) +} + +// EnforcementServiceRequestAccept encodes parameters for the EnforcementServiceRequest_Accept choice. +func (e *encoder) EnforcementServiceRequestAccept(args EnforcementServiceRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementServiceRequest_Accept", args) +} + +// EnforcementServiceRequestCancel encodes parameters for the EnforcementServiceRequest_Cancel choice. +func (e *encoder) EnforcementServiceRequestCancel(args EnforcementServiceRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementServiceRequest_Cancel", args) +} + +// EnforcementServiceRequestReject encodes parameters for the EnforcementServiceRequest_Reject choice. +func (e *encoder) EnforcementServiceRequestReject(args EnforcementServiceRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementServiceRequest_Reject", args) +} + +// EnforcementServiceAcceptForceTransferRequest encodes parameters for the EnforcementService_AcceptForceTransferRequest choice. +func (e *encoder) EnforcementServiceAcceptForceTransferRequest(args EnforcementServiceAcceptForceTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementService_AcceptForceTransferRequest", args) +} + +// EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization encodes parameters for the EnforcementService_AcceptForceTransferRequestWithSenderAuthorization choice. +func (e *encoder) EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization(args EnforcementServiceAcceptForceTransferRequestWithSenderAuthorization) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementService_AcceptForceTransferRequestWithSenderAuthorization", args) +} + +// EnforcementServiceTerminate encodes parameters for the EnforcementService_Terminate choice. +func (e *encoder) EnforcementServiceTerminate(args EnforcementServiceTerminate) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("EnforcementService_Terminate", args) +} + +// ExecutedBurnDelete encodes parameters for the ExecutedBurn_Delete choice. +func (e *encoder) ExecutedBurnDelete(args ExecutedBurnDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedBurn_Delete", args) +} + +// ExecutedMintDelete encodes parameters for the ExecutedMint_Delete choice. +func (e *encoder) ExecutedMintDelete(args ExecutedMintDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedMint_Delete", args) +} + +// HolderServiceRequestAccept encodes parameters for the HolderServiceRequest_Accept choice. +func (e *encoder) HolderServiceRequestAccept(args HolderServiceRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderServiceRequest_Accept", args) +} + +// HolderServiceRequestCancel encodes parameters for the HolderServiceRequest_Cancel choice. +func (e *encoder) HolderServiceRequestCancel(args HolderServiceRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderServiceRequest_Cancel", args) +} + +// HolderServiceRequestClean encodes parameters for the HolderServiceRequest_Clean choice. +func (e *encoder) HolderServiceRequestClean(args HolderServiceRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderServiceRequest_Clean", args) +} + +// HolderServiceRequestReject encodes parameters for the HolderServiceRequest_Reject choice. +func (e *encoder) HolderServiceRequestReject(args HolderServiceRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderServiceRequest_Reject", args) +} + +// HolderServiceAcceptBurnOffer encodes parameters for the HolderService_AcceptBurnOffer choice. +func (e *encoder) HolderServiceAcceptBurnOffer(args HolderServiceAcceptBurnOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptBurnOffer", args) +} + +// HolderServiceAcceptLockOffer encodes parameters for the HolderService_AcceptLockOffer choice. +func (e *encoder) HolderServiceAcceptLockOffer(args HolderServiceAcceptLockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptLockOffer", args) +} + +// HolderServiceAcceptLockRequest encodes parameters for the HolderService_AcceptLockRequest choice. +func (e *encoder) HolderServiceAcceptLockRequest(args HolderServiceAcceptLockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptLockRequest", args) +} + +// HolderServiceAcceptMintOffer encodes parameters for the HolderService_AcceptMintOffer choice. +func (e *encoder) HolderServiceAcceptMintOffer(args HolderServiceAcceptMintOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptMintOffer", args) +} + +// HolderServiceAcceptTransferOffer encodes parameters for the HolderService_AcceptTransferOffer choice. +func (e *encoder) HolderServiceAcceptTransferOffer(args HolderServiceAcceptTransferOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptTransferOffer", args) +} + +// HolderServiceAcceptTransferRequest encodes parameters for the HolderService_AcceptTransferRequest choice. +func (e *encoder) HolderServiceAcceptTransferRequest(args HolderServiceAcceptTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptTransferRequest", args) +} + +// HolderServiceAcceptUnlockOffer encodes parameters for the HolderService_AcceptUnlockOffer choice. +func (e *encoder) HolderServiceAcceptUnlockOffer(args HolderServiceAcceptUnlockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptUnlockOffer", args) +} + +// HolderServiceAcceptUnlockRequest encodes parameters for the HolderService_AcceptUnlockRequest choice. +func (e *encoder) HolderServiceAcceptUnlockRequest(args HolderServiceAcceptUnlockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_AcceptUnlockRequest", args) +} + +// HolderServiceCancelBurnRequest encodes parameters for the HolderService_CancelBurnRequest choice. +func (e *encoder) HolderServiceCancelBurnRequest(args HolderServiceCancelBurnRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelBurnRequest", args) +} + +// HolderServiceCancelEnforcementServiceRequest encodes parameters for the HolderService_CancelEnforcementServiceRequest choice. +func (e *encoder) HolderServiceCancelEnforcementServiceRequest(args HolderServiceCancelEnforcementServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelEnforcementServiceRequest", args) +} + +// HolderServiceCancelForceTransferRequest encodes parameters for the HolderService_CancelForceTransferRequest choice. +func (e *encoder) HolderServiceCancelForceTransferRequest(args HolderServiceCancelForceTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelForceTransferRequest", args) +} + +// HolderServiceCancelLockOffer encodes parameters for the HolderService_CancelLockOffer choice. +func (e *encoder) HolderServiceCancelLockOffer(args HolderServiceCancelLockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelLockOffer", args) +} + +// HolderServiceCancelLockRequest encodes parameters for the HolderService_CancelLockRequest choice. +func (e *encoder) HolderServiceCancelLockRequest(args HolderServiceCancelLockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelLockRequest", args) +} + +// HolderServiceCancelMintRequest encodes parameters for the HolderService_CancelMintRequest choice. +func (e *encoder) HolderServiceCancelMintRequest(args HolderServiceCancelMintRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelMintRequest", args) +} + +// HolderServiceCancelTransferOffer encodes parameters for the HolderService_CancelTransferOffer choice. +func (e *encoder) HolderServiceCancelTransferOffer(args HolderServiceCancelTransferOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelTransferOffer", args) +} + +// HolderServiceCancelTransferRequest encodes parameters for the HolderService_CancelTransferRequest choice. +func (e *encoder) HolderServiceCancelTransferRequest(args HolderServiceCancelTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelTransferRequest", args) +} + +// HolderServiceCancelUnlockOffer encodes parameters for the HolderService_CancelUnlockOffer choice. +func (e *encoder) HolderServiceCancelUnlockOffer(args HolderServiceCancelUnlockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelUnlockOffer", args) +} + +// HolderServiceCancelUnlockRequest encodes parameters for the HolderService_CancelUnlockRequest choice. +func (e *encoder) HolderServiceCancelUnlockRequest(args HolderServiceCancelUnlockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CancelUnlockRequest", args) +} + +// HolderServiceClean encodes parameters for the HolderService_Clean choice. +func (e *encoder) HolderServiceClean(args HolderServiceClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_Clean", args) +} + +// HolderServiceCreateAllocation encodes parameters for the HolderService_CreateAllocation choice. +func (e *encoder) HolderServiceCreateAllocation(args HolderServiceCreateAllocation) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_CreateAllocation", args) +} + +// HolderServiceOfferLock encodes parameters for the HolderService_OfferLock choice. +func (e *encoder) HolderServiceOfferLock(args HolderServiceOfferLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_OfferLock", args) +} + +// HolderServiceOfferTransfer encodes parameters for the HolderService_OfferTransfer choice. +func (e *encoder) HolderServiceOfferTransfer(args HolderServiceOfferTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_OfferTransfer", args) +} + +// HolderServiceOfferUnlock encodes parameters for the HolderService_OfferUnlock choice. +func (e *encoder) HolderServiceOfferUnlock(args HolderServiceOfferUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_OfferUnlock", args) +} + +// HolderServiceRejectAllocationRequest encodes parameters for the HolderService_RejectAllocationRequest choice. +func (e *encoder) HolderServiceRejectAllocationRequest(args HolderServiceRejectAllocationRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectAllocationRequest", args) +} + +// HolderServiceRejectBurnOffer encodes parameters for the HolderService_RejectBurnOffer choice. +func (e *encoder) HolderServiceRejectBurnOffer(args HolderServiceRejectBurnOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectBurnOffer", args) +} + +// HolderServiceRejectLockOffer encodes parameters for the HolderService_RejectLockOffer choice. +func (e *encoder) HolderServiceRejectLockOffer(args HolderServiceRejectLockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectLockOffer", args) +} + +// HolderServiceRejectLockRequest encodes parameters for the HolderService_RejectLockRequest choice. +func (e *encoder) HolderServiceRejectLockRequest(args HolderServiceRejectLockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectLockRequest", args) +} + +// HolderServiceRejectMintOffer encodes parameters for the HolderService_RejectMintOffer choice. +func (e *encoder) HolderServiceRejectMintOffer(args HolderServiceRejectMintOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectMintOffer", args) +} + +// HolderServiceRejectTransferOffer encodes parameters for the HolderService_RejectTransferOffer choice. +func (e *encoder) HolderServiceRejectTransferOffer(args HolderServiceRejectTransferOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectTransferOffer", args) +} + +// HolderServiceRejectTransferRequest encodes parameters for the HolderService_RejectTransferRequest choice. +func (e *encoder) HolderServiceRejectTransferRequest(args HolderServiceRejectTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectTransferRequest", args) +} + +// HolderServiceRejectUnlockOffer encodes parameters for the HolderService_RejectUnlockOffer choice. +func (e *encoder) HolderServiceRejectUnlockOffer(args HolderServiceRejectUnlockOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectUnlockOffer", args) +} + +// HolderServiceRejectUnlockRequest encodes parameters for the HolderService_RejectUnlockRequest choice. +func (e *encoder) HolderServiceRejectUnlockRequest(args HolderServiceRejectUnlockRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RejectUnlockRequest", args) +} + +// HolderServiceRequestBurn encodes parameters for the HolderService_RequestBurn choice. +func (e *encoder) HolderServiceRequestBurn(args HolderServiceRequestBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestBurn", args) +} + +// HolderServiceRequestEnforcementService encodes parameters for the HolderService_RequestEnforcementService choice. +func (e *encoder) HolderServiceRequestEnforcementService(args HolderServiceRequestEnforcementService) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestEnforcementService", args) +} + +// HolderServiceRequestForceTransfer encodes parameters for the HolderService_RequestForceTransfer choice. +func (e *encoder) HolderServiceRequestForceTransfer(args HolderServiceRequestForceTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestForceTransfer", args) +} + +// HolderServiceRequestLock encodes parameters for the HolderService_RequestLock choice. +func (e *encoder) HolderServiceRequestLock(args HolderServiceRequestLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestLock", args) +} + +// HolderServiceRequestMint encodes parameters for the HolderService_RequestMint choice. +func (e *encoder) HolderServiceRequestMint(args HolderServiceRequestMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestMint", args) +} + +// HolderServiceRequestTransfer encodes parameters for the HolderService_RequestTransfer choice. +func (e *encoder) HolderServiceRequestTransfer(args HolderServiceRequestTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestTransfer", args) +} + +// HolderServiceRequestUnlock encodes parameters for the HolderService_RequestUnlock choice. +func (e *encoder) HolderServiceRequestUnlock(args HolderServiceRequestUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_RequestUnlock", args) +} + +// HolderServiceTerminate encodes parameters for the HolderService_Terminate choice. +func (e *encoder) HolderServiceTerminate(args HolderServiceTerminate) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("HolderService_Terminate", args) +} + +// MintOfferAccept encodes parameters for the MintOffer_Accept choice. +func (e *encoder) MintOfferAccept(args MintOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Accept", args) +} + +// MintOfferCancel encodes parameters for the MintOffer_Cancel choice. +func (e *encoder) MintOfferCancel(args MintOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Cancel", args) +} + +// MintOfferReject encodes parameters for the MintOffer_Reject choice. +func (e *encoder) MintOfferReject(args MintOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Reject", args) +} + +// MintRequestAccept encodes parameters for the MintRequest_Accept choice. +func (e *encoder) MintRequestAccept(args MintRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Accept", args) +} + +// MintRequestCancel encodes parameters for the MintRequest_Cancel choice. +func (e *encoder) MintRequestCancel(args MintRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Cancel", args) +} + +// MintRequestReject encodes parameters for the MintRequest_Reject choice. +func (e *encoder) MintRequestReject(args MintRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Reject", args) +} + +// OperatorConfigurationGet encodes parameters for the OperatorConfiguration_Get choice. +func (e *encoder) OperatorConfigurationGet(args OperatorConfigurationGet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("OperatorConfiguration_Get", args) +} + +// OperatorConfigurationModify encodes parameters for the OperatorConfiguration_Modify choice. +func (e *encoder) OperatorConfigurationModify(args OperatorConfigurationModify) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("OperatorConfiguration_Modify", args) +} + +// ProviderConfigurationGet encodes parameters for the ProviderConfiguration_Get choice. +func (e *encoder) ProviderConfigurationGet(args ProviderConfigurationGet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderConfiguration_Get", args) +} + +// ProviderServiceRequestAccept encodes parameters for the ProviderServiceRequest_Accept choice. +func (e *encoder) ProviderServiceRequestAccept(args ProviderServiceRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderServiceRequest_Accept", args) +} + +// ProviderServiceRequestCancel encodes parameters for the ProviderServiceRequest_Cancel choice. +func (e *encoder) ProviderServiceRequestCancel(args ProviderServiceRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderServiceRequest_Cancel", args) +} + +// ProviderServiceRequestReject encodes parameters for the ProviderServiceRequest_Reject choice. +func (e *encoder) ProviderServiceRequestReject(args ProviderServiceRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderServiceRequest_Reject", args) +} + +// ProviderServiceAcceptHolderServiceRequest encodes parameters for the ProviderService_AcceptHolderServiceRequest choice. +func (e *encoder) ProviderServiceAcceptHolderServiceRequest(args ProviderServiceAcceptHolderServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_AcceptHolderServiceRequest", args) +} + +// ProviderServiceAcceptRegistrarServiceRequest encodes parameters for the ProviderService_AcceptRegistrarServiceRequest choice. +func (e *encoder) ProviderServiceAcceptRegistrarServiceRequest(args ProviderServiceAcceptRegistrarServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_AcceptRegistrarServiceRequest", args) +} + +// ProviderServiceArchiveAndCreateProviderConfiguration encodes parameters for the ProviderService_ArchiveAndCreateProviderConfiguration choice. +func (e *encoder) ProviderServiceArchiveAndCreateProviderConfiguration(args ProviderServiceArchiveAndCreateProviderConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_ArchiveAndCreateProviderConfiguration", args) +} + +// ProviderServiceArchiveProviderConfiguration encodes parameters for the ProviderService_ArchiveProviderConfiguration choice. +func (e *encoder) ProviderServiceArchiveProviderConfiguration(args ProviderServiceArchiveProviderConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_ArchiveProviderConfiguration", args) +} + +// ProviderServiceCreateProviderConfiguration encodes parameters for the ProviderService_CreateProviderConfiguration choice. +func (e *encoder) ProviderServiceCreateProviderConfiguration(args ProviderServiceCreateProviderConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_CreateProviderConfiguration", args) +} + +// ProviderServiceRejectHolderServiceRequest encodes parameters for the ProviderService_RejectHolderServiceRequest choice. +func (e *encoder) ProviderServiceRejectHolderServiceRequest(args ProviderServiceRejectHolderServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_RejectHolderServiceRequest", args) +} + +// ProviderServiceRejectRegistrarServiceRequest encodes parameters for the ProviderService_RejectRegistrarServiceRequest choice. +func (e *encoder) ProviderServiceRejectRegistrarServiceRequest(args ProviderServiceRejectRegistrarServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_RejectRegistrarServiceRequest", args) +} + +// ProviderServiceTerminate encodes parameters for the ProviderService_Terminate choice. +func (e *encoder) ProviderServiceTerminate(args ProviderServiceTerminate) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ProviderService_Terminate", args) +} + +// RegistrarConfigurationGet encodes parameters for the RegistrarConfiguration_Get choice. +func (e *encoder) RegistrarConfigurationGet(args RegistrarConfigurationGet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarConfiguration_Get", args) +} + +// RegistrarServiceRequestAccept encodes parameters for the RegistrarServiceRequest_Accept choice. +func (e *encoder) RegistrarServiceRequestAccept(args RegistrarServiceRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarServiceRequest_Accept", args) +} + +// RegistrarServiceRequestCancel encodes parameters for the RegistrarServiceRequest_Cancel choice. +func (e *encoder) RegistrarServiceRequestCancel(args RegistrarServiceRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarServiceRequest_Cancel", args) +} + +// RegistrarServiceRequestReject encodes parameters for the RegistrarServiceRequest_Reject choice. +func (e *encoder) RegistrarServiceRequestReject(args RegistrarServiceRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarServiceRequest_Reject", args) +} + +// RegistrarServiceAcceptBurnRequest encodes parameters for the RegistrarService_AcceptBurnRequest choice. +func (e *encoder) RegistrarServiceAcceptBurnRequest(args RegistrarServiceAcceptBurnRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_AcceptBurnRequest", args) +} + +// RegistrarServiceAcceptEnforcementServiceRequest encodes parameters for the RegistrarService_AcceptEnforcementServiceRequest choice. +func (e *encoder) RegistrarServiceAcceptEnforcementServiceRequest(args RegistrarServiceAcceptEnforcementServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_AcceptEnforcementServiceRequest", args) +} + +// RegistrarServiceAcceptForceTransferRequest encodes parameters for the RegistrarService_AcceptForceTransferRequest choice. +func (e *encoder) RegistrarServiceAcceptForceTransferRequest(args RegistrarServiceAcceptForceTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_AcceptForceTransferRequest", args) +} + +// RegistrarServiceAcceptMintRequest encodes parameters for the RegistrarService_AcceptMintRequest choice. +func (e *encoder) RegistrarServiceAcceptMintRequest(args RegistrarServiceAcceptMintRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_AcceptMintRequest", args) +} + +// RegistrarServiceArchiveAllocationFactory encodes parameters for the RegistrarService_ArchiveAllocationFactory choice. +func (e *encoder) RegistrarServiceArchiveAllocationFactory(args RegistrarServiceArchiveAllocationFactory) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveAllocationFactory", args) +} + +// RegistrarServiceArchiveAndCreateInstrumentConfiguration encodes parameters for the RegistrarService_ArchiveAndCreateInstrumentConfiguration choice. +func (e *encoder) RegistrarServiceArchiveAndCreateInstrumentConfiguration(args RegistrarServiceArchiveAndCreateInstrumentConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveAndCreateInstrumentConfiguration", args) +} + +// RegistrarServiceArchiveAndCreateRegistrarConfiguration encodes parameters for the RegistrarService_ArchiveAndCreateRegistrarConfiguration choice. +func (e *encoder) RegistrarServiceArchiveAndCreateRegistrarConfiguration(args RegistrarServiceArchiveAndCreateRegistrarConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveAndCreateRegistrarConfiguration", args) +} + +// RegistrarServiceArchiveInstrumentConfiguration encodes parameters for the RegistrarService_ArchiveInstrumentConfiguration choice. +func (e *encoder) RegistrarServiceArchiveInstrumentConfiguration(args RegistrarServiceArchiveInstrumentConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveInstrumentConfiguration", args) +} + +// RegistrarServiceArchiveRegistrarConfiguration encodes parameters for the RegistrarService_ArchiveRegistrarConfiguration choice. +func (e *encoder) RegistrarServiceArchiveRegistrarConfiguration(args RegistrarServiceArchiveRegistrarConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveRegistrarConfiguration", args) +} + +// RegistrarServiceArchiveTransferRule encodes parameters for the RegistrarService_ArchiveTransferRule choice. +func (e *encoder) RegistrarServiceArchiveTransferRule(args RegistrarServiceArchiveTransferRule) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ArchiveTransferRule", args) +} + +// RegistrarServiceCancelBurnOffer encodes parameters for the RegistrarService_CancelBurnOffer choice. +func (e *encoder) RegistrarServiceCancelBurnOffer(args RegistrarServiceCancelBurnOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CancelBurnOffer", args) +} + +// RegistrarServiceCancelMintOffer encodes parameters for the RegistrarService_CancelMintOffer choice. +func (e *encoder) RegistrarServiceCancelMintOffer(args RegistrarServiceCancelMintOffer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CancelMintOffer", args) +} + +// RegistrarServiceCreateAllocationFactory encodes parameters for the RegistrarService_CreateAllocationFactory choice. +func (e *encoder) RegistrarServiceCreateAllocationFactory(args RegistrarServiceCreateAllocationFactory) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CreateAllocationFactory", args) +} + +// RegistrarServiceCreateInstrumentConfiguration encodes parameters for the RegistrarService_CreateInstrumentConfiguration choice. +func (e *encoder) RegistrarServiceCreateInstrumentConfiguration(args RegistrarServiceCreateInstrumentConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CreateInstrumentConfiguration", args) +} + +// RegistrarServiceCreateRegistrarConfiguration encodes parameters for the RegistrarService_CreateRegistrarConfiguration choice. +func (e *encoder) RegistrarServiceCreateRegistrarConfiguration(args RegistrarServiceCreateRegistrarConfiguration) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CreateRegistrarConfiguration", args) +} + +// RegistrarServiceCreateTransferRule encodes parameters for the RegistrarService_CreateTransferRule choice. +func (e *encoder) RegistrarServiceCreateTransferRule(args RegistrarServiceCreateTransferRule) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_CreateTransferRule", args) +} + +// RegistrarServiceDeleteExecutedBurn encodes parameters for the RegistrarService_DeleteExecutedBurn choice. +func (e *encoder) RegistrarServiceDeleteExecutedBurn(args RegistrarServiceDeleteExecutedBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedBurn", args) +} + +// RegistrarServiceDeleteExecutedLock encodes parameters for the RegistrarService_DeleteExecutedLock choice. +func (e *encoder) RegistrarServiceDeleteExecutedLock(args RegistrarServiceDeleteExecutedLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedLock", args) +} + +// RegistrarServiceDeleteExecutedMint encodes parameters for the RegistrarService_DeleteExecutedMint choice. +func (e *encoder) RegistrarServiceDeleteExecutedMint(args RegistrarServiceDeleteExecutedMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedMint", args) +} + +// RegistrarServiceDeleteExecutedTransfer encodes parameters for the RegistrarService_DeleteExecutedTransfer choice. +func (e *encoder) RegistrarServiceDeleteExecutedTransfer(args RegistrarServiceDeleteExecutedTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedTransfer", args) +} + +// RegistrarServiceDeleteExecutedTransfers encodes parameters for the RegistrarService_DeleteExecutedTransfers choice. +func (e *encoder) RegistrarServiceDeleteExecutedTransfers(args RegistrarServiceDeleteExecutedTransfers) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedTransfers", args) +} + +// RegistrarServiceDeleteExecutedUnlock encodes parameters for the RegistrarService_DeleteExecutedUnlock choice. +func (e *encoder) RegistrarServiceDeleteExecutedUnlock(args RegistrarServiceDeleteExecutedUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteExecutedUnlock", args) +} + +// RegistrarServiceDeleteFailedBurn encodes parameters for the RegistrarService_DeleteFailedBurn choice. +func (e *encoder) RegistrarServiceDeleteFailedBurn(args RegistrarServiceDeleteFailedBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedBurn", args) +} + +// RegistrarServiceDeleteFailedLock encodes parameters for the RegistrarService_DeleteFailedLock choice. +func (e *encoder) RegistrarServiceDeleteFailedLock(args RegistrarServiceDeleteFailedLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedLock", args) +} + +// RegistrarServiceDeleteFailedMint encodes parameters for the RegistrarService_DeleteFailedMint choice. +func (e *encoder) RegistrarServiceDeleteFailedMint(args RegistrarServiceDeleteFailedMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedMint", args) +} + +// RegistrarServiceDeleteFailedTransfer encodes parameters for the RegistrarService_DeleteFailedTransfer choice. +func (e *encoder) RegistrarServiceDeleteFailedTransfer(args RegistrarServiceDeleteFailedTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedTransfer", args) +} + +// RegistrarServiceDeleteFailedTransfers encodes parameters for the RegistrarService_DeleteFailedTransfers choice. +func (e *encoder) RegistrarServiceDeleteFailedTransfers(args RegistrarServiceDeleteFailedTransfers) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedTransfers", args) +} + +// RegistrarServiceDeleteFailedUnlock encodes parameters for the RegistrarService_DeleteFailedUnlock choice. +func (e *encoder) RegistrarServiceDeleteFailedUnlock(args RegistrarServiceDeleteFailedUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteFailedUnlock", args) +} + +// RegistrarServiceDeleteRejectedBurn encodes parameters for the RegistrarService_DeleteRejectedBurn choice. +func (e *encoder) RegistrarServiceDeleteRejectedBurn(args RegistrarServiceDeleteRejectedBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedBurn", args) +} + +// RegistrarServiceDeleteRejectedLock encodes parameters for the RegistrarService_DeleteRejectedLock choice. +func (e *encoder) RegistrarServiceDeleteRejectedLock(args RegistrarServiceDeleteRejectedLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedLock", args) +} + +// RegistrarServiceDeleteRejectedMint encodes parameters for the RegistrarService_DeleteRejectedMint choice. +func (e *encoder) RegistrarServiceDeleteRejectedMint(args RegistrarServiceDeleteRejectedMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedMint", args) +} + +// RegistrarServiceDeleteRejectedTransfer encodes parameters for the RegistrarService_DeleteRejectedTransfer choice. +func (e *encoder) RegistrarServiceDeleteRejectedTransfer(args RegistrarServiceDeleteRejectedTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedTransfer", args) +} + +// RegistrarServiceDeleteRejectedTransfers encodes parameters for the RegistrarService_DeleteRejectedTransfers choice. +func (e *encoder) RegistrarServiceDeleteRejectedTransfers(args RegistrarServiceDeleteRejectedTransfers) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedTransfers", args) +} + +// RegistrarServiceDeleteRejectedUnlock encodes parameters for the RegistrarService_DeleteRejectedUnlock choice. +func (e *encoder) RegistrarServiceDeleteRejectedUnlock(args RegistrarServiceDeleteRejectedUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_DeleteRejectedUnlock", args) +} + +// RegistrarServiceExecuteAcceptedBurn encodes parameters for the RegistrarService_ExecuteAcceptedBurn choice. +func (e *encoder) RegistrarServiceExecuteAcceptedBurn(args RegistrarServiceExecuteAcceptedBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedBurn", args) +} + +// RegistrarServiceExecuteAcceptedForceTransfer encodes parameters for the RegistrarService_ExecuteAcceptedForceTransfer choice. +func (e *encoder) RegistrarServiceExecuteAcceptedForceTransfer(args RegistrarServiceExecuteAcceptedForceTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedForceTransfer", args) +} + +// RegistrarServiceExecuteAcceptedLock encodes parameters for the RegistrarService_ExecuteAcceptedLock choice. +func (e *encoder) RegistrarServiceExecuteAcceptedLock(args RegistrarServiceExecuteAcceptedLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedLock", args) +} + +// RegistrarServiceExecuteAcceptedMint encodes parameters for the RegistrarService_ExecuteAcceptedMint choice. +func (e *encoder) RegistrarServiceExecuteAcceptedMint(args RegistrarServiceExecuteAcceptedMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedMint", args) +} + +// RegistrarServiceExecuteAcceptedTransfer encodes parameters for the RegistrarService_ExecuteAcceptedTransfer choice. +func (e *encoder) RegistrarServiceExecuteAcceptedTransfer(args RegistrarServiceExecuteAcceptedTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedTransfer", args) +} + +// RegistrarServiceExecuteAcceptedUnlock encodes parameters for the RegistrarService_ExecuteAcceptedUnlock choice. +func (e *encoder) RegistrarServiceExecuteAcceptedUnlock(args RegistrarServiceExecuteAcceptedUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_ExecuteAcceptedUnlock", args) +} + +// RegistrarServiceFailAcceptedBurn encodes parameters for the RegistrarService_FailAcceptedBurn choice. +func (e *encoder) RegistrarServiceFailAcceptedBurn(args RegistrarServiceFailAcceptedBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedBurn", args) +} + +// RegistrarServiceFailAcceptedForceTransfer encodes parameters for the RegistrarService_FailAcceptedForceTransfer choice. +func (e *encoder) RegistrarServiceFailAcceptedForceTransfer(args RegistrarServiceFailAcceptedForceTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedForceTransfer", args) +} + +// RegistrarServiceFailAcceptedLock encodes parameters for the RegistrarService_FailAcceptedLock choice. +func (e *encoder) RegistrarServiceFailAcceptedLock(args RegistrarServiceFailAcceptedLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedLock", args) +} + +// RegistrarServiceFailAcceptedMint encodes parameters for the RegistrarService_FailAcceptedMint choice. +func (e *encoder) RegistrarServiceFailAcceptedMint(args RegistrarServiceFailAcceptedMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedMint", args) +} + +// RegistrarServiceFailAcceptedTransfer encodes parameters for the RegistrarService_FailAcceptedTransfer choice. +func (e *encoder) RegistrarServiceFailAcceptedTransfer(args RegistrarServiceFailAcceptedTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedTransfer", args) +} + +// RegistrarServiceFailAcceptedUnlock encodes parameters for the RegistrarService_FailAcceptedUnlock choice. +func (e *encoder) RegistrarServiceFailAcceptedUnlock(args RegistrarServiceFailAcceptedUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_FailAcceptedUnlock", args) +} + +// RegistrarServiceMergeHolding encodes parameters for the RegistrarService_MergeHolding choice. +func (e *encoder) RegistrarServiceMergeHolding(args RegistrarServiceMergeHolding) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_MergeHolding", args) +} + +// RegistrarServiceOfferBurn encodes parameters for the RegistrarService_OfferBurn choice. +func (e *encoder) RegistrarServiceOfferBurn(args RegistrarServiceOfferBurn) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_OfferBurn", args) +} + +// RegistrarServiceOfferMint encodes parameters for the RegistrarService_OfferMint choice. +func (e *encoder) RegistrarServiceOfferMint(args RegistrarServiceOfferMint) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_OfferMint", args) +} + +// RegistrarServiceRejectBurnRequest encodes parameters for the RegistrarService_RejectBurnRequest choice. +func (e *encoder) RegistrarServiceRejectBurnRequest(args RegistrarServiceRejectBurnRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_RejectBurnRequest", args) +} + +// RegistrarServiceRejectEnforcementServiceRequest encodes parameters for the RegistrarService_RejectEnforcementServiceRequest choice. +func (e *encoder) RegistrarServiceRejectEnforcementServiceRequest(args RegistrarServiceRejectEnforcementServiceRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_RejectEnforcementServiceRequest", args) +} + +// RegistrarServiceRejectForceTransferRequest encodes parameters for the RegistrarService_RejectForceTransferRequest choice. +func (e *encoder) RegistrarServiceRejectForceTransferRequest(args RegistrarServiceRejectForceTransferRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_RejectForceTransferRequest", args) +} + +// RegistrarServiceRejectMintRequest encodes parameters for the RegistrarService_RejectMintRequest choice. +func (e *encoder) RegistrarServiceRejectMintRequest(args RegistrarServiceRejectMintRequest) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_RejectMintRequest", args) +} + +// RegistrarServiceSet encodes parameters for the RegistrarService_Set choice. +func (e *encoder) RegistrarServiceSet(args RegistrarServiceSet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_Set", args) +} + +// RegistrarServiceSplitHolding encodes parameters for the RegistrarService_SplitHolding choice. +func (e *encoder) RegistrarServiceSplitHolding(args RegistrarServiceSplitHolding) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_SplitHolding", args) +} + +// RegistrarServiceTerminate encodes parameters for the RegistrarService_Terminate choice. +func (e *encoder) RegistrarServiceTerminate(args RegistrarServiceTerminate) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_Terminate", args) +} + +// RegistrarServiceTerminateEnforcementService encodes parameters for the RegistrarService_TerminateEnforcementService choice. +func (e *encoder) RegistrarServiceTerminateEnforcementService(args RegistrarServiceTerminateEnforcementService) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RegistrarService_TerminateEnforcementService", args) +} + +// RejectedBurnDelete encodes parameters for the RejectedBurn_Delete choice. +func (e *encoder) RejectedBurnDelete(args RejectedBurnDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedBurn_Delete", args) +} + +// RejectedEnforcementServiceRequestDelete encodes parameters for the RejectedEnforcementServiceRequest_Delete choice. +func (e *encoder) RejectedEnforcementServiceRequestDelete(args RejectedEnforcementServiceRequestDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedEnforcementServiceRequest_Delete", args) +} + +// RejectedHolderServiceRequestClean encodes parameters for the RejectedHolderServiceRequest_Clean choice. +func (e *encoder) RejectedHolderServiceRequestClean(args RejectedHolderServiceRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedHolderServiceRequest_Clean", args) +} + +// RejectedHolderServiceRequestDelete encodes parameters for the RejectedHolderServiceRequest_Delete choice. +func (e *encoder) RejectedHolderServiceRequestDelete(args RejectedHolderServiceRequestDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedHolderServiceRequest_Delete", args) +} + +// RejectedMintDelete encodes parameters for the RejectedMint_Delete choice. +func (e *encoder) RejectedMintDelete(args RejectedMintDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedMint_Delete", args) +} + +// RejectedProviderServiceRequestDelete encodes parameters for the RejectedProviderServiceRequest_Delete choice. +func (e *encoder) RejectedProviderServiceRequestDelete(args RejectedProviderServiceRequestDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedProviderServiceRequest_Delete", args) +} + +// RejectedRegistrarServiceRequestDelete encodes parameters for the RejectedRegistrarServiceRequest_Delete choice. +func (e *encoder) RejectedRegistrarServiceRequestDelete(args RejectedRegistrarServiceRequestDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedRegistrarServiceRequest_Delete", args) +} + +// TransferPreapprovalModify encodes parameters for the TransferPreapproval_Modify choice. +func (e *encoder) TransferPreapprovalModify(args TransferPreapprovalModify) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferPreapproval_Modify", args) +} + +// TransferPreapprovalWithdraw encodes parameters for the TransferPreapproval_Withdraw choice. +func (e *encoder) TransferPreapprovalWithdraw(args TransferPreapprovalWithdraw) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferPreapproval_Withdraw", args) +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/utility/registry_holding_v0/registry_holding_v0.go b/bindings/generated/latest/utility/registry_holding_v0/registry_holding_v0.go new file mode 100644 index 000000000..7999bc0ad --- /dev/null +++ b/bindings/generated/latest/utility/registry_holding_v0/registry_holding_v0.go @@ -0,0 +1,1433 @@ +package registry_holding_v0 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "utility-registry-holding-v0" + PackageID = "8107899ac4723ce986bf7d27416534e576e54b92161e46150a595fb78ff3d3a1" + SDKVersion = "3.4.9" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +const ( + GetRegistrarInternalScheme = types.TEXT("RegistrarInternalScheme") + SpliceMetaPrefix = types.TEXT("splice.lfdecentralizedtrust.org/") +) + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// CollapseAction is a variant/union type +type CollapseAction struct { + MergeSplit *types.UNIT `json:"MergeSplit,omitempty"` + MergeSplitLock *Lock2 `json:"MergeSplitLock,omitempty"` + MergeSplitBurn *types.UNIT `json:"MergeSplitBurn,omitempty"` + UnlockMergeSplitBurn *ExpectedLock `json:"UnlockMergeSplitBurn,omitempty"` + MergeSplitTransfer *types.PARTY `json:"MergeSplitTransfer,omitempty"` + UnlockMergeSplitTransfer *Tuple2 `json:"UnlockMergeSplitTransfer,omitempty"` + AutoUnlockMergeSplitTransfer *Tuple2 `json:"AutoUnlockMergeSplitTransfer,omitempty"` + UnlockMergeSplitLockRemaining *types.UNIT `json:"UnlockMergeSplitLockRemaining,omitempty"` +} + +// MarshalJSON implements custom JSON marshaling for CollapseAction +func (v CollapseAction) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(v) +} + +// UnmarshalJSON implements custom JSON unmarshalling for CollapseAction +func (v *CollapseAction) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, v) +} + +// MarshalHex encodes CollapseAction to hex string (Canton MCMS format) +func (v CollapseAction) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(v) +} + +// UnmarshalHex decodes CollapseAction from hex string (Canton MCMS format) +func (v *CollapseAction) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, v) +} + +// GetVariantTag implements types.VARIANT interface +func (v CollapseAction) GetVariantTag() string { + + if v.MergeSplit != nil { + return "MergeSplit" + } + + if v.MergeSplitLock != nil { + return "MergeSplitLock" + } + + if v.MergeSplitBurn != nil { + return "MergeSplitBurn" + } + + if v.UnlockMergeSplitBurn != nil { + return "UnlockMergeSplitBurn" + } + + if v.MergeSplitTransfer != nil { + return "MergeSplitTransfer" + } + + if v.UnlockMergeSplitTransfer != nil { + return "UnlockMergeSplitTransfer" + } + + if v.AutoUnlockMergeSplitTransfer != nil { + return "AutoUnlockMergeSplitTransfer" + } + + if v.UnlockMergeSplitLockRemaining != nil { + return "UnlockMergeSplitLockRemaining" + } + + return "" +} + +// GetVariantValue implements types.VARIANT interface +func (v CollapseAction) GetVariantValue() any { + + if v.MergeSplit != nil { + return v.MergeSplit + } + + if v.MergeSplitLock != nil { + return v.MergeSplitLock + } + + if v.MergeSplitBurn != nil { + return v.MergeSplitBurn + } + + if v.UnlockMergeSplitBurn != nil { + return v.UnlockMergeSplitBurn + } + + if v.MergeSplitTransfer != nil { + return v.MergeSplitTransfer + } + + if v.UnlockMergeSplitTransfer != nil { + return v.UnlockMergeSplitTransfer + } + + if v.AutoUnlockMergeSplitTransfer != nil { + return v.AutoUnlockMergeSplitTransfer + } + + if v.UnlockMergeSplitLockRemaining != nil { + return v.UnlockMergeSplitLockRemaining + } + + return nil +} + +var _ types.VARIANT = (*CollapseAction)(nil) + +// CollapseActionResult is a Record type +type CollapseActionResult struct { + Output *Tuple2 `json:"output" hex:"optional"` + Remaining *types.CONTRACT_ID `json:"remaining" hex:"optional"` +} + +// ToMap converts CollapseActionResult to a map for DAML arguments +func (t CollapseActionResult) ToMap() map[string]any { + m := make(map[string]any) + + if t.Output != nil { + m["output"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Output), + } + } else { + m["output"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.Remaining != nil { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Remaining), + } + } else { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t CollapseActionResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *CollapseActionResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes CollapseActionResult to hex string (Canton MCMS format) +func (t CollapseActionResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes CollapseActionResult from hex string (Canton MCMS format) +func (t *CollapseActionResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExpectedLock is a Record type +type ExpectedLock struct { + Lockers types.SET `json:"lockers"` + Context types.TEXT `json:"context"` +} + +// ToMap converts ExpectedLock to a map for DAML arguments +func (t ExpectedLock) ToMap() map[string]any { + m := make(map[string]any) + + m["lockers"] = model.NestedToDAMLValue(t.Lockers) + + m["context"] = string(t.Context) + + return m +} + +func (t ExpectedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExpectedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExpectedLock to hex string (Canton MCMS format) +func (t ExpectedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExpectedLock from hex string (Canton MCMS format) +func (t *ExpectedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Holding is a Template type +type Holding struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Owner types.PARTY `json:"owner"` + Instrument InstrumentIdentifier `json:"instrument"` + Label types.TEXT `json:"label"` + Amount types.NUMERIC `json:"amount"` + Lock *Lock2 `json:"lock" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t Holding) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t Holding) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t Holding) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["owner"] = t.Owner.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrument"] = model.NestedToDAMLValue(t.Instrument) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["label"] = string(t.Label) + + if t.Amount != "" { + args["amount"] = t.Amount + } + + if t.Lock != nil { + args["lock"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Lock), + } + } else { + args["lock"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t Holding) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["owner"] = t.Owner.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["instrument"] = model.NestedToDAMLValue(t.Instrument) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["label"] = string(t.Label) + + if t.Amount != "" { + args["amount"] = t.Amount + } + + if t.Lock != nil { + args["lock"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Lock), + } + } else { + args["lock"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t Holding) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Holding) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Holding to hex string (Canton MCMS format) +func (t Holding) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Holding from hex string (Canton MCMS format) +func (t *Holding) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for Holding + +// Archive exercises the Archive choice on this Holding contract via the IHolding interface +// This method uses the package name in the template ID +func (t Holding) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t Holding) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// HoldingUnlock exercises the Holding_Unlock choice on this Holding contract +// This method uses the package name in the template ID +func (t Holding) HoldingUnlock(contractID string, args HoldingUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Unlock", + Arguments: argsToMap(args), + } +} + +// HoldingUnlockWithPackageID exercises the Holding_Unlock choice using the provided package ID instead of package name +func (t Holding) HoldingUnlockWithPackageID(contractID string, packageID string, args HoldingUnlock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Unlock", + Arguments: argsToMap(args), + } +} + +// HoldingMerge exercises the Holding_Merge choice on this Holding contract +// This method uses the package name in the template ID +func (t Holding) HoldingMerge(contractID string, args HoldingMerge) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Merge", + Arguments: argsToMap(args), + } +} + +// HoldingMergeWithPackageID exercises the Holding_Merge choice using the provided package ID instead of package name +func (t Holding) HoldingMergeWithPackageID(contractID string, packageID string, args HoldingMerge) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Merge", + Arguments: argsToMap(args), + } +} + +// HoldingLock exercises the Holding_Lock choice on this Holding contract +// This method uses the package name in the template ID +func (t Holding) HoldingLock(contractID string, args HoldingLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Lock", + Arguments: argsToMap(args), + } +} + +// HoldingLockWithPackageID exercises the Holding_Lock choice using the provided package ID instead of package name +func (t Holding) HoldingLockWithPackageID(contractID string, packageID string, args HoldingLock) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Lock", + Arguments: argsToMap(args), + } +} + +// HoldingTransfer exercises the Holding_Transfer choice on this Holding contract +// This method uses the package name in the template ID +func (t Holding) HoldingTransfer(contractID string, args HoldingTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Transfer", + Arguments: argsToMap(args), + } +} + +// HoldingTransferWithPackageID exercises the Holding_Transfer choice using the provided package ID instead of package name +func (t Holding) HoldingTransferWithPackageID(contractID string, packageID string, args HoldingTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Transfer", + Arguments: argsToMap(args), + } +} + +// HoldingSplit exercises the Holding_Split choice on this Holding contract +// This method uses the package name in the template ID +func (t Holding) HoldingSplit(contractID string, args HoldingSplit) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Split", + Arguments: argsToMap(args), + } +} + +// HoldingSplitWithPackageID exercises the Holding_Split choice using the provided package ID instead of package name +func (t Holding) HoldingSplitWithPackageID(contractID string, packageID string, args HoldingSplit) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.Holding.V0.Holding", "Holding"), + ContractID: contractID, + Choice: "Holding_Split", + Arguments: argsToMap(args), + } +} + +// Verify interface implementations for Holding + +var _ splice_api_token_holding_v1.IHolding = (*Holding)(nil) + +// HoldingLock is a Record type +type HoldingLock struct { + Lockers types.SET `json:"lockers"` + Context types.TEXT `json:"context"` + Observers *types.SET `json:"observers" hex:"optional"` +} + +// ToMap converts HoldingLock to a map for DAML arguments +func (t HoldingLock) ToMap() map[string]any { + m := make(map[string]any) + + m["lockers"] = model.NestedToDAMLValue(t.Lockers) + + m["context"] = string(t.Context) + + if t.Observers != nil { + m["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + m["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t HoldingLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingLock to hex string (Canton MCMS format) +func (t HoldingLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingLock from hex string (Canton MCMS format) +func (t *HoldingLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingLockResult is a Record type +type HoldingLockResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts HoldingLockResult to a map for DAML arguments +func (t HoldingLockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t HoldingLockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingLockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingLockResult to hex string (Canton MCMS format) +func (t HoldingLockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingLockResult from hex string (Canton MCMS format) +func (t *HoldingLockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingMerge is a Record type +type HoldingMerge struct { + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` +} + +// ToMap converts HoldingMerge to a map for DAML arguments +func (t HoldingMerge) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t HoldingMerge) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingMerge) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingMerge to hex string (Canton MCMS format) +func (t HoldingMerge) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingMerge from hex string (Canton MCMS format) +func (t *HoldingMerge) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingMergeResult is a Record type +type HoldingMergeResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts HoldingMergeResult to a map for DAML arguments +func (t HoldingMergeResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t HoldingMergeResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingMergeResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingMergeResult to hex string (Canton MCMS format) +func (t HoldingMergeResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingMergeResult from hex string (Canton MCMS format) +func (t *HoldingMergeResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingSplit is a Record type +type HoldingSplit struct { + Amounts []types.NUMERIC `json:"amounts"` +} + +// ToMap converts HoldingSplit to a map for DAML arguments +func (t HoldingSplit) ToMap() map[string]any { + m := make(map[string]any) + + m["amounts"] = func() []any { + res := make([]any, 0, len(t.Amounts)) + for _, e := range t.Amounts { + res = append(res, e) + } + return res + }() + + return m +} + +func (t HoldingSplit) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingSplit) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingSplit to hex string (Canton MCMS format) +func (t HoldingSplit) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingSplit from hex string (Canton MCMS format) +func (t *HoldingSplit) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingSplitResult is a Record type +type HoldingSplitResult struct { + SplitCids []types.CONTRACT_ID `json:"splitCids"` + Remaining *types.CONTRACT_ID `json:"remaining" hex:"optional"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts HoldingSplitResult to a map for DAML arguments +func (t HoldingSplitResult) ToMap() map[string]any { + m := make(map[string]any) + + m["splitCids"] = func() []any { + res := make([]any, 0, len(t.SplitCids)) + for _, e := range t.SplitCids { + res = append(res, e) + } + return res + }() + + if t.Remaining != nil { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Remaining), + } + } else { + m["remaining"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t HoldingSplitResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingSplitResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingSplitResult to hex string (Canton MCMS format) +func (t HoldingSplitResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingSplitResult from hex string (Canton MCMS format) +func (t *HoldingSplitResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingTransfer is a Record type +type HoldingTransfer struct { + NewOwner types.PARTY `json:"newOwner"` + NewLabel types.TEXT `json:"newLabel"` +} + +// ToMap converts HoldingTransfer to a map for DAML arguments +func (t HoldingTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["newOwner"] = t.NewOwner.ToMap() + + m["newLabel"] = string(t.NewLabel) + + return m +} + +func (t HoldingTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingTransfer to hex string (Canton MCMS format) +func (t HoldingTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingTransfer from hex string (Canton MCMS format) +func (t *HoldingTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingTransferResult is a Record type +type HoldingTransferResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts HoldingTransferResult to a map for DAML arguments +func (t HoldingTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t HoldingTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingTransferResult to hex string (Canton MCMS format) +func (t HoldingTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingTransferResult from hex string (Canton MCMS format) +func (t *HoldingTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingUnlock is a Record type +type HoldingUnlock struct { +} + +// ToMap converts HoldingUnlock to a map for DAML arguments +func (t HoldingUnlock) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t HoldingUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingUnlock to hex string (Canton MCMS format) +func (t HoldingUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingUnlock from hex string (Canton MCMS format) +func (t *HoldingUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// HoldingUnlockResult is a Record type +type HoldingUnlockResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts HoldingUnlockResult to a map for DAML arguments +func (t HoldingUnlockResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t HoldingUnlockResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *HoldingUnlockResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes HoldingUnlockResult to hex string (Canton MCMS format) +func (t HoldingUnlockResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes HoldingUnlockResult from hex string (Canton MCMS format) +func (t *HoldingUnlockResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// InstrumentIdentifier is a Record type +type InstrumentIdentifier struct { + Source types.PARTY `json:"source"` + Id types.TEXT `json:"id"` + Scheme types.TEXT `json:"scheme"` +} + +// ToMap converts InstrumentIdentifier to a map for DAML arguments +func (t InstrumentIdentifier) ToMap() map[string]any { + m := make(map[string]any) + + m["source"] = t.Source.ToMap() + + m["id"] = string(t.Id) + + m["scheme"] = string(t.Scheme) + + return m +} + +func (t InstrumentIdentifier) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentIdentifier) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentIdentifier to hex string (Canton MCMS format) +func (t InstrumentIdentifier) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentIdentifier from hex string (Canton MCMS format) +func (t *InstrumentIdentifier) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Lock2 is a Record type +type Lock2 struct { + Lockers types.SET `json:"lockers"` + Context types.TEXT `json:"context"` + Observers *types.SET `json:"observers" hex:"optional"` +} + +// ToMap converts Lock2 to a map for DAML arguments +func (t Lock2) ToMap() map[string]any { + m := make(map[string]any) + + m["lockers"] = model.NestedToDAMLValue(t.Lockers) + + m["context"] = string(t.Context) + + if t.Observers != nil { + m["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + m["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t Lock2) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Lock2) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Lock2 to hex string (Canton MCMS format) +func (t Lock2) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Lock2 from hex string (Canton MCMS format) +func (t *Lock2) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperator is a Record type +type WithOperator struct { + Operator types.PARTY `json:"operator"` +} + +// ToMap converts WithOperator to a map for DAML arguments +func (t WithOperator) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + return m +} + +func (t WithOperator) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperator) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperator to hex string (Canton MCMS format) +func (t WithOperator) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperator from hex string (Canton MCMS format) +func (t *WithOperator) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorProvider is a Record type +type WithOperatorProvider struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` +} + +// ToMap converts WithOperatorProvider to a map for DAML arguments +func (t WithOperatorProvider) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + return m +} + +func (t WithOperatorProvider) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorProvider) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorProvider to hex string (Canton MCMS format) +func (t WithOperatorProvider) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorProvider from hex string (Canton MCMS format) +func (t *WithOperatorProvider) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorProviderRegistrar is a Record type +type WithOperatorProviderRegistrar struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` +} + +// ToMap converts WithOperatorProviderRegistrar to a map for DAML arguments +func (t WithOperatorProviderRegistrar) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + return m +} + +func (t WithOperatorProviderRegistrar) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorProviderRegistrar) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorProviderRegistrar to hex string (Canton MCMS format) +func (t WithOperatorProviderRegistrar) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorProviderRegistrar from hex string (Canton MCMS format) +func (t *WithOperatorProviderRegistrar) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorProviderRegistrarHolder is a Record type +type WithOperatorProviderRegistrarHolder struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` +} + +// ToMap converts WithOperatorProviderRegistrarHolder to a map for DAML arguments +func (t WithOperatorProviderRegistrarHolder) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + return m +} + +func (t WithOperatorProviderRegistrarHolder) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorProviderRegistrarHolder) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorProviderRegistrarHolder to hex string (Canton MCMS format) +func (t WithOperatorProviderRegistrarHolder) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorProviderRegistrarHolder from hex string (Canton MCMS format) +func (t *WithOperatorProviderRegistrarHolder) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorProviderRegistrarHolderInstrument is a Record type +type WithOperatorProviderRegistrarHolderInstrument struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + Instrument InstrumentIdentifier `json:"instrument"` +} + +// ToMap converts WithOperatorProviderRegistrarHolderInstrument to a map for DAML arguments +func (t WithOperatorProviderRegistrarHolderInstrument) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["instrument"] = model.NestedToDAMLValue(t.Instrument) + + return m +} + +func (t WithOperatorProviderRegistrarHolderInstrument) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorProviderRegistrarHolderInstrument) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorProviderRegistrarHolderInstrument to hex string (Canton MCMS format) +func (t WithOperatorProviderRegistrarHolderInstrument) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorProviderRegistrarHolderInstrument from hex string (Canton MCMS format) +func (t *WithOperatorProviderRegistrarHolderInstrument) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorRegistrar is a Record type +type WithOperatorRegistrar struct { + Operator types.PARTY `json:"operator"` + Registrar types.PARTY `json:"registrar"` +} + +// ToMap converts WithOperatorRegistrar to a map for DAML arguments +func (t WithOperatorRegistrar) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + return m +} + +func (t WithOperatorRegistrar) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorRegistrar) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorRegistrar to hex string (Canton MCMS format) +func (t WithOperatorRegistrar) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorRegistrar from hex string (Canton MCMS format) +func (t *WithOperatorRegistrar) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// WithOperatorRegistrarHolderInstrument is a Record type +type WithOperatorRegistrarHolderInstrument struct { + Operator types.PARTY `json:"operator"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + Instrument InstrumentIdentifier `json:"instrument"` +} + +// ToMap converts WithOperatorRegistrarHolderInstrument to a map for DAML arguments +func (t WithOperatorRegistrarHolderInstrument) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["instrument"] = model.NestedToDAMLValue(t.Instrument) + + return m +} + +func (t WithOperatorRegistrarHolderInstrument) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *WithOperatorRegistrarHolderInstrument) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes WithOperatorRegistrarHolderInstrument to hex string (Canton MCMS format) +func (t WithOperatorRegistrarHolderInstrument) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes WithOperatorRegistrarHolderInstrument from hex string (Canton MCMS format) +func (t *WithOperatorRegistrarHolderInstrument) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { + HoldingLock(args HoldingLock) (*bind.EncodedChoice, error) + HoldingMerge(args HoldingMerge) (*bind.EncodedChoice, error) + HoldingSplit(args HoldingSplit) (*bind.EncodedChoice, error) + HoldingTransfer(args HoldingTransfer) (*bind.EncodedChoice, error) + HoldingUnlock(args HoldingUnlock) (*bind.EncodedChoice, error) +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// HoldingLock encodes parameters for the Holding_Lock choice. +func (e *encoder) HoldingLock(args HoldingLock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Holding_Lock", args) +} + +// HoldingMerge encodes parameters for the Holding_Merge choice. +func (e *encoder) HoldingMerge(args HoldingMerge) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Holding_Merge", args) +} + +// HoldingSplit encodes parameters for the Holding_Split choice. +func (e *encoder) HoldingSplit(args HoldingSplit) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Holding_Split", args) +} + +// HoldingTransfer encodes parameters for the Holding_Transfer choice. +func (e *encoder) HoldingTransfer(args HoldingTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Holding_Transfer", args) +} + +// HoldingUnlock encodes parameters for the Holding_Unlock choice. +func (e *encoder) HoldingUnlock(args HoldingUnlock) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("Holding_Unlock", args) +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/bindings/generated/latest/utility/registry_holding_v0/tuple2.go b/bindings/generated/latest/utility/registry_holding_v0/tuple2.go new file mode 100644 index 000000000..d7f66edb0 --- /dev/null +++ b/bindings/generated/latest/utility/registry_holding_v0/tuple2.go @@ -0,0 +1,8 @@ +package registry_holding_v0 +// Code generated by contracts/cmd/bindings. DO NOT EDIT. + +// Tuple2 mirrors GHC.Tuple from daml-prim (referenced by utility DARs, not emitted by codegen). +type Tuple2 struct { + First any `json:"_1"` + Second any `json:"_2"` +} diff --git a/bindings/generated/latest/utility/registry_v0/registry_v0.go b/bindings/generated/latest/utility/registry_v0/registry_v0.go new file mode 100644 index 000000000..192aeefca --- /dev/null +++ b/bindings/generated/latest/utility/registry_v0/registry_v0.go @@ -0,0 +1,13292 @@ +package registry_v0 + +import ( + "errors" + "fmt" + "math/big" + "strings" + + splice_api_featured_app_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_featured_app_v1" + splice_api_token_allocation_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_allocation_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + splice_api_token_transfer_instruction_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_transfer_instruction_v1" + credential_v0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/credential_v0" + registry_holding_v0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_holding_v0" + "github.com/smartcontractkit/go-daml/pkg/bind" + "github.com/smartcontractkit/go-daml/pkg/codec" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var ( + _ = fmt.Sprintf + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = model.Command{} + _ bind.BoundTemplate +) + +const ( + PackageName = "utility-registry-v0" + PackageID = "a236e8e22a3b5f199e37d5554e82bafd2df688f901de02b00be3964bdfa8c1ab" + SDKVersion = "3.4.9" +) + +type Template interface { + CreateCommand() *model.CreateCommand + GetTemplateID() string +} + +const ( + UtilityPrefix = types.TEXT("utility.digitalasset.com/") +) + +func argsToMap(args any) map[string]any { + if args == nil { + return map[string]any{} + } + + if m, ok := args.(map[string]any); ok { + return m + } + + type mapper interface { + ToMap() map[string]any + } + if mapper, ok := args.(mapper); ok { + return mapper.ToMap() + } + + return map[string]any{"args": args} +} + +// AcceptedBurn is a Template type +type AcceptedBurn struct { + Burn Burn `json:"burn"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurn to hex string (Canton MCMS format) +func (t AcceptedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurn from hex string (Canton MCMS format) +func (t *AcceptedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedBurn + +// AcceptedBurnClean exercises the AcceptedBurn_Clean choice on this AcceptedBurn contract +// This method uses the package name in the template ID +func (t AcceptedBurn) AcceptedBurnClean(contractID string, args AcceptedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedBurnCleanWithPackageID exercises the AcceptedBurn_Clean choice using the provided package ID instead of package name +func (t AcceptedBurn) AcceptedBurnCleanWithPackageID(contractID string, packageID string, args AcceptedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedBurnExecute exercises the AcceptedBurn_Execute choice on this AcceptedBurn contract +// This method uses the package name in the template ID +func (t AcceptedBurn) AcceptedBurnExecute(contractID string, args AcceptedBurnExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedBurnExecuteWithPackageID exercises the AcceptedBurn_Execute choice using the provided package ID instead of package name +func (t AcceptedBurn) AcceptedBurnExecuteWithPackageID(contractID string, packageID string, args AcceptedBurnExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedBurnFail exercises the AcceptedBurn_Fail choice on this AcceptedBurn contract +// This method uses the package name in the template ID +func (t AcceptedBurn) AcceptedBurnFail(contractID string, args AcceptedBurnFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedBurnFailWithPackageID exercises the AcceptedBurn_Fail choice using the provided package ID instead of package name +func (t AcceptedBurn) AcceptedBurnFailWithPackageID(contractID string, packageID string, args AcceptedBurnFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "AcceptedBurn_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedBurn contract +// This method uses the package name in the template ID +func (t AcceptedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "AcceptedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedBurnClean is a Record type +type AcceptedBurnClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AcceptedBurnClean to a map for DAML arguments +func (t AcceptedBurnClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AcceptedBurnClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurnClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurnClean to hex string (Canton MCMS format) +func (t AcceptedBurnClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurnClean from hex string (Canton MCMS format) +func (t *AcceptedBurnClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedBurnExecute is a Record type +type AcceptedBurnExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts AcceptedBurnExecute to a map for DAML arguments +func (t AcceptedBurnExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t AcceptedBurnExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurnExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurnExecute to hex string (Canton MCMS format) +func (t AcceptedBurnExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurnExecute from hex string (Canton MCMS format) +func (t *AcceptedBurnExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedBurnExecuteResult is a Record type +type AcceptedBurnExecuteResult struct { + ExecutedBurnCid types.CONTRACT_ID `json:"executedBurnCid"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts AcceptedBurnExecuteResult to a map for DAML arguments +func (t AcceptedBurnExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["executedBurnCid"] = model.NestedToDAMLValue(t.ExecutedBurnCid) + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t AcceptedBurnExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurnExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurnExecuteResult to hex string (Canton MCMS format) +func (t AcceptedBurnExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurnExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedBurnExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedBurnFail is a Record type +type AcceptedBurnFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedBurnFail to a map for DAML arguments +func (t AcceptedBurnFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedBurnFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurnFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurnFail to hex string (Canton MCMS format) +func (t AcceptedBurnFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurnFail from hex string (Canton MCMS format) +func (t *AcceptedBurnFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedBurnFailResult is a Record type +type AcceptedBurnFailResult struct { + FailedBurnCid types.CONTRACT_ID `json:"failedBurnCid"` +} + +// ToMap converts AcceptedBurnFailResult to a map for DAML arguments +func (t AcceptedBurnFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedBurnCid"] = model.NestedToDAMLValue(t.FailedBurnCid) + + return m +} + +func (t AcceptedBurnFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedBurnFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedBurnFailResult to hex string (Canton MCMS format) +func (t AcceptedBurnFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedBurnFailResult from hex string (Canton MCMS format) +func (t *AcceptedBurnFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedForceTransfer is a Template type +type AcceptedForceTransfer struct { + ForceTransfer ForceTransfer `json:"forceTransfer"` + RegistrarRationale types.TEXT `json:"registrarRationale"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedForceTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedForceTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedForceTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRationale"] = string(t.RegistrarRationale) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedForceTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRationale"] = string(t.RegistrarRationale) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedForceTransfer to hex string (Canton MCMS format) +func (t AcceptedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedForceTransfer from hex string (Canton MCMS format) +func (t *AcceptedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedForceTransfer + +// AcceptedForceTransferExecute exercises the AcceptedForceTransfer_Execute choice on this AcceptedForceTransfer contract +// This method uses the package name in the template ID +func (t AcceptedForceTransfer) AcceptedForceTransferExecute(contractID string, args AcceptedForceTransferExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "AcceptedForceTransfer_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedForceTransferExecuteWithPackageID exercises the AcceptedForceTransfer_Execute choice using the provided package ID instead of package name +func (t AcceptedForceTransfer) AcceptedForceTransferExecuteWithPackageID(contractID string, packageID string, args AcceptedForceTransferExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "AcceptedForceTransfer_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedForceTransferFail exercises the AcceptedForceTransfer_Fail choice on this AcceptedForceTransfer contract +// This method uses the package name in the template ID +func (t AcceptedForceTransfer) AcceptedForceTransferFail(contractID string, args AcceptedForceTransferFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "AcceptedForceTransfer_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedForceTransferFailWithPackageID exercises the AcceptedForceTransfer_Fail choice using the provided package ID instead of package name +func (t AcceptedForceTransfer) AcceptedForceTransferFailWithPackageID(contractID string, packageID string, args AcceptedForceTransferFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "AcceptedForceTransfer_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedForceTransfer contract +// This method uses the package name in the template ID +func (t AcceptedForceTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedForceTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "AcceptedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedForceTransferExecute is a Record type +type AcceptedForceTransferExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` + RequestorCredentialCids []types.CONTRACT_ID `json:"requestorCredentialCids"` +} + +// ToMap converts AcceptedForceTransferExecute to a map for DAML arguments +func (t AcceptedForceTransferExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + m["requestorCredentialCids"] = func() []any { + res := make([]any, 0, len(t.RequestorCredentialCids)) + for _, e := range t.RequestorCredentialCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t AcceptedForceTransferExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedForceTransferExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedForceTransferExecute to hex string (Canton MCMS format) +func (t AcceptedForceTransferExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedForceTransferExecute from hex string (Canton MCMS format) +func (t *AcceptedForceTransferExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedForceTransferExecuteResult is a Record type +type AcceptedForceTransferExecuteResult struct { + HoldingTransferResult registry_holding_v0.HoldingTransferResult `json:"holdingTransferResult"` + ExecutedForceTransferCid types.CONTRACT_ID `json:"executedForceTransferCid"` + RemainingHoldingCids []types.CONTRACT_ID `json:"remainingHoldingCids"` +} + +// ToMap converts AcceptedForceTransferExecuteResult to a map for DAML arguments +func (t AcceptedForceTransferExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingTransferResult"] = model.NestedToDAMLValue(t.HoldingTransferResult) + + m["executedForceTransferCid"] = model.NestedToDAMLValue(t.ExecutedForceTransferCid) + + m["remainingHoldingCids"] = func() []any { + res := make([]any, 0, len(t.RemainingHoldingCids)) + for _, e := range t.RemainingHoldingCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t AcceptedForceTransferExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedForceTransferExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedForceTransferExecuteResult to hex string (Canton MCMS format) +func (t AcceptedForceTransferExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedForceTransferExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedForceTransferExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedForceTransferFail is a Record type +type AcceptedForceTransferFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedForceTransferFail to a map for DAML arguments +func (t AcceptedForceTransferFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedForceTransferFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedForceTransferFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedForceTransferFail to hex string (Canton MCMS format) +func (t AcceptedForceTransferFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedForceTransferFail from hex string (Canton MCMS format) +func (t *AcceptedForceTransferFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedForceTransferFailResult is a Record type +type AcceptedForceTransferFailResult struct { + FailedForceTransferCid types.CONTRACT_ID `json:"failedForceTransferCid"` +} + +// ToMap converts AcceptedForceTransferFailResult to a map for DAML arguments +func (t AcceptedForceTransferFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedForceTransferCid"] = model.NestedToDAMLValue(t.FailedForceTransferCid) + + return m +} + +func (t AcceptedForceTransferFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedForceTransferFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedForceTransferFailResult to hex string (Canton MCMS format) +func (t AcceptedForceTransferFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedForceTransferFailResult from hex string (Canton MCMS format) +func (t *AcceptedForceTransferFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedLock is a Template type +type AcceptedLock struct { + Lock Lock3 `json:"lock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedLock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "AcceptedLock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedLock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "AcceptedLock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedLock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedLock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLock to hex string (Canton MCMS format) +func (t AcceptedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLock from hex string (Canton MCMS format) +func (t *AcceptedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedLock + +// AcceptedLockClean exercises the AcceptedLock_Clean choice on this AcceptedLock contract +// This method uses the package name in the template ID +func (t AcceptedLock) AcceptedLockClean(contractID string, args AcceptedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedLockCleanWithPackageID exercises the AcceptedLock_Clean choice using the provided package ID instead of package name +func (t AcceptedLock) AcceptedLockCleanWithPackageID(contractID string, packageID string, args AcceptedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedLockExecute exercises the AcceptedLock_Execute choice on this AcceptedLock contract +// This method uses the package name in the template ID +func (t AcceptedLock) AcceptedLockExecute(contractID string, args AcceptedLockExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedLockExecuteWithPackageID exercises the AcceptedLock_Execute choice using the provided package ID instead of package name +func (t AcceptedLock) AcceptedLockExecuteWithPackageID(contractID string, packageID string, args AcceptedLockExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedLockFail exercises the AcceptedLock_Fail choice on this AcceptedLock contract +// This method uses the package name in the template ID +func (t AcceptedLock) AcceptedLockFail(contractID string, args AcceptedLockFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedLockFailWithPackageID exercises the AcceptedLock_Fail choice using the provided package ID instead of package name +func (t AcceptedLock) AcceptedLockFailWithPackageID(contractID string, packageID string, args AcceptedLockFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "AcceptedLock_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedLock contract +// This method uses the package name in the template ID +func (t AcceptedLock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedLock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "AcceptedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedLockClean is a Record type +type AcceptedLockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AcceptedLockClean to a map for DAML arguments +func (t AcceptedLockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AcceptedLockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLockClean to hex string (Canton MCMS format) +func (t AcceptedLockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLockClean from hex string (Canton MCMS format) +func (t *AcceptedLockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedLockExecute is a Record type +type AcceptedLockExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts AcceptedLockExecute to a map for DAML arguments +func (t AcceptedLockExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t AcceptedLockExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLockExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLockExecute to hex string (Canton MCMS format) +func (t AcceptedLockExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLockExecute from hex string (Canton MCMS format) +func (t *AcceptedLockExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedLockExecuteResult is a Record type +type AcceptedLockExecuteResult struct { + HoldingLockResult registry_holding_v0.HoldingLockResult `json:"holdingLockResult"` + ExecutedLockCid types.CONTRACT_ID `json:"executedLockCid"` +} + +// ToMap converts AcceptedLockExecuteResult to a map for DAML arguments +func (t AcceptedLockExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingLockResult"] = model.NestedToDAMLValue(t.HoldingLockResult) + + m["executedLockCid"] = model.NestedToDAMLValue(t.ExecutedLockCid) + + return m +} + +func (t AcceptedLockExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLockExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLockExecuteResult to hex string (Canton MCMS format) +func (t AcceptedLockExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLockExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedLockExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedLockFail is a Record type +type AcceptedLockFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedLockFail to a map for DAML arguments +func (t AcceptedLockFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedLockFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLockFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLockFail to hex string (Canton MCMS format) +func (t AcceptedLockFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLockFail from hex string (Canton MCMS format) +func (t *AcceptedLockFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedLockFailResult is a Record type +type AcceptedLockFailResult struct { + FailedLockCid types.CONTRACT_ID `json:"failedLockCid"` +} + +// ToMap converts AcceptedLockFailResult to a map for DAML arguments +func (t AcceptedLockFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedLockCid"] = model.NestedToDAMLValue(t.FailedLockCid) + + return m +} + +func (t AcceptedLockFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedLockFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedLockFailResult to hex string (Canton MCMS format) +func (t AcceptedLockFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedLockFailResult from hex string (Canton MCMS format) +func (t *AcceptedLockFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedMint is a Template type +type AcceptedMint struct { + Mint Mint `json:"mint"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "AcceptedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "AcceptedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMint to hex string (Canton MCMS format) +func (t AcceptedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMint from hex string (Canton MCMS format) +func (t *AcceptedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedMint + +// AcceptedMintClean exercises the AcceptedMint_Clean choice on this AcceptedMint contract +// This method uses the package name in the template ID +func (t AcceptedMint) AcceptedMintClean(contractID string, args AcceptedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedMintCleanWithPackageID exercises the AcceptedMint_Clean choice using the provided package ID instead of package name +func (t AcceptedMint) AcceptedMintCleanWithPackageID(contractID string, packageID string, args AcceptedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedMintExecute exercises the AcceptedMint_Execute choice on this AcceptedMint contract +// This method uses the package name in the template ID +func (t AcceptedMint) AcceptedMintExecute(contractID string, args AcceptedMintExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedMintExecuteWithPackageID exercises the AcceptedMint_Execute choice using the provided package ID instead of package name +func (t AcceptedMint) AcceptedMintExecuteWithPackageID(contractID string, packageID string, args AcceptedMintExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedMintFail exercises the AcceptedMint_Fail choice on this AcceptedMint contract +// This method uses the package name in the template ID +func (t AcceptedMint) AcceptedMintFail(contractID string, args AcceptedMintFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedMintFailWithPackageID exercises the AcceptedMint_Fail choice using the provided package ID instead of package name +func (t AcceptedMint) AcceptedMintFailWithPackageID(contractID string, packageID string, args AcceptedMintFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "AcceptedMint_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedMint contract +// This method uses the package name in the template ID +func (t AcceptedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "AcceptedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedMintClean is a Record type +type AcceptedMintClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AcceptedMintClean to a map for DAML arguments +func (t AcceptedMintClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AcceptedMintClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMintClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMintClean to hex string (Canton MCMS format) +func (t AcceptedMintClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMintClean from hex string (Canton MCMS format) +func (t *AcceptedMintClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedMintExecute is a Record type +type AcceptedMintExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` +} + +// ToMap converts AcceptedMintExecute to a map for DAML arguments +func (t AcceptedMintExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t AcceptedMintExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMintExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMintExecute to hex string (Canton MCMS format) +func (t AcceptedMintExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMintExecute from hex string (Canton MCMS format) +func (t *AcceptedMintExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedMintExecuteResult is a Record type +type AcceptedMintExecuteResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + ExecutedMintCid types.CONTRACT_ID `json:"executedMintCid"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts AcceptedMintExecuteResult to a map for DAML arguments +func (t AcceptedMintExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + m["executedMintCid"] = model.NestedToDAMLValue(t.ExecutedMintCid) + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t AcceptedMintExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMintExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMintExecuteResult to hex string (Canton MCMS format) +func (t AcceptedMintExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMintExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedMintExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedMintFail is a Record type +type AcceptedMintFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedMintFail to a map for DAML arguments +func (t AcceptedMintFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedMintFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMintFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMintFail to hex string (Canton MCMS format) +func (t AcceptedMintFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMintFail from hex string (Canton MCMS format) +func (t *AcceptedMintFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedMintFailResult is a Record type +type AcceptedMintFailResult struct { + FailedMintCid types.CONTRACT_ID `json:"failedMintCid"` +} + +// ToMap converts AcceptedMintFailResult to a map for DAML arguments +func (t AcceptedMintFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedMintCid"] = model.NestedToDAMLValue(t.FailedMintCid) + + return m +} + +func (t AcceptedMintFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedMintFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedMintFailResult to hex string (Canton MCMS format) +func (t AcceptedMintFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedMintFailResult from hex string (Canton MCMS format) +func (t *AcceptedMintFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedTransfer is a Template type +type AcceptedTransfer struct { + Transfer Transfer2 `json:"transfer"` + SenderLabel types.TEXT `json:"senderLabel"` + ReceiverLabel types.TEXT `json:"receiverLabel"` + Observers *types.SET `json:"observers" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransfer to hex string (Canton MCMS format) +func (t AcceptedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransfer from hex string (Canton MCMS format) +func (t *AcceptedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedTransfer + +// AcceptedTransferClean exercises the AcceptedTransfer_Clean choice on this AcceptedTransfer contract +// This method uses the package name in the template ID +func (t AcceptedTransfer) AcceptedTransferClean(contractID string, args AcceptedTransferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedTransferCleanWithPackageID exercises the AcceptedTransfer_Clean choice using the provided package ID instead of package name +func (t AcceptedTransfer) AcceptedTransferCleanWithPackageID(contractID string, packageID string, args AcceptedTransferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedTransferExecute exercises the AcceptedTransfer_Execute choice on this AcceptedTransfer contract +// This method uses the package name in the template ID +func (t AcceptedTransfer) AcceptedTransferExecute(contractID string, args AcceptedTransferExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedTransferExecuteWithPackageID exercises the AcceptedTransfer_Execute choice using the provided package ID instead of package name +func (t AcceptedTransfer) AcceptedTransferExecuteWithPackageID(contractID string, packageID string, args AcceptedTransferExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedTransferFail exercises the AcceptedTransfer_Fail choice on this AcceptedTransfer contract +// This method uses the package name in the template ID +func (t AcceptedTransfer) AcceptedTransferFail(contractID string, args AcceptedTransferFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedTransferFailWithPackageID exercises the AcceptedTransfer_Fail choice using the provided package ID instead of package name +func (t AcceptedTransfer) AcceptedTransferFailWithPackageID(contractID string, packageID string, args AcceptedTransferFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "AcceptedTransfer_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedTransfer contract +// This method uses the package name in the template ID +func (t AcceptedTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "AcceptedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedTransferClean is a Record type +type AcceptedTransferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AcceptedTransferClean to a map for DAML arguments +func (t AcceptedTransferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AcceptedTransferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransferClean to hex string (Canton MCMS format) +func (t AcceptedTransferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransferClean from hex string (Canton MCMS format) +func (t *AcceptedTransferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedTransferExecute is a Record type +type AcceptedTransferExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + SenderCredentialCids []types.CONTRACT_ID `json:"senderCredentialCids"` + ReceiverCredentialCids []types.CONTRACT_ID `json:"receiverCredentialCids"` + HoldingCid types.CONTRACT_ID `json:"holdingCid"` +} + +// ToMap converts AcceptedTransferExecute to a map for DAML arguments +func (t AcceptedTransferExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["senderCredentialCids"] = func() []any { + res := make([]any, 0, len(t.SenderCredentialCids)) + for _, e := range t.SenderCredentialCids { + res = append(res, e) + } + return res + }() + + m["receiverCredentialCids"] = func() []any { + res := make([]any, 0, len(t.ReceiverCredentialCids)) + for _, e := range t.ReceiverCredentialCids { + res = append(res, e) + } + return res + }() + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + return m +} + +func (t AcceptedTransferExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransferExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransferExecute to hex string (Canton MCMS format) +func (t AcceptedTransferExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransferExecute from hex string (Canton MCMS format) +func (t *AcceptedTransferExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedTransferExecuteResult is a Record type +type AcceptedTransferExecuteResult struct { + HoldingTransferResult registry_holding_v0.HoldingTransferResult `json:"holdingTransferResult"` + ExecutedTransferCid types.CONTRACT_ID `json:"executedTransferCid"` + Meta *splice_api_token_metadata_v1.Metadata `json:"meta" hex:"optional"` +} + +// ToMap converts AcceptedTransferExecuteResult to a map for DAML arguments +func (t AcceptedTransferExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingTransferResult"] = model.NestedToDAMLValue(t.HoldingTransferResult) + + m["executedTransferCid"] = model.NestedToDAMLValue(t.ExecutedTransferCid) + + if t.Meta != nil { + m["meta"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Meta), + } + } else { + m["meta"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t AcceptedTransferExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransferExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransferExecuteResult to hex string (Canton MCMS format) +func (t AcceptedTransferExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransferExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedTransferExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedTransferFail is a Record type +type AcceptedTransferFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedTransferFail to a map for DAML arguments +func (t AcceptedTransferFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedTransferFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransferFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransferFail to hex string (Canton MCMS format) +func (t AcceptedTransferFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransferFail from hex string (Canton MCMS format) +func (t *AcceptedTransferFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedTransferFailResult is a Record type +type AcceptedTransferFailResult struct { + FailedTransferCid types.CONTRACT_ID `json:"failedTransferCid"` +} + +// ToMap converts AcceptedTransferFailResult to a map for DAML arguments +func (t AcceptedTransferFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedTransferCid"] = model.NestedToDAMLValue(t.FailedTransferCid) + + return m +} + +func (t AcceptedTransferFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedTransferFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedTransferFailResult to hex string (Canton MCMS format) +func (t AcceptedTransferFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedTransferFailResult from hex string (Canton MCMS format) +func (t *AcceptedTransferFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedUnlock is a Template type +type AcceptedUnlock struct { + Unlock Unlock `json:"unlock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AcceptedUnlock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AcceptedUnlock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AcceptedUnlock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AcceptedUnlock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AcceptedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlock to hex string (Canton MCMS format) +func (t AcceptedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlock from hex string (Canton MCMS format) +func (t *AcceptedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AcceptedUnlock + +// AcceptedUnlockClean exercises the AcceptedUnlock_Clean choice on this AcceptedUnlock contract +// This method uses the package name in the template ID +func (t AcceptedUnlock) AcceptedUnlockClean(contractID string, args AcceptedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedUnlockCleanWithPackageID exercises the AcceptedUnlock_Clean choice using the provided package ID instead of package name +func (t AcceptedUnlock) AcceptedUnlockCleanWithPackageID(contractID string, packageID string, args AcceptedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// AcceptedUnlockExecute exercises the AcceptedUnlock_Execute choice on this AcceptedUnlock contract +// This method uses the package name in the template ID +func (t AcceptedUnlock) AcceptedUnlockExecute(contractID string, args AcceptedUnlockExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedUnlockExecuteWithPackageID exercises the AcceptedUnlock_Execute choice using the provided package ID instead of package name +func (t AcceptedUnlock) AcceptedUnlockExecuteWithPackageID(contractID string, packageID string, args AcceptedUnlockExecute) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Execute", + Arguments: argsToMap(args), + } +} + +// AcceptedUnlockFail exercises the AcceptedUnlock_Fail choice on this AcceptedUnlock contract +// This method uses the package name in the template ID +func (t AcceptedUnlock) AcceptedUnlockFail(contractID string, args AcceptedUnlockFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Fail", + Arguments: argsToMap(args), + } +} + +// AcceptedUnlockFailWithPackageID exercises the AcceptedUnlock_Fail choice using the provided package ID instead of package name +func (t AcceptedUnlock) AcceptedUnlockFailWithPackageID(contractID string, packageID string, args AcceptedUnlockFail) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "AcceptedUnlock_Fail", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this AcceptedUnlock contract +// This method uses the package name in the template ID +func (t AcceptedUnlock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AcceptedUnlock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "AcceptedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AcceptedUnlockClean is a Record type +type AcceptedUnlockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts AcceptedUnlockClean to a map for DAML arguments +func (t AcceptedUnlockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t AcceptedUnlockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlockClean to hex string (Canton MCMS format) +func (t AcceptedUnlockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlockClean from hex string (Canton MCMS format) +func (t *AcceptedUnlockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedUnlockExecute is a Record type +type AcceptedUnlockExecute struct { + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + CredentialCids []types.CONTRACT_ID `json:"credentialCids"` + HoldingCids []types.CONTRACT_ID `json:"holdingCids"` +} + +// ToMap converts AcceptedUnlockExecute to a map for DAML arguments +func (t AcceptedUnlockExecute) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["credentialCids"] = func() []any { + res := make([]any, 0, len(t.CredentialCids)) + for _, e := range t.CredentialCids { + res = append(res, e) + } + return res + }() + + m["holdingCids"] = func() []any { + res := make([]any, 0, len(t.HoldingCids)) + for _, e := range t.HoldingCids { + res = append(res, e) + } + return res + }() + + return m +} + +func (t AcceptedUnlockExecute) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlockExecute) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlockExecute to hex string (Canton MCMS format) +func (t AcceptedUnlockExecute) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlockExecute from hex string (Canton MCMS format) +func (t *AcceptedUnlockExecute) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedUnlockExecuteResult is a Record type +type AcceptedUnlockExecuteResult struct { + HoldingCid types.CONTRACT_ID `json:"holdingCid"` + RemainingCids []types.CONTRACT_ID `json:"remainingCids"` + ExecutedUnlockCid types.CONTRACT_ID `json:"executedUnlockCid"` +} + +// ToMap converts AcceptedUnlockExecuteResult to a map for DAML arguments +func (t AcceptedUnlockExecuteResult) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingCid"] = model.NestedToDAMLValue(t.HoldingCid) + + m["remainingCids"] = func() []any { + res := make([]any, 0, len(t.RemainingCids)) + for _, e := range t.RemainingCids { + res = append(res, e) + } + return res + }() + + m["executedUnlockCid"] = model.NestedToDAMLValue(t.ExecutedUnlockCid) + + return m +} + +func (t AcceptedUnlockExecuteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlockExecuteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlockExecuteResult to hex string (Canton MCMS format) +func (t AcceptedUnlockExecuteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlockExecuteResult from hex string (Canton MCMS format) +func (t *AcceptedUnlockExecuteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedUnlockFail is a Record type +type AcceptedUnlockFail struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts AcceptedUnlockFail to a map for DAML arguments +func (t AcceptedUnlockFail) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t AcceptedUnlockFail) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlockFail) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlockFail to hex string (Canton MCMS format) +func (t AcceptedUnlockFail) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlockFail from hex string (Canton MCMS format) +func (t *AcceptedUnlockFail) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AcceptedUnlockFailResult is a Record type +type AcceptedUnlockFailResult struct { + FailedUnlockCid types.CONTRACT_ID `json:"failedUnlockCid"` +} + +// ToMap converts AcceptedUnlockFailResult to a map for DAML arguments +func (t AcceptedUnlockFailResult) ToMap() map[string]any { + m := make(map[string]any) + + m["failedUnlockCid"] = model.NestedToDAMLValue(t.FailedUnlockCid) + + return m +} + +func (t AcceptedUnlockFailResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AcceptedUnlockFailResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AcceptedUnlockFailResult to hex string (Canton MCMS format) +func (t AcceptedUnlockFailResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AcceptedUnlockFailResult from hex string (Canton MCMS format) +func (t *AcceptedUnlockFailResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AppRewardConfiguration is a Template type +type AppRewardConfiguration struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Details AppRewardConfigurationDetails `json:"details"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t AppRewardConfiguration) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t AppRewardConfiguration) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t AppRewardConfiguration) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["details"] = model.NestedToDAMLValue(t.Details) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t AppRewardConfiguration) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["details"] = model.NestedToDAMLValue(t.Details) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t AppRewardConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AppRewardConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AppRewardConfiguration to hex string (Canton MCMS format) +func (t AppRewardConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AppRewardConfiguration from hex string (Canton MCMS format) +func (t *AppRewardConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for AppRewardConfiguration + +// Archive exercises the Archive choice on this AppRewardConfiguration contract +// This method uses the package name in the template ID +func (t AppRewardConfiguration) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t AppRewardConfiguration) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AppRewardConfigurationModify exercises the AppRewardConfiguration_Modify choice on this AppRewardConfiguration contract +// This method uses the package name in the template ID +func (t AppRewardConfiguration) AppRewardConfigurationModify(contractID string, args AppRewardConfigurationModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration"), + ContractID: contractID, + Choice: "AppRewardConfiguration_Modify", + Arguments: argsToMap(args), + } +} + +// AppRewardConfigurationModifyWithPackageID exercises the AppRewardConfiguration_Modify choice using the provided package ID instead of package name +func (t AppRewardConfiguration) AppRewardConfigurationModifyWithPackageID(contractID string, packageID string, args AppRewardConfigurationModify) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.AppReward", "AppRewardConfiguration"), + ContractID: contractID, + Choice: "AppRewardConfiguration_Modify", + Arguments: argsToMap(args), + } +} + +// AppRewardConfigurationDetails is a Record type +type AppRewardConfigurationDetails struct { + Dso types.PARTY `json:"dso"` + OperatorAppRewardBeneficiary splice_api_featured_app_v1.AppRewardBeneficiary `json:"operatorAppRewardBeneficiary"` +} + +// ToMap converts AppRewardConfigurationDetails to a map for DAML arguments +func (t AppRewardConfigurationDetails) ToMap() map[string]any { + m := make(map[string]any) + + m["dso"] = t.Dso.ToMap() + + m["operatorAppRewardBeneficiary"] = model.NestedToDAMLValue(t.OperatorAppRewardBeneficiary) + + return m +} + +func (t AppRewardConfigurationDetails) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AppRewardConfigurationDetails) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AppRewardConfigurationDetails to hex string (Canton MCMS format) +func (t AppRewardConfigurationDetails) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AppRewardConfigurationDetails from hex string (Canton MCMS format) +func (t *AppRewardConfigurationDetails) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// AppRewardConfigurationModify is a Record type +type AppRewardConfigurationModify struct { + Details AppRewardConfigurationDetails `json:"details"` +} + +// ToMap converts AppRewardConfigurationModify to a map for DAML arguments +func (t AppRewardConfigurationModify) ToMap() map[string]any { + m := make(map[string]any) + + m["details"] = model.NestedToDAMLValue(t.Details) + + return m +} + +func (t AppRewardConfigurationModify) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *AppRewardConfigurationModify) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes AppRewardConfigurationModify to hex string (Canton MCMS format) +func (t AppRewardConfigurationModify) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes AppRewardConfigurationModify from hex string (Canton MCMS format) +func (t *AppRewardConfigurationModify) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Batch is a Record type +type Batch struct { + Id types.TEXT `json:"id"` + Size types.INT64 `json:"size"` + SettlementFrom *types.TIMESTAMP `json:"settlementFrom" hex:"optional"` + SettlementUntil *types.TIMESTAMP `json:"settlementUntil" hex:"optional"` +} + +// ToMap converts Batch to a map for DAML arguments +func (t Batch) ToMap() map[string]any { + m := make(map[string]any) + + m["id"] = string(t.Id) + + m["size"] = int64(t.Size) + + if t.SettlementFrom != nil { + m["settlementFrom"] = map[string]any{ + "_type": "optional", + "value": *t.SettlementFrom, + } + } else { + m["settlementFrom"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.SettlementUntil != nil { + m["settlementUntil"] = map[string]any{ + "_type": "optional", + "value": *t.SettlementUntil, + } + } else { + m["settlementUntil"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t Batch) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Batch) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Batch to hex string (Canton MCMS format) +func (t Batch) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Batch from hex string (Canton MCMS format) +func (t *Batch) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Burn is a Record type +type Burn struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + Batch Batch `json:"batch"` +} + +// ToMap converts Burn to a map for DAML arguments +func (t Burn) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t Burn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Burn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Burn to hex string (Canton MCMS format) +func (t Burn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Burn from hex string (Canton MCMS format) +func (t *Burn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOffer is a Template type +type BurnOffer struct { + Burn Burn `json:"burn"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t BurnOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t BurnOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t BurnOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t BurnOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t BurnOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOffer to hex string (Canton MCMS format) +func (t BurnOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOffer from hex string (Canton MCMS format) +func (t *BurnOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for BurnOffer + +// BurnOfferClean exercises the BurnOffer_Clean choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferClean(contractID string, args BurnOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Clean", + Arguments: argsToMap(args), + } +} + +// BurnOfferCleanWithPackageID exercises the BurnOffer_Clean choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferCleanWithPackageID(contractID string, packageID string, args BurnOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Clean", + Arguments: argsToMap(args), + } +} + +// BurnOfferAccept exercises the BurnOffer_Accept choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferAccept(contractID string, args BurnOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Accept", + Arguments: argsToMap(args), + } +} + +// BurnOfferAcceptWithPackageID exercises the BurnOffer_Accept choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferAcceptWithPackageID(contractID string, packageID string, args BurnOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Accept", + Arguments: argsToMap(args), + } +} + +// BurnOfferReject exercises the BurnOffer_Reject choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferReject(contractID string, args BurnOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Reject", + Arguments: argsToMap(args), + } +} + +// BurnOfferRejectWithPackageID exercises the BurnOffer_Reject choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferRejectWithPackageID(contractID string, packageID string, args BurnOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Reject", + Arguments: argsToMap(args), + } +} + +// BurnOfferCancel exercises the BurnOffer_Cancel choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) BurnOfferCancel(contractID string, args BurnOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// BurnOfferCancelWithPackageID exercises the BurnOffer_Cancel choice using the provided package ID instead of package name +func (t BurnOffer) BurnOfferCancelWithPackageID(contractID string, packageID string, args BurnOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "BurnOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this BurnOffer contract +// This method uses the package name in the template ID +func (t BurnOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t BurnOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// BurnOfferAccept is a Record type +type BurnOfferAccept struct { + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// ToMap converts BurnOfferAccept to a map for DAML arguments +func (t BurnOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingLabel"] = string(t.HoldingLabel) + + return m +} + +func (t BurnOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferAccept to hex string (Canton MCMS format) +func (t BurnOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferAccept from hex string (Canton MCMS format) +func (t *BurnOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferAcceptResult is a Record type +type BurnOfferAcceptResult struct { + AcceptedBurnCid types.CONTRACT_ID `json:"acceptedBurnCid"` +} + +// ToMap converts BurnOfferAcceptResult to a map for DAML arguments +func (t BurnOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedBurnCid"] = model.NestedToDAMLValue(t.AcceptedBurnCid) + + return m +} + +func (t BurnOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferAcceptResult to hex string (Canton MCMS format) +func (t BurnOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferAcceptResult from hex string (Canton MCMS format) +func (t *BurnOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferCancel is a Record type +type BurnOfferCancel struct { +} + +// ToMap converts BurnOfferCancel to a map for DAML arguments +func (t BurnOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferCancel to hex string (Canton MCMS format) +func (t BurnOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferCancel from hex string (Canton MCMS format) +func (t *BurnOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferCancelResult is a Record type +type BurnOfferCancelResult struct { +} + +// ToMap converts BurnOfferCancelResult to a map for DAML arguments +func (t BurnOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferCancelResult to hex string (Canton MCMS format) +func (t BurnOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferCancelResult from hex string (Canton MCMS format) +func (t *BurnOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferClean is a Record type +type BurnOfferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts BurnOfferClean to a map for DAML arguments +func (t BurnOfferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t BurnOfferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferClean to hex string (Canton MCMS format) +func (t BurnOfferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferClean from hex string (Canton MCMS format) +func (t *BurnOfferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferReject is a Record type +type BurnOfferReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts BurnOfferReject to a map for DAML arguments +func (t BurnOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t BurnOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferReject to hex string (Canton MCMS format) +func (t BurnOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferReject from hex string (Canton MCMS format) +func (t *BurnOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnOfferRejectResult is a Record type +type BurnOfferRejectResult struct { + RejectedBurnCid types.CONTRACT_ID `json:"rejectedBurnCid"` +} + +// ToMap converts BurnOfferRejectResult to a map for DAML arguments +func (t BurnOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedBurnCid"] = model.NestedToDAMLValue(t.RejectedBurnCid) + + return m +} + +func (t BurnOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnOfferRejectResult to hex string (Canton MCMS format) +func (t BurnOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnOfferRejectResult from hex string (Canton MCMS format) +func (t *BurnOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequest is a Template type +type BurnRequest struct { + Burn Burn `json:"burn"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t BurnRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t BurnRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t BurnRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t BurnRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t BurnRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequest to hex string (Canton MCMS format) +func (t BurnRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequest from hex string (Canton MCMS format) +func (t *BurnRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for BurnRequest + +// BurnRequestClean exercises the BurnRequest_Clean choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestClean(contractID string, args BurnRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Clean", + Arguments: argsToMap(args), + } +} + +// BurnRequestCleanWithPackageID exercises the BurnRequest_Clean choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestCleanWithPackageID(contractID string, packageID string, args BurnRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Clean", + Arguments: argsToMap(args), + } +} + +// BurnRequestAccept exercises the BurnRequest_Accept choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestAccept(contractID string, args BurnRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Accept", + Arguments: argsToMap(args), + } +} + +// BurnRequestAcceptWithPackageID exercises the BurnRequest_Accept choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestAcceptWithPackageID(contractID string, packageID string, args BurnRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Accept", + Arguments: argsToMap(args), + } +} + +// BurnRequestReject exercises the BurnRequest_Reject choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestReject(contractID string, args BurnRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Reject", + Arguments: argsToMap(args), + } +} + +// BurnRequestRejectWithPackageID exercises the BurnRequest_Reject choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestRejectWithPackageID(contractID string, packageID string, args BurnRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Reject", + Arguments: argsToMap(args), + } +} + +// BurnRequestCancel exercises the BurnRequest_Cancel choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) BurnRequestCancel(contractID string, args BurnRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// BurnRequestCancelWithPackageID exercises the BurnRequest_Cancel choice using the provided package ID instead of package name +func (t BurnRequest) BurnRequestCancelWithPackageID(contractID string, packageID string, args BurnRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "BurnRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this BurnRequest contract +// This method uses the package name in the template ID +func (t BurnRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t BurnRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "BurnRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// BurnRequestAccept is a Record type +type BurnRequestAccept struct { +} + +// ToMap converts BurnRequestAccept to a map for DAML arguments +func (t BurnRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestAccept to hex string (Canton MCMS format) +func (t BurnRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestAccept from hex string (Canton MCMS format) +func (t *BurnRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestAcceptResult is a Record type +type BurnRequestAcceptResult struct { + AcceptedBurnCid types.CONTRACT_ID `json:"acceptedBurnCid"` +} + +// ToMap converts BurnRequestAcceptResult to a map for DAML arguments +func (t BurnRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedBurnCid"] = model.NestedToDAMLValue(t.AcceptedBurnCid) + + return m +} + +func (t BurnRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestAcceptResult to hex string (Canton MCMS format) +func (t BurnRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestAcceptResult from hex string (Canton MCMS format) +func (t *BurnRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestCancel is a Record type +type BurnRequestCancel struct { +} + +// ToMap converts BurnRequestCancel to a map for DAML arguments +func (t BurnRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestCancel to hex string (Canton MCMS format) +func (t BurnRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestCancel from hex string (Canton MCMS format) +func (t *BurnRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestCancelResult is a Record type +type BurnRequestCancelResult struct { +} + +// ToMap converts BurnRequestCancelResult to a map for DAML arguments +func (t BurnRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t BurnRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestCancelResult to hex string (Canton MCMS format) +func (t BurnRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestCancelResult from hex string (Canton MCMS format) +func (t *BurnRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestClean is a Record type +type BurnRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts BurnRequestClean to a map for DAML arguments +func (t BurnRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t BurnRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestClean to hex string (Canton MCMS format) +func (t BurnRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestClean from hex string (Canton MCMS format) +func (t *BurnRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestReject is a Record type +type BurnRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts BurnRequestReject to a map for DAML arguments +func (t BurnRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t BurnRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestReject to hex string (Canton MCMS format) +func (t BurnRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestReject from hex string (Canton MCMS format) +func (t *BurnRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// BurnRequestRejectResult is a Record type +type BurnRequestRejectResult struct { + RejectedBurnCid types.CONTRACT_ID `json:"rejectedBurnCid"` +} + +// ToMap converts BurnRequestRejectResult to a map for DAML arguments +func (t BurnRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedBurnCid"] = model.NestedToDAMLValue(t.RejectedBurnCid) + + return m +} + +func (t BurnRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *BurnRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes BurnRequestRejectResult to hex string (Canton MCMS format) +func (t BurnRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes BurnRequestRejectResult from hex string (Canton MCMS format) +func (t *BurnRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// DvpLegAllocation is a Template type +type DvpLegAllocation struct { + Allocation splice_api_token_allocation_v1.AllocationSpecification `json:"allocation"` + LockedHoldingCid types.CONTRACT_ID `json:"lockedHoldingCid"` + Operator types.PARTY `json:"operator"` + Provider *types.PARTY `json:"provider" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t DvpLegAllocation) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Allocation", "DvpLegAllocation") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t DvpLegAllocation) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Allocation", "DvpLegAllocation") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t DvpLegAllocation) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["allocation"] = model.NestedToDAMLValue(t.Allocation) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lockedHoldingCid"] = model.NestedToDAMLValue(t.LockedHoldingCid) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + if t.Provider != nil { + args["provider"] = map[string]any{ + "_type": "optional", + "value": (*t.Provider).ToMap(), + } + } else { + args["provider"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t DvpLegAllocation) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["allocation"] = model.NestedToDAMLValue(t.Allocation) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lockedHoldingCid"] = model.NestedToDAMLValue(t.LockedHoldingCid) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + if t.Provider != nil { + args["provider"] = map[string]any{ + "_type": "optional", + "value": (*t.Provider).ToMap(), + } + } else { + args["provider"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t DvpLegAllocation) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *DvpLegAllocation) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes DvpLegAllocation to hex string (Canton MCMS format) +func (t DvpLegAllocation) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes DvpLegAllocation from hex string (Canton MCMS format) +func (t *DvpLegAllocation) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for DvpLegAllocation + +// Archive exercises the Archive choice on this DvpLegAllocation contract via the IAllocation interface +// This method uses the package name in the template ID +func (t DvpLegAllocation) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t DvpLegAllocation) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// AllocationWithdraw exercises the Allocation_Withdraw choice on this DvpLegAllocation contract via the IAllocation interface +// This method uses the package name in the template ID +func (t DvpLegAllocation) AllocationWithdraw(contractID string, args splice_api_token_allocation_v1.AllocationWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_Withdraw", + Arguments: argsToMap(args), + } +} + +// AllocationWithdrawWithPackageID exercises the Allocation_Withdraw choice using the provided package ID instead of package name +func (t DvpLegAllocation) AllocationWithdrawWithPackageID(contractID string, packageID string, args splice_api_token_allocation_v1.AllocationWithdraw) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_Withdraw", + Arguments: argsToMap(args), + } +} + +// AllocationCancel exercises the Allocation_Cancel choice on this DvpLegAllocation contract via the IAllocation interface +// This method uses the package name in the template ID +func (t DvpLegAllocation) AllocationCancel(contractID string, args splice_api_token_allocation_v1.AllocationCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_Cancel", + Arguments: argsToMap(args), + } +} + +// AllocationCancelWithPackageID exercises the Allocation_Cancel choice using the provided package ID instead of package name +func (t DvpLegAllocation) AllocationCancelWithPackageID(contractID string, packageID string, args splice_api_token_allocation_v1.AllocationCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_Cancel", + Arguments: argsToMap(args), + } +} + +// AllocationExecuteTransfer exercises the Allocation_ExecuteTransfer choice on this DvpLegAllocation contract via the IAllocation interface +// This method uses the package name in the template ID +func (t DvpLegAllocation) AllocationExecuteTransfer(contractID string, args splice_api_token_allocation_v1.AllocationExecuteTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_ExecuteTransfer", + Arguments: argsToMap(args), + } +} + +// AllocationExecuteTransferWithPackageID exercises the Allocation_ExecuteTransfer choice using the provided package ID instead of package name +func (t DvpLegAllocation) AllocationExecuteTransferWithPackageID(contractID string, packageID string, args splice_api_token_allocation_v1.AllocationExecuteTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Allocation", "Allocation"), + ContractID: contractID, + Choice: "Allocation_ExecuteTransfer", + Arguments: argsToMap(args), + } +} + +// Verify interface implementations for DvpLegAllocation + +var _ splice_api_token_allocation_v1.IAllocation = (*DvpLegAllocation)(nil) + +// ExecutedBurn is a Template type +type ExecutedBurn struct { + Burn Burn `json:"burn"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurn to hex string (Canton MCMS format) +func (t ExecutedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurn from hex string (Canton MCMS format) +func (t *ExecutedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedBurn + +// ExecutedBurnClean exercises the ExecutedBurn_Clean choice on this ExecutedBurn contract +// This method uses the package name in the template ID +func (t ExecutedBurn) ExecutedBurnClean(contractID string, args ExecutedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// ExecutedBurnCleanWithPackageID exercises the ExecutedBurn_Clean choice using the provided package ID instead of package name +func (t ExecutedBurn) ExecutedBurnCleanWithPackageID(contractID string, packageID string, args ExecutedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedBurn contract +// This method uses the package name in the template ID +func (t ExecutedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedBurnDelete exercises the ExecutedBurn_Delete choice on this ExecutedBurn contract +// This method uses the package name in the template ID +func (t ExecutedBurn) ExecutedBurnDelete(contractID string, args ExecutedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedBurnDeleteWithPackageID exercises the ExecutedBurn_Delete choice using the provided package ID instead of package name +func (t ExecutedBurn) ExecutedBurnDeleteWithPackageID(contractID string, packageID string, args ExecutedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "ExecutedBurn"), + ContractID: contractID, + Choice: "ExecutedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedBurnClean is a Record type +type ExecutedBurnClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedBurnClean to a map for DAML arguments +func (t ExecutedBurnClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedBurnClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurnClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurnClean to hex string (Canton MCMS format) +func (t ExecutedBurnClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurnClean from hex string (Canton MCMS format) +func (t *ExecutedBurnClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedBurnDelete is a Record type +type ExecutedBurnDelete struct { +} + +// ToMap converts ExecutedBurnDelete to a map for DAML arguments +func (t ExecutedBurnDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedBurnDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurnDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurnDelete to hex string (Canton MCMS format) +func (t ExecutedBurnDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurnDelete from hex string (Canton MCMS format) +func (t *ExecutedBurnDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedBurnDeleteResult is a Record type +type ExecutedBurnDeleteResult struct { +} + +// ToMap converts ExecutedBurnDeleteResult to a map for DAML arguments +func (t ExecutedBurnDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedBurnDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedBurnDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedBurnDeleteResult to hex string (Canton MCMS format) +func (t ExecutedBurnDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedBurnDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedBurnDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedForceTransfer is a Template type +type ExecutedForceTransfer struct { + ForceTransfer ForceTransfer `json:"forceTransfer"` + RegistrarRationale types.TEXT `json:"registrarRationale"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedForceTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedForceTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedForceTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRationale"] = string(t.RegistrarRationale) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedForceTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrarRationale"] = string(t.RegistrarRationale) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedForceTransfer to hex string (Canton MCMS format) +func (t ExecutedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedForceTransfer from hex string (Canton MCMS format) +func (t *ExecutedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedForceTransfer + +// Archive exercises the Archive choice on this ExecutedForceTransfer contract +// This method uses the package name in the template ID +func (t ExecutedForceTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedForceTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedForceTransferDelete exercises the ExecutedForceTransfer_Delete choice on this ExecutedForceTransfer contract +// This method uses the package name in the template ID +func (t ExecutedForceTransfer) ExecutedForceTransferDelete(contractID string, args ExecutedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer"), + ContractID: contractID, + Choice: "ExecutedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedForceTransferDeleteWithPackageID exercises the ExecutedForceTransfer_Delete choice using the provided package ID instead of package name +func (t ExecutedForceTransfer) ExecutedForceTransferDeleteWithPackageID(contractID string, packageID string, args ExecutedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ExecutedForceTransfer"), + ContractID: contractID, + Choice: "ExecutedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedForceTransferDelete is a Record type +type ExecutedForceTransferDelete struct { +} + +// ToMap converts ExecutedForceTransferDelete to a map for DAML arguments +func (t ExecutedForceTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedForceTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedForceTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedForceTransferDelete to hex string (Canton MCMS format) +func (t ExecutedForceTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedForceTransferDelete from hex string (Canton MCMS format) +func (t *ExecutedForceTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedForceTransferDeleteResult is a Record type +type ExecutedForceTransferDeleteResult struct { +} + +// ToMap converts ExecutedForceTransferDeleteResult to a map for DAML arguments +func (t ExecutedForceTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedForceTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedForceTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedForceTransferDeleteResult to hex string (Canton MCMS format) +func (t ExecutedForceTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedForceTransferDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedForceTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedLock is a Template type +type ExecutedLock struct { + Lock Lock3 `json:"lock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedLock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "ExecutedLock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedLock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "ExecutedLock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedLock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedLock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedLock to hex string (Canton MCMS format) +func (t ExecutedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedLock from hex string (Canton MCMS format) +func (t *ExecutedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedLock + +// ExecutedLockClean exercises the ExecutedLock_Clean choice on this ExecutedLock contract +// This method uses the package name in the template ID +func (t ExecutedLock) ExecutedLockClean(contractID string, args ExecutedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "ExecutedLock_Clean", + Arguments: argsToMap(args), + } +} + +// ExecutedLockCleanWithPackageID exercises the ExecutedLock_Clean choice using the provided package ID instead of package name +func (t ExecutedLock) ExecutedLockCleanWithPackageID(contractID string, packageID string, args ExecutedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "ExecutedLock_Clean", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedLock contract +// This method uses the package name in the template ID +func (t ExecutedLock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedLock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedLockDelete exercises the ExecutedLock_Delete choice on this ExecutedLock contract +// This method uses the package name in the template ID +func (t ExecutedLock) ExecutedLockDelete(contractID string, args ExecutedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "ExecutedLock_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedLockDeleteWithPackageID exercises the ExecutedLock_Delete choice using the provided package ID instead of package name +func (t ExecutedLock) ExecutedLockDeleteWithPackageID(contractID string, packageID string, args ExecutedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "ExecutedLock"), + ContractID: contractID, + Choice: "ExecutedLock_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedLockClean is a Record type +type ExecutedLockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedLockClean to a map for DAML arguments +func (t ExecutedLockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedLockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedLockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedLockClean to hex string (Canton MCMS format) +func (t ExecutedLockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedLockClean from hex string (Canton MCMS format) +func (t *ExecutedLockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedLockDelete is a Record type +type ExecutedLockDelete struct { +} + +// ToMap converts ExecutedLockDelete to a map for DAML arguments +func (t ExecutedLockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedLockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedLockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedLockDelete to hex string (Canton MCMS format) +func (t ExecutedLockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedLockDelete from hex string (Canton MCMS format) +func (t *ExecutedLockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedLockDeleteResult is a Record type +type ExecutedLockDeleteResult struct { +} + +// ToMap converts ExecutedLockDeleteResult to a map for DAML arguments +func (t ExecutedLockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedLockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedLockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedLockDeleteResult to hex string (Canton MCMS format) +func (t ExecutedLockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedLockDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedLockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedMint is a Template type +type ExecutedMint struct { + Mint Mint `json:"mint"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "ExecutedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "ExecutedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMint to hex string (Canton MCMS format) +func (t ExecutedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMint from hex string (Canton MCMS format) +func (t *ExecutedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedMint + +// ExecutedMintClean exercises the ExecutedMint_Clean choice on this ExecutedMint contract +// This method uses the package name in the template ID +func (t ExecutedMint) ExecutedMintClean(contractID string, args ExecutedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Clean", + Arguments: argsToMap(args), + } +} + +// ExecutedMintCleanWithPackageID exercises the ExecutedMint_Clean choice using the provided package ID instead of package name +func (t ExecutedMint) ExecutedMintCleanWithPackageID(contractID string, packageID string, args ExecutedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Clean", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedMint contract +// This method uses the package name in the template ID +func (t ExecutedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedMintDelete exercises the ExecutedMint_Delete choice on this ExecutedMint contract +// This method uses the package name in the template ID +func (t ExecutedMint) ExecutedMintDelete(contractID string, args ExecutedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedMintDeleteWithPackageID exercises the ExecutedMint_Delete choice using the provided package ID instead of package name +func (t ExecutedMint) ExecutedMintDeleteWithPackageID(contractID string, packageID string, args ExecutedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "ExecutedMint"), + ContractID: contractID, + Choice: "ExecutedMint_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedMintClean is a Record type +type ExecutedMintClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedMintClean to a map for DAML arguments +func (t ExecutedMintClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedMintClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMintClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMintClean to hex string (Canton MCMS format) +func (t ExecutedMintClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMintClean from hex string (Canton MCMS format) +func (t *ExecutedMintClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedMintDelete is a Record type +type ExecutedMintDelete struct { +} + +// ToMap converts ExecutedMintDelete to a map for DAML arguments +func (t ExecutedMintDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedMintDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMintDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMintDelete to hex string (Canton MCMS format) +func (t ExecutedMintDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMintDelete from hex string (Canton MCMS format) +func (t *ExecutedMintDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedMintDeleteResult is a Record type +type ExecutedMintDeleteResult struct { +} + +// ToMap converts ExecutedMintDeleteResult to a map for DAML arguments +func (t ExecutedMintDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedMintDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedMintDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedMintDeleteResult to hex string (Canton MCMS format) +func (t ExecutedMintDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedMintDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedMintDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedTransfer is a Template type +type ExecutedTransfer struct { + Transfer Transfer2 `json:"transfer"` + SenderLabel types.TEXT `json:"senderLabel"` + ReceiverLabel types.TEXT `json:"receiverLabel"` + Observers *types.SET `json:"observers" hex:"optional"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedTransfer to hex string (Canton MCMS format) +func (t ExecutedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedTransfer from hex string (Canton MCMS format) +func (t *ExecutedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedTransfer + +// Archive exercises the Archive choice on this ExecutedTransfer contract +// This method uses the package name in the template ID +func (t ExecutedTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedTransferDelete exercises the ExecutedTransfer_Delete choice on this ExecutedTransfer contract +// This method uses the package name in the template ID +func (t ExecutedTransfer) ExecutedTransferDelete(contractID string, args ExecutedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer"), + ContractID: contractID, + Choice: "ExecutedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedTransferDeleteWithPackageID exercises the ExecutedTransfer_Delete choice using the provided package ID instead of package name +func (t ExecutedTransfer) ExecutedTransferDeleteWithPackageID(contractID string, packageID string, args ExecutedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "ExecutedTransfer"), + ContractID: contractID, + Choice: "ExecutedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedTransferDelete is a Record type +type ExecutedTransferDelete struct { +} + +// ToMap converts ExecutedTransferDelete to a map for DAML arguments +func (t ExecutedTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedTransferDelete to hex string (Canton MCMS format) +func (t ExecutedTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedTransferDelete from hex string (Canton MCMS format) +func (t *ExecutedTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedTransferDeleteResult is a Record type +type ExecutedTransferDeleteResult struct { +} + +// ToMap converts ExecutedTransferDeleteResult to a map for DAML arguments +func (t ExecutedTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedTransferDeleteResult to hex string (Canton MCMS format) +func (t ExecutedTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedTransferDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedUnlock is a Template type +type ExecutedUnlock struct { + Unlock Unlock `json:"unlock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ExecutedUnlock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ExecutedUnlock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ExecutedUnlock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ExecutedUnlock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ExecutedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedUnlock to hex string (Canton MCMS format) +func (t ExecutedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedUnlock from hex string (Canton MCMS format) +func (t *ExecutedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ExecutedUnlock + +// ExecutedUnlockClean exercises the ExecutedUnlock_Clean choice on this ExecutedUnlock contract +// This method uses the package name in the template ID +func (t ExecutedUnlock) ExecutedUnlockClean(contractID string, args ExecutedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "ExecutedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// ExecutedUnlockCleanWithPackageID exercises the ExecutedUnlock_Clean choice using the provided package ID instead of package name +func (t ExecutedUnlock) ExecutedUnlockCleanWithPackageID(contractID string, packageID string, args ExecutedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "ExecutedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ExecutedUnlock contract +// This method uses the package name in the template ID +func (t ExecutedUnlock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ExecutedUnlock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ExecutedUnlockDelete exercises the ExecutedUnlock_Delete choice on this ExecutedUnlock contract +// This method uses the package name in the template ID +func (t ExecutedUnlock) ExecutedUnlockDelete(contractID string, args ExecutedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "ExecutedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedUnlockDeleteWithPackageID exercises the ExecutedUnlock_Delete choice using the provided package ID instead of package name +func (t ExecutedUnlock) ExecutedUnlockDeleteWithPackageID(contractID string, packageID string, args ExecutedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "ExecutedUnlock"), + ContractID: contractID, + Choice: "ExecutedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// ExecutedUnlockClean is a Record type +type ExecutedUnlockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts ExecutedUnlockClean to a map for DAML arguments +func (t ExecutedUnlockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t ExecutedUnlockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedUnlockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedUnlockClean to hex string (Canton MCMS format) +func (t ExecutedUnlockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedUnlockClean from hex string (Canton MCMS format) +func (t *ExecutedUnlockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedUnlockDelete is a Record type +type ExecutedUnlockDelete struct { +} + +// ToMap converts ExecutedUnlockDelete to a map for DAML arguments +func (t ExecutedUnlockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedUnlockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedUnlockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedUnlockDelete to hex string (Canton MCMS format) +func (t ExecutedUnlockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedUnlockDelete from hex string (Canton MCMS format) +func (t *ExecutedUnlockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExecutedUnlockDeleteResult is a Record type +type ExecutedUnlockDeleteResult struct { +} + +// ToMap converts ExecutedUnlockDeleteResult to a map for DAML arguments +func (t ExecutedUnlockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ExecutedUnlockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ExecutedUnlockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ExecutedUnlockDeleteResult to hex string (Canton MCMS format) +func (t ExecutedUnlockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ExecutedUnlockDeleteResult from hex string (Canton MCMS format) +func (t *ExecutedUnlockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ExpectedInputHoldingLockState is an enum type +type ExpectedInputHoldingLockState string + +const ( + ExpectedInputHoldingLockStateExpectedUnlocked ExpectedInputHoldingLockState = "ExpectedUnlocked" + + ExpectedInputHoldingLockStateExpectedLocked ExpectedInputHoldingLockState = "ExpectedLocked" +) + +func (e ExpectedInputHoldingLockState) GetEnumConstructor() string { return string(e) } + +func (e ExpectedInputHoldingLockState) GetEnumTypeID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "ExpectedInputHoldingLockState") +} + +// GetEnumTypeIDWithPackageID returns the enum type ID using the provided package ID instead of package name +func (e ExpectedInputHoldingLockState) GetEnumTypeIDWithPackageID(packageID string) string { + return fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "ExpectedInputHoldingLockState") +} + +func (e ExpectedInputHoldingLockState) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(e) +} + +func (e *ExpectedInputHoldingLockState) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, e) +} + +// MarshalHex encodes ExpectedInputHoldingLockState to hex string (Canton MCMS format) +func (e ExpectedInputHoldingLockState) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(e) +} + +// UnmarshalHex decodes ExpectedInputHoldingLockState from hex string (Canton MCMS format) +func (e *ExpectedInputHoldingLockState) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, e) +} + +var _ types.ENUM = ExpectedInputHoldingLockState("") + +// FailedBurn is a Template type +type FailedBurn struct { + Burn Burn `json:"burn"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "FailedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "FailedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedBurn to hex string (Canton MCMS format) +func (t FailedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedBurn from hex string (Canton MCMS format) +func (t *FailedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedBurn + +// FailedBurnClean exercises the FailedBurn_Clean choice on this FailedBurn contract +// This method uses the package name in the template ID +func (t FailedBurn) FailedBurnClean(contractID string, args FailedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "FailedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// FailedBurnCleanWithPackageID exercises the FailedBurn_Clean choice using the provided package ID instead of package name +func (t FailedBurn) FailedBurnCleanWithPackageID(contractID string, packageID string, args FailedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "FailedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// FailedBurnDelete exercises the FailedBurn_Delete choice on this FailedBurn contract +// This method uses the package name in the template ID +func (t FailedBurn) FailedBurnDelete(contractID string, args FailedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "FailedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// FailedBurnDeleteWithPackageID exercises the FailedBurn_Delete choice using the provided package ID instead of package name +func (t FailedBurn) FailedBurnDeleteWithPackageID(contractID string, packageID string, args FailedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "FailedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedBurn contract +// This method uses the package name in the template ID +func (t FailedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "FailedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedBurnClean is a Record type +type FailedBurnClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts FailedBurnClean to a map for DAML arguments +func (t FailedBurnClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t FailedBurnClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedBurnClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedBurnClean to hex string (Canton MCMS format) +func (t FailedBurnClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedBurnClean from hex string (Canton MCMS format) +func (t *FailedBurnClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedBurnDelete is a Record type +type FailedBurnDelete struct { +} + +// ToMap converts FailedBurnDelete to a map for DAML arguments +func (t FailedBurnDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedBurnDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedBurnDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedBurnDelete to hex string (Canton MCMS format) +func (t FailedBurnDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedBurnDelete from hex string (Canton MCMS format) +func (t *FailedBurnDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedBurnDeleteResult is a Record type +type FailedBurnDeleteResult struct { +} + +// ToMap converts FailedBurnDeleteResult to a map for DAML arguments +func (t FailedBurnDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedBurnDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedBurnDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedBurnDeleteResult to hex string (Canton MCMS format) +func (t FailedBurnDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedBurnDeleteResult from hex string (Canton MCMS format) +func (t *FailedBurnDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedForceTransfer is a Template type +type FailedForceTransfer struct { + ForceTransfer ForceTransfer `json:"forceTransfer"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedForceTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedForceTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedForceTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedForceTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedForceTransfer to hex string (Canton MCMS format) +func (t FailedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedForceTransfer from hex string (Canton MCMS format) +func (t *FailedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedForceTransfer + +// FailedForceTransferDelete exercises the FailedForceTransfer_Delete choice on this FailedForceTransfer contract +// This method uses the package name in the template ID +func (t FailedForceTransfer) FailedForceTransferDelete(contractID string, args FailedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer"), + ContractID: contractID, + Choice: "FailedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// FailedForceTransferDeleteWithPackageID exercises the FailedForceTransfer_Delete choice using the provided package ID instead of package name +func (t FailedForceTransfer) FailedForceTransferDeleteWithPackageID(contractID string, packageID string, args FailedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer"), + ContractID: contractID, + Choice: "FailedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedForceTransfer contract +// This method uses the package name in the template ID +func (t FailedForceTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedForceTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "FailedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedForceTransferDelete is a Record type +type FailedForceTransferDelete struct { +} + +// ToMap converts FailedForceTransferDelete to a map for DAML arguments +func (t FailedForceTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedForceTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedForceTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedForceTransferDelete to hex string (Canton MCMS format) +func (t FailedForceTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedForceTransferDelete from hex string (Canton MCMS format) +func (t *FailedForceTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedForceTransferDeleteResult is a Record type +type FailedForceTransferDeleteResult struct { +} + +// ToMap converts FailedForceTransferDeleteResult to a map for DAML arguments +func (t FailedForceTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedForceTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedForceTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedForceTransferDeleteResult to hex string (Canton MCMS format) +func (t FailedForceTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedForceTransferDeleteResult from hex string (Canton MCMS format) +func (t *FailedForceTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedLock is a Template type +type FailedLock struct { + Lock Lock3 `json:"lock"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedLock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "FailedLock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedLock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "FailedLock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedLock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedLock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedLock to hex string (Canton MCMS format) +func (t FailedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedLock from hex string (Canton MCMS format) +func (t *FailedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedLock + +// FailedLockClean exercises the FailedLock_Clean choice on this FailedLock contract +// This method uses the package name in the template ID +func (t FailedLock) FailedLockClean(contractID string, args FailedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "FailedLock_Clean", + Arguments: argsToMap(args), + } +} + +// FailedLockCleanWithPackageID exercises the FailedLock_Clean choice using the provided package ID instead of package name +func (t FailedLock) FailedLockCleanWithPackageID(contractID string, packageID string, args FailedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "FailedLock_Clean", + Arguments: argsToMap(args), + } +} + +// FailedLockDelete exercises the FailedLock_Delete choice on this FailedLock contract +// This method uses the package name in the template ID +func (t FailedLock) FailedLockDelete(contractID string, args FailedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "FailedLock_Delete", + Arguments: argsToMap(args), + } +} + +// FailedLockDeleteWithPackageID exercises the FailedLock_Delete choice using the provided package ID instead of package name +func (t FailedLock) FailedLockDeleteWithPackageID(contractID string, packageID string, args FailedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "FailedLock_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedLock contract +// This method uses the package name in the template ID +func (t FailedLock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedLock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "FailedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedLockClean is a Record type +type FailedLockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts FailedLockClean to a map for DAML arguments +func (t FailedLockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t FailedLockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedLockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedLockClean to hex string (Canton MCMS format) +func (t FailedLockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedLockClean from hex string (Canton MCMS format) +func (t *FailedLockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedLockDelete is a Record type +type FailedLockDelete struct { +} + +// ToMap converts FailedLockDelete to a map for DAML arguments +func (t FailedLockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedLockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedLockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedLockDelete to hex string (Canton MCMS format) +func (t FailedLockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedLockDelete from hex string (Canton MCMS format) +func (t *FailedLockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedLockDeleteResult is a Record type +type FailedLockDeleteResult struct { +} + +// ToMap converts FailedLockDeleteResult to a map for DAML arguments +func (t FailedLockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedLockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedLockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedLockDeleteResult to hex string (Canton MCMS format) +func (t FailedLockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedLockDeleteResult from hex string (Canton MCMS format) +func (t *FailedLockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedMint is a Template type +type FailedMint struct { + Mint Mint `json:"mint"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "FailedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "FailedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedMint to hex string (Canton MCMS format) +func (t FailedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedMint from hex string (Canton MCMS format) +func (t *FailedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedMint + +// FailedMintClean exercises the FailedMint_Clean choice on this FailedMint contract +// This method uses the package name in the template ID +func (t FailedMint) FailedMintClean(contractID string, args FailedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "FailedMint_Clean", + Arguments: argsToMap(args), + } +} + +// FailedMintCleanWithPackageID exercises the FailedMint_Clean choice using the provided package ID instead of package name +func (t FailedMint) FailedMintCleanWithPackageID(contractID string, packageID string, args FailedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "FailedMint_Clean", + Arguments: argsToMap(args), + } +} + +// FailedMintDelete exercises the FailedMint_Delete choice on this FailedMint contract +// This method uses the package name in the template ID +func (t FailedMint) FailedMintDelete(contractID string, args FailedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "FailedMint_Delete", + Arguments: argsToMap(args), + } +} + +// FailedMintDeleteWithPackageID exercises the FailedMint_Delete choice using the provided package ID instead of package name +func (t FailedMint) FailedMintDeleteWithPackageID(contractID string, packageID string, args FailedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "FailedMint_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedMint contract +// This method uses the package name in the template ID +func (t FailedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "FailedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedMintClean is a Record type +type FailedMintClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts FailedMintClean to a map for DAML arguments +func (t FailedMintClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t FailedMintClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedMintClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedMintClean to hex string (Canton MCMS format) +func (t FailedMintClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedMintClean from hex string (Canton MCMS format) +func (t *FailedMintClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedMintDelete is a Record type +type FailedMintDelete struct { +} + +// ToMap converts FailedMintDelete to a map for DAML arguments +func (t FailedMintDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedMintDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedMintDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedMintDelete to hex string (Canton MCMS format) +func (t FailedMintDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedMintDelete from hex string (Canton MCMS format) +func (t *FailedMintDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedMintDeleteResult is a Record type +type FailedMintDeleteResult struct { +} + +// ToMap converts FailedMintDeleteResult to a map for DAML arguments +func (t FailedMintDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedMintDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedMintDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedMintDeleteResult to hex string (Canton MCMS format) +func (t FailedMintDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedMintDeleteResult from hex string (Canton MCMS format) +func (t *FailedMintDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedTransfer is a Template type +type FailedTransfer struct { + Transfer Transfer2 `json:"transfer"` + Reason types.TEXT `json:"reason"` + Observers *types.SET `json:"observers" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedTransfer to hex string (Canton MCMS format) +func (t FailedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedTransfer from hex string (Canton MCMS format) +func (t *FailedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedTransfer + +// FailedTransferClean exercises the FailedTransfer_Clean choice on this FailedTransfer contract +// This method uses the package name in the template ID +func (t FailedTransfer) FailedTransferClean(contractID string, args FailedTransferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "FailedTransfer_Clean", + Arguments: argsToMap(args), + } +} + +// FailedTransferCleanWithPackageID exercises the FailedTransfer_Clean choice using the provided package ID instead of package name +func (t FailedTransfer) FailedTransferCleanWithPackageID(contractID string, packageID string, args FailedTransferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "FailedTransfer_Clean", + Arguments: argsToMap(args), + } +} + +// FailedTransferDelete exercises the FailedTransfer_Delete choice on this FailedTransfer contract +// This method uses the package name in the template ID +func (t FailedTransfer) FailedTransferDelete(contractID string, args FailedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "FailedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// FailedTransferDeleteWithPackageID exercises the FailedTransfer_Delete choice using the provided package ID instead of package name +func (t FailedTransfer) FailedTransferDeleteWithPackageID(contractID string, packageID string, args FailedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "FailedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedTransfer contract +// This method uses the package name in the template ID +func (t FailedTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "FailedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedTransferClean is a Record type +type FailedTransferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts FailedTransferClean to a map for DAML arguments +func (t FailedTransferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t FailedTransferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedTransferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedTransferClean to hex string (Canton MCMS format) +func (t FailedTransferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedTransferClean from hex string (Canton MCMS format) +func (t *FailedTransferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedTransferDelete is a Record type +type FailedTransferDelete struct { +} + +// ToMap converts FailedTransferDelete to a map for DAML arguments +func (t FailedTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedTransferDelete to hex string (Canton MCMS format) +func (t FailedTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedTransferDelete from hex string (Canton MCMS format) +func (t *FailedTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedTransferDeleteResult is a Record type +type FailedTransferDeleteResult struct { +} + +// ToMap converts FailedTransferDeleteResult to a map for DAML arguments +func (t FailedTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedTransferDeleteResult to hex string (Canton MCMS format) +func (t FailedTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedTransferDeleteResult from hex string (Canton MCMS format) +func (t *FailedTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedUnlock is a Template type +type FailedUnlock struct { + Unlock Unlock `json:"unlock"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t FailedUnlock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t FailedUnlock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t FailedUnlock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t FailedUnlock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t FailedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedUnlock to hex string (Canton MCMS format) +func (t FailedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedUnlock from hex string (Canton MCMS format) +func (t *FailedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for FailedUnlock + +// FailedUnlockClean exercises the FailedUnlock_Clean choice on this FailedUnlock contract +// This method uses the package name in the template ID +func (t FailedUnlock) FailedUnlockClean(contractID string, args FailedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "FailedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// FailedUnlockCleanWithPackageID exercises the FailedUnlock_Clean choice using the provided package ID instead of package name +func (t FailedUnlock) FailedUnlockCleanWithPackageID(contractID string, packageID string, args FailedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "FailedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// FailedUnlockDelete exercises the FailedUnlock_Delete choice on this FailedUnlock contract +// This method uses the package name in the template ID +func (t FailedUnlock) FailedUnlockDelete(contractID string, args FailedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "FailedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// FailedUnlockDeleteWithPackageID exercises the FailedUnlock_Delete choice using the provided package ID instead of package name +func (t FailedUnlock) FailedUnlockDeleteWithPackageID(contractID string, packageID string, args FailedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "FailedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this FailedUnlock contract +// This method uses the package name in the template ID +func (t FailedUnlock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t FailedUnlock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "FailedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// FailedUnlockClean is a Record type +type FailedUnlockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts FailedUnlockClean to a map for DAML arguments +func (t FailedUnlockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t FailedUnlockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedUnlockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedUnlockClean to hex string (Canton MCMS format) +func (t FailedUnlockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedUnlockClean from hex string (Canton MCMS format) +func (t *FailedUnlockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedUnlockDelete is a Record type +type FailedUnlockDelete struct { +} + +// ToMap converts FailedUnlockDelete to a map for DAML arguments +func (t FailedUnlockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedUnlockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedUnlockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedUnlockDelete to hex string (Canton MCMS format) +func (t FailedUnlockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedUnlockDelete from hex string (Canton MCMS format) +func (t *FailedUnlockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// FailedUnlockDeleteResult is a Record type +type FailedUnlockDeleteResult struct { +} + +// ToMap converts FailedUnlockDeleteResult to a map for DAML arguments +func (t FailedUnlockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t FailedUnlockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *FailedUnlockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes FailedUnlockDeleteResult to hex string (Canton MCMS format) +func (t FailedUnlockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes FailedUnlockDeleteResult from hex string (Canton MCMS format) +func (t *FailedUnlockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransfer is a Record type +type ForceTransfer struct { + Requestor types.PARTY `json:"requestor"` + RequestorRationale types.TEXT `json:"requestorRationale"` + Transfer Transfer2 `json:"transfer"` + SenderLabel types.TEXT `json:"senderLabel"` + ReceiverLabel types.TEXT `json:"receiverLabel"` +} + +// ToMap converts ForceTransfer to a map for DAML arguments +func (t ForceTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["requestor"] = t.Requestor.ToMap() + + m["requestorRationale"] = string(t.RequestorRationale) + + m["transfer"] = model.NestedToDAMLValue(t.Transfer) + + m["senderLabel"] = string(t.SenderLabel) + + m["receiverLabel"] = string(t.ReceiverLabel) + + return m +} + +func (t ForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransfer to hex string (Canton MCMS format) +func (t ForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransfer from hex string (Canton MCMS format) +func (t *ForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequest is a Template type +type ForceTransferRequest struct { + ForceTransfer ForceTransfer `json:"forceTransfer"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t ForceTransferRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t ForceTransferRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t ForceTransferRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t ForceTransferRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t ForceTransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequest to hex string (Canton MCMS format) +func (t ForceTransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequest from hex string (Canton MCMS format) +func (t *ForceTransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for ForceTransferRequest + +// ForceTransferRequestAccept exercises the ForceTransferRequest_Accept choice on this ForceTransferRequest contract +// This method uses the package name in the template ID +func (t ForceTransferRequest) ForceTransferRequestAccept(contractID string, args ForceTransferRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Accept", + Arguments: argsToMap(args), + } +} + +// ForceTransferRequestAcceptWithPackageID exercises the ForceTransferRequest_Accept choice using the provided package ID instead of package name +func (t ForceTransferRequest) ForceTransferRequestAcceptWithPackageID(contractID string, packageID string, args ForceTransferRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Accept", + Arguments: argsToMap(args), + } +} + +// ForceTransferRequestReject exercises the ForceTransferRequest_Reject choice on this ForceTransferRequest contract +// This method uses the package name in the template ID +func (t ForceTransferRequest) ForceTransferRequestReject(contractID string, args ForceTransferRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Reject", + Arguments: argsToMap(args), + } +} + +// ForceTransferRequestRejectWithPackageID exercises the ForceTransferRequest_Reject choice using the provided package ID instead of package name +func (t ForceTransferRequest) ForceTransferRequestRejectWithPackageID(contractID string, packageID string, args ForceTransferRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Reject", + Arguments: argsToMap(args), + } +} + +// ForceTransferRequestCancel exercises the ForceTransferRequest_Cancel choice on this ForceTransferRequest contract +// This method uses the package name in the template ID +func (t ForceTransferRequest) ForceTransferRequestCancel(contractID string, args ForceTransferRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// ForceTransferRequestCancelWithPackageID exercises the ForceTransferRequest_Cancel choice using the provided package ID instead of package name +func (t ForceTransferRequest) ForceTransferRequestCancelWithPackageID(contractID string, packageID string, args ForceTransferRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "ForceTransferRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this ForceTransferRequest contract +// This method uses the package name in the template ID +func (t ForceTransferRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t ForceTransferRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "ForceTransferRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ForceTransferRequestAccept is a Record type +type ForceTransferRequestAccept struct { + RegistrarRationale types.TEXT `json:"registrarRationale"` +} + +// ToMap converts ForceTransferRequestAccept to a map for DAML arguments +func (t ForceTransferRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["registrarRationale"] = string(t.RegistrarRationale) + + return m +} + +func (t ForceTransferRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestAccept to hex string (Canton MCMS format) +func (t ForceTransferRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestAccept from hex string (Canton MCMS format) +func (t *ForceTransferRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequestAcceptResult is a Record type +type ForceTransferRequestAcceptResult struct { + AcceptedForceTransferCid types.CONTRACT_ID `json:"acceptedForceTransferCid"` +} + +// ToMap converts ForceTransferRequestAcceptResult to a map for DAML arguments +func (t ForceTransferRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedForceTransferCid"] = model.NestedToDAMLValue(t.AcceptedForceTransferCid) + + return m +} + +func (t ForceTransferRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestAcceptResult to hex string (Canton MCMS format) +func (t ForceTransferRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestAcceptResult from hex string (Canton MCMS format) +func (t *ForceTransferRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequestCancel is a Record type +type ForceTransferRequestCancel struct { +} + +// ToMap converts ForceTransferRequestCancel to a map for DAML arguments +func (t ForceTransferRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ForceTransferRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestCancel to hex string (Canton MCMS format) +func (t ForceTransferRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestCancel from hex string (Canton MCMS format) +func (t *ForceTransferRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequestCancelResult is a Record type +type ForceTransferRequestCancelResult struct { +} + +// ToMap converts ForceTransferRequestCancelResult to a map for DAML arguments +func (t ForceTransferRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t ForceTransferRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestCancelResult to hex string (Canton MCMS format) +func (t ForceTransferRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestCancelResult from hex string (Canton MCMS format) +func (t *ForceTransferRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequestReject is a Record type +type ForceTransferRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts ForceTransferRequestReject to a map for DAML arguments +func (t ForceTransferRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t ForceTransferRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestReject to hex string (Canton MCMS format) +func (t ForceTransferRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestReject from hex string (Canton MCMS format) +func (t *ForceTransferRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// ForceTransferRequestRejectResult is a Record type +type ForceTransferRequestRejectResult struct { + RejectedForceTransferCid types.CONTRACT_ID `json:"rejectedForceTransferCid"` +} + +// ToMap converts ForceTransferRequestRejectResult to a map for DAML arguments +func (t ForceTransferRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedForceTransferCid"] = model.NestedToDAMLValue(t.RejectedForceTransferCid) + + return m +} + +func (t ForceTransferRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *ForceTransferRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes ForceTransferRequestRejectResult to hex string (Canton MCMS format) +func (t ForceTransferRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes ForceTransferRequestRejectResult from hex string (Canton MCMS format) +func (t *ForceTransferRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// InstrumentConfiguration is a Template type +type InstrumentConfiguration struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + DefaultIdentifier registry_holding_v0.InstrumentIdentifier `json:"defaultIdentifier"` + AdditionalIdentifiers []registry_holding_v0.InstrumentIdentifier `json:"additionalIdentifiers"` + IssuerRequirements []credential_v0.PartyCredentialRequirement `json:"issuerRequirements"` + HolderRequirements []credential_v0.PartyCredentialRequirement `json:"holderRequirements"` + ProviderAppRewardBeneficiaries *[]splice_api_featured_app_v1.AppRewardBeneficiary `json:"providerAppRewardBeneficiaries" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t InstrumentConfiguration) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t InstrumentConfiguration) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t InstrumentConfiguration) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["defaultIdentifier"] = model.NestedToDAMLValue(t.DefaultIdentifier) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["additionalIdentifiers"] = func() []any { + res := make([]any, 0, len(t.AdditionalIdentifiers)) + for _, e := range t.AdditionalIdentifiers { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["issuerRequirements"] = func() []any { + res := make([]any, 0, len(t.IssuerRequirements)) + for _, e := range t.IssuerRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + if t.ProviderAppRewardBeneficiaries != nil { + args["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ProviderAppRewardBeneficiaries), + } + } else { + args["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t InstrumentConfiguration) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["defaultIdentifier"] = model.NestedToDAMLValue(t.DefaultIdentifier) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["additionalIdentifiers"] = func() []any { + res := make([]any, 0, len(t.AdditionalIdentifiers)) + for _, e := range t.AdditionalIdentifiers { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["issuerRequirements"] = func() []any { + res := make([]any, 0, len(t.IssuerRequirements)) + for _, e := range t.IssuerRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holderRequirements"] = func() []any { + res := make([]any, 0, len(t.HolderRequirements)) + for _, e := range t.HolderRequirements { + res = append(res, model.NestedToDAMLValue(e)) + } + return res + }() + + if t.ProviderAppRewardBeneficiaries != nil { + args["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ProviderAppRewardBeneficiaries), + } + } else { + args["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t InstrumentConfiguration) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentConfiguration) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentConfiguration to hex string (Canton MCMS format) +func (t InstrumentConfiguration) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentConfiguration from hex string (Canton MCMS format) +func (t *InstrumentConfiguration) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for InstrumentConfiguration + +// InstrumentConfigurationSetProviderAppRewardBeneficiaries exercises the InstrumentConfiguration_SetProviderAppRewardBeneficiaries choice on this InstrumentConfiguration contract +// This method uses the package name in the template ID +func (t InstrumentConfiguration) InstrumentConfigurationSetProviderAppRewardBeneficiaries(contractID string, args InstrumentConfigurationSetProviderAppRewardBeneficiaries) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "InstrumentConfiguration_SetProviderAppRewardBeneficiaries", + Arguments: argsToMap(args), + } +} + +// InstrumentConfigurationSetProviderAppRewardBeneficiariesWithPackageID exercises the InstrumentConfiguration_SetProviderAppRewardBeneficiaries choice using the provided package ID instead of package name +func (t InstrumentConfiguration) InstrumentConfigurationSetProviderAppRewardBeneficiariesWithPackageID(contractID string, packageID string, args InstrumentConfigurationSetProviderAppRewardBeneficiaries) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "InstrumentConfiguration_SetProviderAppRewardBeneficiaries", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this InstrumentConfiguration contract +// This method uses the package name in the template ID +func (t InstrumentConfiguration) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t InstrumentConfiguration) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// InstrumentConfigurationGet exercises the InstrumentConfiguration_Get choice on this InstrumentConfiguration contract +// This method uses the package name in the template ID +func (t InstrumentConfiguration) InstrumentConfigurationGet(contractID string, args InstrumentConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "InstrumentConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// InstrumentConfigurationGetWithPackageID exercises the InstrumentConfiguration_Get choice using the provided package ID instead of package name +func (t InstrumentConfiguration) InstrumentConfigurationGetWithPackageID(contractID string, packageID string, args InstrumentConfigurationGet) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Configuration.Instrument", "InstrumentConfiguration"), + ContractID: contractID, + Choice: "InstrumentConfiguration_Get", + Arguments: argsToMap(args), + } +} + +// InstrumentConfigurationGet is a Record type +type InstrumentConfigurationGet struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts InstrumentConfigurationGet to a map for DAML arguments +func (t InstrumentConfigurationGet) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t InstrumentConfigurationGet) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentConfigurationGet) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentConfigurationGet to hex string (Canton MCMS format) +func (t InstrumentConfigurationGet) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentConfigurationGet from hex string (Canton MCMS format) +func (t *InstrumentConfigurationGet) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// InstrumentConfigurationGetResult is a Record type +type InstrumentConfigurationGetResult struct { + InstrumentConfiguration InstrumentConfiguration `json:"instrumentConfiguration"` +} + +// ToMap converts InstrumentConfigurationGetResult to a map for DAML arguments +func (t InstrumentConfigurationGetResult) ToMap() map[string]any { + m := make(map[string]any) + + m["instrumentConfiguration"] = model.NestedToDAMLValue(t.InstrumentConfiguration) + + return m +} + +func (t InstrumentConfigurationGetResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentConfigurationGetResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentConfigurationGetResult to hex string (Canton MCMS format) +func (t InstrumentConfigurationGetResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentConfigurationGetResult from hex string (Canton MCMS format) +func (t *InstrumentConfigurationGetResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// InstrumentConfigurationSetProviderAppRewardBeneficiaries is a Record type +type InstrumentConfigurationSetProviderAppRewardBeneficiaries struct { + ProviderAppRewardBeneficiaries *[]splice_api_featured_app_v1.AppRewardBeneficiary `json:"providerAppRewardBeneficiaries" hex:"optional"` +} + +// ToMap converts InstrumentConfigurationSetProviderAppRewardBeneficiaries to a map for DAML arguments +func (t InstrumentConfigurationSetProviderAppRewardBeneficiaries) ToMap() map[string]any { + m := make(map[string]any) + + if t.ProviderAppRewardBeneficiaries != nil { + m["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.ProviderAppRewardBeneficiaries), + } + } else { + m["providerAppRewardBeneficiaries"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t InstrumentConfigurationSetProviderAppRewardBeneficiaries) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *InstrumentConfigurationSetProviderAppRewardBeneficiaries) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes InstrumentConfigurationSetProviderAppRewardBeneficiaries to hex string (Canton MCMS format) +func (t InstrumentConfigurationSetProviderAppRewardBeneficiaries) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes InstrumentConfigurationSetProviderAppRewardBeneficiaries from hex string (Canton MCMS format) +func (t *InstrumentConfigurationSetProviderAppRewardBeneficiaries) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Lock3 is a Record type +type Lock3 struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + Locker types.PARTY `json:"locker"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Context types.TEXT `json:"context"` + Reference types.TEXT `json:"reference"` + Batch Batch `json:"batch"` +} + +// ToMap converts Lock3 to a map for DAML arguments +func (t Lock3) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["locker"] = t.Locker.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["context"] = string(t.Context) + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t Lock3) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Lock3) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Lock3 to hex string (Canton MCMS format) +func (t Lock3) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Lock3 from hex string (Canton MCMS format) +func (t *Lock3) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOffer is a Template type +type LockOffer struct { + Lock Lock3 `json:"lock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t LockOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t LockOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t LockOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t LockOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t LockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOffer to hex string (Canton MCMS format) +func (t LockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOffer from hex string (Canton MCMS format) +func (t *LockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for LockOffer + +// LockOfferClean exercises the LockOffer_Clean choice on this LockOffer contract +// This method uses the package name in the template ID +func (t LockOffer) LockOfferClean(contractID string, args LockOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Clean", + Arguments: argsToMap(args), + } +} + +// LockOfferCleanWithPackageID exercises the LockOffer_Clean choice using the provided package ID instead of package name +func (t LockOffer) LockOfferCleanWithPackageID(contractID string, packageID string, args LockOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Clean", + Arguments: argsToMap(args), + } +} + +// LockOfferAccept exercises the LockOffer_Accept choice on this LockOffer contract +// This method uses the package name in the template ID +func (t LockOffer) LockOfferAccept(contractID string, args LockOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Accept", + Arguments: argsToMap(args), + } +} + +// LockOfferAcceptWithPackageID exercises the LockOffer_Accept choice using the provided package ID instead of package name +func (t LockOffer) LockOfferAcceptWithPackageID(contractID string, packageID string, args LockOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Accept", + Arguments: argsToMap(args), + } +} + +// LockOfferReject exercises the LockOffer_Reject choice on this LockOffer contract +// This method uses the package name in the template ID +func (t LockOffer) LockOfferReject(contractID string, args LockOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Reject", + Arguments: argsToMap(args), + } +} + +// LockOfferRejectWithPackageID exercises the LockOffer_Reject choice using the provided package ID instead of package name +func (t LockOffer) LockOfferRejectWithPackageID(contractID string, packageID string, args LockOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Reject", + Arguments: argsToMap(args), + } +} + +// LockOfferCancel exercises the LockOffer_Cancel choice on this LockOffer contract +// This method uses the package name in the template ID +func (t LockOffer) LockOfferCancel(contractID string, args LockOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// LockOfferCancelWithPackageID exercises the LockOffer_Cancel choice using the provided package ID instead of package name +func (t LockOffer) LockOfferCancelWithPackageID(contractID string, packageID string, args LockOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "LockOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this LockOffer contract +// This method uses the package name in the template ID +func (t LockOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t LockOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// LockOfferAccept is a Record type +type LockOfferAccept struct { +} + +// ToMap converts LockOfferAccept to a map for DAML arguments +func (t LockOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t LockOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferAccept to hex string (Canton MCMS format) +func (t LockOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferAccept from hex string (Canton MCMS format) +func (t *LockOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferAcceptResult is a Record type +type LockOfferAcceptResult struct { + AcceptedLockCid types.CONTRACT_ID `json:"acceptedLockCid"` +} + +// ToMap converts LockOfferAcceptResult to a map for DAML arguments +func (t LockOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedLockCid"] = model.NestedToDAMLValue(t.AcceptedLockCid) + + return m +} + +func (t LockOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferAcceptResult to hex string (Canton MCMS format) +func (t LockOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferAcceptResult from hex string (Canton MCMS format) +func (t *LockOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferCancel is a Record type +type LockOfferCancel struct { +} + +// ToMap converts LockOfferCancel to a map for DAML arguments +func (t LockOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t LockOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferCancel to hex string (Canton MCMS format) +func (t LockOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferCancel from hex string (Canton MCMS format) +func (t *LockOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferCancelResult is a Record type +type LockOfferCancelResult struct { +} + +// ToMap converts LockOfferCancelResult to a map for DAML arguments +func (t LockOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t LockOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferCancelResult to hex string (Canton MCMS format) +func (t LockOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferCancelResult from hex string (Canton MCMS format) +func (t *LockOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferClean is a Record type +type LockOfferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts LockOfferClean to a map for DAML arguments +func (t LockOfferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t LockOfferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferClean to hex string (Canton MCMS format) +func (t LockOfferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferClean from hex string (Canton MCMS format) +func (t *LockOfferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferReject is a Record type +type LockOfferReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts LockOfferReject to a map for DAML arguments +func (t LockOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t LockOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferReject to hex string (Canton MCMS format) +func (t LockOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferReject from hex string (Canton MCMS format) +func (t *LockOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockOfferRejectResult is a Record type +type LockOfferRejectResult struct { + RejectedLockCid types.CONTRACT_ID `json:"rejectedLockCid"` +} + +// ToMap converts LockOfferRejectResult to a map for DAML arguments +func (t LockOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedLockCid"] = model.NestedToDAMLValue(t.RejectedLockCid) + + return m +} + +func (t LockOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockOfferRejectResult to hex string (Canton MCMS format) +func (t LockOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockOfferRejectResult from hex string (Canton MCMS format) +func (t *LockOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequest is a Template type +type LockRequest struct { + Lock Lock3 `json:"lock"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t LockRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t LockRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t LockRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t LockRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t LockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequest to hex string (Canton MCMS format) +func (t LockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequest from hex string (Canton MCMS format) +func (t *LockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for LockRequest + +// LockRequestClean exercises the LockRequest_Clean choice on this LockRequest contract +// This method uses the package name in the template ID +func (t LockRequest) LockRequestClean(contractID string, args LockRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Clean", + Arguments: argsToMap(args), + } +} + +// LockRequestCleanWithPackageID exercises the LockRequest_Clean choice using the provided package ID instead of package name +func (t LockRequest) LockRequestCleanWithPackageID(contractID string, packageID string, args LockRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Clean", + Arguments: argsToMap(args), + } +} + +// LockRequestAccept exercises the LockRequest_Accept choice on this LockRequest contract +// This method uses the package name in the template ID +func (t LockRequest) LockRequestAccept(contractID string, args LockRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Accept", + Arguments: argsToMap(args), + } +} + +// LockRequestAcceptWithPackageID exercises the LockRequest_Accept choice using the provided package ID instead of package name +func (t LockRequest) LockRequestAcceptWithPackageID(contractID string, packageID string, args LockRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Accept", + Arguments: argsToMap(args), + } +} + +// LockRequestReject exercises the LockRequest_Reject choice on this LockRequest contract +// This method uses the package name in the template ID +func (t LockRequest) LockRequestReject(contractID string, args LockRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Reject", + Arguments: argsToMap(args), + } +} + +// LockRequestRejectWithPackageID exercises the LockRequest_Reject choice using the provided package ID instead of package name +func (t LockRequest) LockRequestRejectWithPackageID(contractID string, packageID string, args LockRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Reject", + Arguments: argsToMap(args), + } +} + +// LockRequestCancel exercises the LockRequest_Cancel choice on this LockRequest contract +// This method uses the package name in the template ID +func (t LockRequest) LockRequestCancel(contractID string, args LockRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// LockRequestCancelWithPackageID exercises the LockRequest_Cancel choice using the provided package ID instead of package name +func (t LockRequest) LockRequestCancelWithPackageID(contractID string, packageID string, args LockRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "LockRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this LockRequest contract +// This method uses the package name in the template ID +func (t LockRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t LockRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "LockRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// LockRequestAccept is a Record type +type LockRequestAccept struct { + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// ToMap converts LockRequestAccept to a map for DAML arguments +func (t LockRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingLabel"] = string(t.HoldingLabel) + + return m +} + +func (t LockRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestAccept to hex string (Canton MCMS format) +func (t LockRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestAccept from hex string (Canton MCMS format) +func (t *LockRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestAcceptResult is a Record type +type LockRequestAcceptResult struct { + AcceptedLockCid types.CONTRACT_ID `json:"acceptedLockCid"` +} + +// ToMap converts LockRequestAcceptResult to a map for DAML arguments +func (t LockRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedLockCid"] = model.NestedToDAMLValue(t.AcceptedLockCid) + + return m +} + +func (t LockRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestAcceptResult to hex string (Canton MCMS format) +func (t LockRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestAcceptResult from hex string (Canton MCMS format) +func (t *LockRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestCancel is a Record type +type LockRequestCancel struct { +} + +// ToMap converts LockRequestCancel to a map for DAML arguments +func (t LockRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t LockRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestCancel to hex string (Canton MCMS format) +func (t LockRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestCancel from hex string (Canton MCMS format) +func (t *LockRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestCancelResult is a Record type +type LockRequestCancelResult struct { +} + +// ToMap converts LockRequestCancelResult to a map for DAML arguments +func (t LockRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t LockRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestCancelResult to hex string (Canton MCMS format) +func (t LockRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestCancelResult from hex string (Canton MCMS format) +func (t *LockRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestClean is a Record type +type LockRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts LockRequestClean to a map for DAML arguments +func (t LockRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t LockRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestClean to hex string (Canton MCMS format) +func (t LockRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestClean from hex string (Canton MCMS format) +func (t *LockRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestReject is a Record type +type LockRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts LockRequestReject to a map for DAML arguments +func (t LockRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t LockRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestReject to hex string (Canton MCMS format) +func (t LockRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestReject from hex string (Canton MCMS format) +func (t *LockRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// LockRequestRejectResult is a Record type +type LockRequestRejectResult struct { + RejectedLockCid types.CONTRACT_ID `json:"rejectedLockCid"` +} + +// ToMap converts LockRequestRejectResult to a map for DAML arguments +func (t LockRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedLockCid"] = model.NestedToDAMLValue(t.RejectedLockCid) + + return m +} + +func (t LockRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *LockRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes LockRequestRejectResult to hex string (Canton MCMS format) +func (t LockRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes LockRequestRejectResult from hex string (Canton MCMS format) +func (t *LockRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Mint is a Record type +type Mint struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Holder types.PARTY `json:"holder"` + Reference types.TEXT `json:"reference"` + Batch Batch `json:"batch"` +} + +// ToMap converts Mint to a map for DAML arguments +func (t Mint) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["holder"] = t.Holder.ToMap() + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t Mint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Mint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Mint to hex string (Canton MCMS format) +func (t Mint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Mint from hex string (Canton MCMS format) +func (t *Mint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOffer is a Template type +type MintOffer struct { + Mint Mint `json:"mint"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t MintOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t MintOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t MintOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t MintOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t MintOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOffer to hex string (Canton MCMS format) +func (t MintOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOffer from hex string (Canton MCMS format) +func (t *MintOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for MintOffer + +// MintOfferClean exercises the MintOffer_Clean choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferClean(contractID string, args MintOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Clean", + Arguments: argsToMap(args), + } +} + +// MintOfferCleanWithPackageID exercises the MintOffer_Clean choice using the provided package ID instead of package name +func (t MintOffer) MintOfferCleanWithPackageID(contractID string, packageID string, args MintOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Clean", + Arguments: argsToMap(args), + } +} + +// MintOfferAccept exercises the MintOffer_Accept choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferAccept(contractID string, args MintOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Accept", + Arguments: argsToMap(args), + } +} + +// MintOfferAcceptWithPackageID exercises the MintOffer_Accept choice using the provided package ID instead of package name +func (t MintOffer) MintOfferAcceptWithPackageID(contractID string, packageID string, args MintOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Accept", + Arguments: argsToMap(args), + } +} + +// MintOfferReject exercises the MintOffer_Reject choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferReject(contractID string, args MintOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Reject", + Arguments: argsToMap(args), + } +} + +// MintOfferRejectWithPackageID exercises the MintOffer_Reject choice using the provided package ID instead of package name +func (t MintOffer) MintOfferRejectWithPackageID(contractID string, packageID string, args MintOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Reject", + Arguments: argsToMap(args), + } +} + +// MintOfferCancel exercises the MintOffer_Cancel choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) MintOfferCancel(contractID string, args MintOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// MintOfferCancelWithPackageID exercises the MintOffer_Cancel choice using the provided package ID instead of package name +func (t MintOffer) MintOfferCancelWithPackageID(contractID string, packageID string, args MintOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "MintOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this MintOffer contract +// This method uses the package name in the template ID +func (t MintOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t MintOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// MintOfferAccept is a Record type +type MintOfferAccept struct { + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// ToMap converts MintOfferAccept to a map for DAML arguments +func (t MintOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingLabel"] = string(t.HoldingLabel) + + return m +} + +func (t MintOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferAccept to hex string (Canton MCMS format) +func (t MintOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferAccept from hex string (Canton MCMS format) +func (t *MintOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferAcceptResult is a Record type +type MintOfferAcceptResult struct { + AcceptedMintCid types.CONTRACT_ID `json:"acceptedMintCid"` +} + +// ToMap converts MintOfferAcceptResult to a map for DAML arguments +func (t MintOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedMintCid"] = model.NestedToDAMLValue(t.AcceptedMintCid) + + return m +} + +func (t MintOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferAcceptResult to hex string (Canton MCMS format) +func (t MintOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferAcceptResult from hex string (Canton MCMS format) +func (t *MintOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferCancel is a Record type +type MintOfferCancel struct { +} + +// ToMap converts MintOfferCancel to a map for DAML arguments +func (t MintOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferCancel to hex string (Canton MCMS format) +func (t MintOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferCancel from hex string (Canton MCMS format) +func (t *MintOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferCancelResult is a Record type +type MintOfferCancelResult struct { +} + +// ToMap converts MintOfferCancelResult to a map for DAML arguments +func (t MintOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferCancelResult to hex string (Canton MCMS format) +func (t MintOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferCancelResult from hex string (Canton MCMS format) +func (t *MintOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferClean is a Record type +type MintOfferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts MintOfferClean to a map for DAML arguments +func (t MintOfferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t MintOfferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferClean to hex string (Canton MCMS format) +func (t MintOfferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferClean from hex string (Canton MCMS format) +func (t *MintOfferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferReject is a Record type +type MintOfferReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts MintOfferReject to a map for DAML arguments +func (t MintOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t MintOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferReject to hex string (Canton MCMS format) +func (t MintOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferReject from hex string (Canton MCMS format) +func (t *MintOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintOfferRejectResult is a Record type +type MintOfferRejectResult struct { + RejectedMintCid types.CONTRACT_ID `json:"rejectedMintCid"` +} + +// ToMap converts MintOfferRejectResult to a map for DAML arguments +func (t MintOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedMintCid"] = model.NestedToDAMLValue(t.RejectedMintCid) + + return m +} + +func (t MintOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintOfferRejectResult to hex string (Canton MCMS format) +func (t MintOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintOfferRejectResult from hex string (Canton MCMS format) +func (t *MintOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequest is a Template type +type MintRequest struct { + Mint Mint `json:"mint"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t MintRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t MintRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t MintRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t MintRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t MintRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequest to hex string (Canton MCMS format) +func (t MintRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequest from hex string (Canton MCMS format) +func (t *MintRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for MintRequest + +// MintRequestClean exercises the MintRequest_Clean choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestClean(contractID string, args MintRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Clean", + Arguments: argsToMap(args), + } +} + +// MintRequestCleanWithPackageID exercises the MintRequest_Clean choice using the provided package ID instead of package name +func (t MintRequest) MintRequestCleanWithPackageID(contractID string, packageID string, args MintRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Clean", + Arguments: argsToMap(args), + } +} + +// MintRequestAccept exercises the MintRequest_Accept choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestAccept(contractID string, args MintRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Accept", + Arguments: argsToMap(args), + } +} + +// MintRequestAcceptWithPackageID exercises the MintRequest_Accept choice using the provided package ID instead of package name +func (t MintRequest) MintRequestAcceptWithPackageID(contractID string, packageID string, args MintRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Accept", + Arguments: argsToMap(args), + } +} + +// MintRequestReject exercises the MintRequest_Reject choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestReject(contractID string, args MintRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Reject", + Arguments: argsToMap(args), + } +} + +// MintRequestRejectWithPackageID exercises the MintRequest_Reject choice using the provided package ID instead of package name +func (t MintRequest) MintRequestRejectWithPackageID(contractID string, packageID string, args MintRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Reject", + Arguments: argsToMap(args), + } +} + +// MintRequestCancel exercises the MintRequest_Cancel choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) MintRequestCancel(contractID string, args MintRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// MintRequestCancelWithPackageID exercises the MintRequest_Cancel choice using the provided package ID instead of package name +func (t MintRequest) MintRequestCancelWithPackageID(contractID string, packageID string, args MintRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "MintRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this MintRequest contract +// This method uses the package name in the template ID +func (t MintRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t MintRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "MintRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// MintRequestAccept is a Record type +type MintRequestAccept struct { +} + +// ToMap converts MintRequestAccept to a map for DAML arguments +func (t MintRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestAccept to hex string (Canton MCMS format) +func (t MintRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestAccept from hex string (Canton MCMS format) +func (t *MintRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestAcceptResult is a Record type +type MintRequestAcceptResult struct { + AcceptedMintCid types.CONTRACT_ID `json:"acceptedMintCid"` +} + +// ToMap converts MintRequestAcceptResult to a map for DAML arguments +func (t MintRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedMintCid"] = model.NestedToDAMLValue(t.AcceptedMintCid) + + return m +} + +func (t MintRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestAcceptResult to hex string (Canton MCMS format) +func (t MintRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestAcceptResult from hex string (Canton MCMS format) +func (t *MintRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestCancel is a Record type +type MintRequestCancel struct { +} + +// ToMap converts MintRequestCancel to a map for DAML arguments +func (t MintRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestCancel to hex string (Canton MCMS format) +func (t MintRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestCancel from hex string (Canton MCMS format) +func (t *MintRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestCancelResult is a Record type +type MintRequestCancelResult struct { +} + +// ToMap converts MintRequestCancelResult to a map for DAML arguments +func (t MintRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t MintRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestCancelResult to hex string (Canton MCMS format) +func (t MintRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestCancelResult from hex string (Canton MCMS format) +func (t *MintRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestClean is a Record type +type MintRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts MintRequestClean to a map for DAML arguments +func (t MintRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t MintRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestClean to hex string (Canton MCMS format) +func (t MintRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestClean from hex string (Canton MCMS format) +func (t *MintRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestReject is a Record type +type MintRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts MintRequestReject to a map for DAML arguments +func (t MintRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t MintRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestReject to hex string (Canton MCMS format) +func (t MintRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestReject from hex string (Canton MCMS format) +func (t *MintRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MintRequestRejectResult is a Record type +type MintRequestRejectResult struct { + RejectedMintCid types.CONTRACT_ID `json:"rejectedMintCid"` +} + +// ToMap converts MintRequestRejectResult to a map for DAML arguments +func (t MintRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedMintCid"] = model.NestedToDAMLValue(t.RejectedMintCid) + + return m +} + +func (t MintRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *MintRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes MintRequestRejectResult to hex string (Canton MCMS format) +func (t MintRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes MintRequestRejectResult from hex string (Canton MCMS format) +func (t *MintRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedBurn is a Template type +type RejectedBurn struct { + Burn Burn `json:"burn"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedBurn) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "RejectedBurn") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedBurn) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "RejectedBurn") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedBurn) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedBurn) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["burn"] = model.NestedToDAMLValue(t.Burn) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedBurn) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurn) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurn to hex string (Canton MCMS format) +func (t RejectedBurn) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurn from hex string (Canton MCMS format) +func (t *RejectedBurn) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedBurn + +// RejectedBurnClean exercises the RejectedBurn_Clean choice on this RejectedBurn contract +// This method uses the package name in the template ID +func (t RejectedBurn) RejectedBurnClean(contractID string, args RejectedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedBurnCleanWithPackageID exercises the RejectedBurn_Clean choice using the provided package ID instead of package name +func (t RejectedBurn) RejectedBurnCleanWithPackageID(contractID string, packageID string, args RejectedBurnClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedBurnDelete exercises the RejectedBurn_Delete choice on this RejectedBurn contract +// This method uses the package name in the template ID +func (t RejectedBurn) RejectedBurnDelete(contractID string, args RejectedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedBurnDeleteWithPackageID exercises the RejectedBurn_Delete choice using the provided package ID instead of package name +func (t RejectedBurn) RejectedBurnDeleteWithPackageID(contractID string, packageID string, args RejectedBurnDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "RejectedBurn_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedBurn contract +// This method uses the package name in the template ID +func (t RejectedBurn) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedBurn) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Burn", "RejectedBurn"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedBurnClean is a Record type +type RejectedBurnClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedBurnClean to a map for DAML arguments +func (t RejectedBurnClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedBurnClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurnClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurnClean to hex string (Canton MCMS format) +func (t RejectedBurnClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurnClean from hex string (Canton MCMS format) +func (t *RejectedBurnClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedBurnDelete is a Record type +type RejectedBurnDelete struct { +} + +// ToMap converts RejectedBurnDelete to a map for DAML arguments +func (t RejectedBurnDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedBurnDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurnDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurnDelete to hex string (Canton MCMS format) +func (t RejectedBurnDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurnDelete from hex string (Canton MCMS format) +func (t *RejectedBurnDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedBurnDeleteResult is a Record type +type RejectedBurnDeleteResult struct { +} + +// ToMap converts RejectedBurnDeleteResult to a map for DAML arguments +func (t RejectedBurnDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedBurnDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedBurnDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedBurnDeleteResult to hex string (Canton MCMS format) +func (t RejectedBurnDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedBurnDeleteResult from hex string (Canton MCMS format) +func (t *RejectedBurnDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedForceTransfer is a Template type +type RejectedForceTransfer struct { + ForceTransfer ForceTransfer `json:"forceTransfer"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedForceTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedForceTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedForceTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedForceTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["forceTransfer"] = model.NestedToDAMLValue(t.ForceTransfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedForceTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedForceTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedForceTransfer to hex string (Canton MCMS format) +func (t RejectedForceTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedForceTransfer from hex string (Canton MCMS format) +func (t *RejectedForceTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedForceTransfer + +// RejectedForceTransferDelete exercises the RejectedForceTransfer_Delete choice on this RejectedForceTransfer contract +// This method uses the package name in the template ID +func (t RejectedForceTransfer) RejectedForceTransferDelete(contractID string, args RejectedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer"), + ContractID: contractID, + Choice: "RejectedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedForceTransferDeleteWithPackageID exercises the RejectedForceTransfer_Delete choice using the provided package ID instead of package name +func (t RejectedForceTransfer) RejectedForceTransferDeleteWithPackageID(contractID string, packageID string, args RejectedForceTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer"), + ContractID: contractID, + Choice: "RejectedForceTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedForceTransfer contract +// This method uses the package name in the template ID +func (t RejectedForceTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedForceTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.ForceTransfer", "RejectedForceTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedForceTransferDelete is a Record type +type RejectedForceTransferDelete struct { +} + +// ToMap converts RejectedForceTransferDelete to a map for DAML arguments +func (t RejectedForceTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedForceTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedForceTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedForceTransferDelete to hex string (Canton MCMS format) +func (t RejectedForceTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedForceTransferDelete from hex string (Canton MCMS format) +func (t *RejectedForceTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedForceTransferDeleteResult is a Record type +type RejectedForceTransferDeleteResult struct { +} + +// ToMap converts RejectedForceTransferDeleteResult to a map for DAML arguments +func (t RejectedForceTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedForceTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedForceTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedForceTransferDeleteResult to hex string (Canton MCMS format) +func (t RejectedForceTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedForceTransferDeleteResult from hex string (Canton MCMS format) +func (t *RejectedForceTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedLock is a Template type +type RejectedLock struct { + Lock Lock3 `json:"lock"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedLock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "RejectedLock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedLock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "RejectedLock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedLock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedLock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["lock"] = model.NestedToDAMLValue(t.Lock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedLock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedLock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedLock to hex string (Canton MCMS format) +func (t RejectedLock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedLock from hex string (Canton MCMS format) +func (t *RejectedLock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedLock + +// RejectedLockClean exercises the RejectedLock_Clean choice on this RejectedLock contract +// This method uses the package name in the template ID +func (t RejectedLock) RejectedLockClean(contractID string, args RejectedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "RejectedLock_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedLockCleanWithPackageID exercises the RejectedLock_Clean choice using the provided package ID instead of package name +func (t RejectedLock) RejectedLockCleanWithPackageID(contractID string, packageID string, args RejectedLockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "RejectedLock_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedLockDelete exercises the RejectedLock_Delete choice on this RejectedLock contract +// This method uses the package name in the template ID +func (t RejectedLock) RejectedLockDelete(contractID string, args RejectedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "RejectedLock_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedLockDeleteWithPackageID exercises the RejectedLock_Delete choice using the provided package ID instead of package name +func (t RejectedLock) RejectedLockDeleteWithPackageID(contractID string, packageID string, args RejectedLockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "RejectedLock_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedLock contract +// This method uses the package name in the template ID +func (t RejectedLock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedLock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Lock", "RejectedLock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedLockClean is a Record type +type RejectedLockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedLockClean to a map for DAML arguments +func (t RejectedLockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedLockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedLockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedLockClean to hex string (Canton MCMS format) +func (t RejectedLockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedLockClean from hex string (Canton MCMS format) +func (t *RejectedLockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedLockDelete is a Record type +type RejectedLockDelete struct { +} + +// ToMap converts RejectedLockDelete to a map for DAML arguments +func (t RejectedLockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedLockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedLockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedLockDelete to hex string (Canton MCMS format) +func (t RejectedLockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedLockDelete from hex string (Canton MCMS format) +func (t *RejectedLockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedLockDeleteResult is a Record type +type RejectedLockDeleteResult struct { +} + +// ToMap converts RejectedLockDeleteResult to a map for DAML arguments +func (t RejectedLockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedLockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedLockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedLockDeleteResult to hex string (Canton MCMS format) +func (t RejectedLockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedLockDeleteResult from hex string (Canton MCMS format) +func (t *RejectedLockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedMint is a Template type +type RejectedMint struct { + Mint Mint `json:"mint"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedMint) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "RejectedMint") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedMint) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "RejectedMint") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedMint) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedMint) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["mint"] = model.NestedToDAMLValue(t.Mint) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedMint) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMint) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMint to hex string (Canton MCMS format) +func (t RejectedMint) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMint from hex string (Canton MCMS format) +func (t *RejectedMint) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedMint + +// RejectedMintClean exercises the RejectedMint_Clean choice on this RejectedMint contract +// This method uses the package name in the template ID +func (t RejectedMint) RejectedMintClean(contractID string, args RejectedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedMintCleanWithPackageID exercises the RejectedMint_Clean choice using the provided package ID instead of package name +func (t RejectedMint) RejectedMintCleanWithPackageID(contractID string, packageID string, args RejectedMintClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedMintDelete exercises the RejectedMint_Delete choice on this RejectedMint contract +// This method uses the package name in the template ID +func (t RejectedMint) RejectedMintDelete(contractID string, args RejectedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedMintDeleteWithPackageID exercises the RejectedMint_Delete choice using the provided package ID instead of package name +func (t RejectedMint) RejectedMintDeleteWithPackageID(contractID string, packageID string, args RejectedMintDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "RejectedMint_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedMint contract +// This method uses the package name in the template ID +func (t RejectedMint) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedMint) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Mint", "RejectedMint"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedMintClean is a Record type +type RejectedMintClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedMintClean to a map for DAML arguments +func (t RejectedMintClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedMintClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMintClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMintClean to hex string (Canton MCMS format) +func (t RejectedMintClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMintClean from hex string (Canton MCMS format) +func (t *RejectedMintClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedMintDelete is a Record type +type RejectedMintDelete struct { +} + +// ToMap converts RejectedMintDelete to a map for DAML arguments +func (t RejectedMintDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedMintDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMintDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMintDelete to hex string (Canton MCMS format) +func (t RejectedMintDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMintDelete from hex string (Canton MCMS format) +func (t *RejectedMintDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedMintDeleteResult is a Record type +type RejectedMintDeleteResult struct { +} + +// ToMap converts RejectedMintDeleteResult to a map for DAML arguments +func (t RejectedMintDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedMintDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedMintDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedMintDeleteResult to hex string (Canton MCMS format) +func (t RejectedMintDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedMintDeleteResult from hex string (Canton MCMS format) +func (t *RejectedMintDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedTransfer is a Template type +type RejectedTransfer struct { + Transfer Transfer2 `json:"transfer"` + Reason types.TEXT `json:"reason"` + Observers *types.SET `json:"observers" hex:"optional"` + OperatorIsObserver *types.BOOL `json:"operatorIsObserver" hex:"optional"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedTransfer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedTransfer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedTransfer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedTransfer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + if t.Observers != nil { + args["observers"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.Observers), + } + } else { + args["observers"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.OperatorIsObserver != nil { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": bool(*t.OperatorIsObserver), + } + } else { + args["operatorIsObserver"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedTransfer to hex string (Canton MCMS format) +func (t RejectedTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedTransfer from hex string (Canton MCMS format) +func (t *RejectedTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedTransfer + +// RejectedTransferDelete exercises the RejectedTransfer_Delete choice on this RejectedTransfer contract +// This method uses the package name in the template ID +func (t RejectedTransfer) RejectedTransferDelete(contractID string, args RejectedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer"), + ContractID: contractID, + Choice: "RejectedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedTransferDeleteWithPackageID exercises the RejectedTransfer_Delete choice using the provided package ID instead of package name +func (t RejectedTransfer) RejectedTransferDeleteWithPackageID(contractID string, packageID string, args RejectedTransferDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer"), + ContractID: contractID, + Choice: "RejectedTransfer_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedTransfer contract +// This method uses the package name in the template ID +func (t RejectedTransfer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedTransfer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "RejectedTransfer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedTransferDelete is a Record type +type RejectedTransferDelete struct { +} + +// ToMap converts RejectedTransferDelete to a map for DAML arguments +func (t RejectedTransferDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedTransferDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedTransferDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedTransferDelete to hex string (Canton MCMS format) +func (t RejectedTransferDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedTransferDelete from hex string (Canton MCMS format) +func (t *RejectedTransferDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedTransferDeleteResult is a Record type +type RejectedTransferDeleteResult struct { +} + +// ToMap converts RejectedTransferDeleteResult to a map for DAML arguments +func (t RejectedTransferDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedTransferDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedTransferDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedTransferDeleteResult to hex string (Canton MCMS format) +func (t RejectedTransferDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedTransferDeleteResult from hex string (Canton MCMS format) +func (t *RejectedTransferDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedUnlock is a Template type +type RejectedUnlock struct { + Unlock Unlock `json:"unlock"` + Reason types.TEXT `json:"reason"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t RejectedUnlock) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t RejectedUnlock) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t RejectedUnlock) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t RejectedUnlock) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["reason"] = string(t.Reason) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t RejectedUnlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedUnlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedUnlock to hex string (Canton MCMS format) +func (t RejectedUnlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedUnlock from hex string (Canton MCMS format) +func (t *RejectedUnlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for RejectedUnlock + +// RejectedUnlockClean exercises the RejectedUnlock_Clean choice on this RejectedUnlock contract +// This method uses the package name in the template ID +func (t RejectedUnlock) RejectedUnlockClean(contractID string, args RejectedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "RejectedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedUnlockCleanWithPackageID exercises the RejectedUnlock_Clean choice using the provided package ID instead of package name +func (t RejectedUnlock) RejectedUnlockCleanWithPackageID(contractID string, packageID string, args RejectedUnlockClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "RejectedUnlock_Clean", + Arguments: argsToMap(args), + } +} + +// RejectedUnlockDelete exercises the RejectedUnlock_Delete choice on this RejectedUnlock contract +// This method uses the package name in the template ID +func (t RejectedUnlock) RejectedUnlockDelete(contractID string, args RejectedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "RejectedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// RejectedUnlockDeleteWithPackageID exercises the RejectedUnlock_Delete choice using the provided package ID instead of package name +func (t RejectedUnlock) RejectedUnlockDeleteWithPackageID(contractID string, packageID string, args RejectedUnlockDelete) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "RejectedUnlock_Delete", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this RejectedUnlock contract +// This method uses the package name in the template ID +func (t RejectedUnlock) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t RejectedUnlock) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "RejectedUnlock"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// RejectedUnlockClean is a Record type +type RejectedUnlockClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts RejectedUnlockClean to a map for DAML arguments +func (t RejectedUnlockClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t RejectedUnlockClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedUnlockClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedUnlockClean to hex string (Canton MCMS format) +func (t RejectedUnlockClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedUnlockClean from hex string (Canton MCMS format) +func (t *RejectedUnlockClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedUnlockDelete is a Record type +type RejectedUnlockDelete struct { +} + +// ToMap converts RejectedUnlockDelete to a map for DAML arguments +func (t RejectedUnlockDelete) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedUnlockDelete) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedUnlockDelete) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedUnlockDelete to hex string (Canton MCMS format) +func (t RejectedUnlockDelete) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedUnlockDelete from hex string (Canton MCMS format) +func (t *RejectedUnlockDelete) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// RejectedUnlockDeleteResult is a Record type +type RejectedUnlockDeleteResult struct { +} + +// ToMap converts RejectedUnlockDeleteResult to a map for DAML arguments +func (t RejectedUnlockDeleteResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t RejectedUnlockDeleteResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *RejectedUnlockDeleteResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes RejectedUnlockDeleteResult to hex string (Canton MCMS format) +func (t RejectedUnlockDeleteResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes RejectedUnlockDeleteResult from hex string (Canton MCMS format) +func (t *RejectedUnlockDeleteResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Transfer2 is a Record type +type Transfer2 struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Sender types.PARTY `json:"sender"` + Receiver types.PARTY `json:"receiver"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Reference types.TEXT `json:"reference"` + Batch Batch `json:"batch"` +} + +// ToMap converts Transfer2 to a map for DAML arguments +func (t Transfer2) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["sender"] = t.Sender.ToMap() + + m["receiver"] = t.Receiver.ToMap() + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t Transfer2) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Transfer2) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Transfer2 to hex string (Canton MCMS format) +func (t Transfer2) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Transfer2 from hex string (Canton MCMS format) +func (t *Transfer2) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOffer is a Template type +type TransferOffer struct { + Transfer Transfer2 `json:"transfer"` + SenderLabel types.TEXT `json:"senderLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t TransferOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t TransferOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t TransferOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t TransferOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["senderLabel"] = string(t.SenderLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t TransferOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOffer to hex string (Canton MCMS format) +func (t TransferOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOffer from hex string (Canton MCMS format) +func (t *TransferOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for TransferOffer + +// TransferOfferClean exercises the TransferOffer_Clean choice on this TransferOffer contract +// This method uses the package name in the template ID +func (t TransferOffer) TransferOfferClean(contractID string, args TransferOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Clean", + Arguments: argsToMap(args), + } +} + +// TransferOfferCleanWithPackageID exercises the TransferOffer_Clean choice using the provided package ID instead of package name +func (t TransferOffer) TransferOfferCleanWithPackageID(contractID string, packageID string, args TransferOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Clean", + Arguments: argsToMap(args), + } +} + +// TransferOfferAccept exercises the TransferOffer_Accept choice on this TransferOffer contract +// This method uses the package name in the template ID +func (t TransferOffer) TransferOfferAccept(contractID string, args TransferOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Accept", + Arguments: argsToMap(args), + } +} + +// TransferOfferAcceptWithPackageID exercises the TransferOffer_Accept choice using the provided package ID instead of package name +func (t TransferOffer) TransferOfferAcceptWithPackageID(contractID string, packageID string, args TransferOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Accept", + Arguments: argsToMap(args), + } +} + +// TransferOfferReject exercises the TransferOffer_Reject choice on this TransferOffer contract +// This method uses the package name in the template ID +func (t TransferOffer) TransferOfferReject(contractID string, args TransferOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Reject", + Arguments: argsToMap(args), + } +} + +// TransferOfferRejectWithPackageID exercises the TransferOffer_Reject choice using the provided package ID instead of package name +func (t TransferOffer) TransferOfferRejectWithPackageID(contractID string, packageID string, args TransferOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Reject", + Arguments: argsToMap(args), + } +} + +// TransferOfferCancel exercises the TransferOffer_Cancel choice on this TransferOffer contract +// This method uses the package name in the template ID +func (t TransferOffer) TransferOfferCancel(contractID string, args TransferOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// TransferOfferCancelWithPackageID exercises the TransferOffer_Cancel choice using the provided package ID instead of package name +func (t TransferOffer) TransferOfferCancelWithPackageID(contractID string, packageID string, args TransferOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "TransferOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this TransferOffer contract +// This method uses the package name in the template ID +func (t TransferOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t TransferOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferOfferAccept is a Record type +type TransferOfferAccept struct { + ReceiverLabel types.TEXT `json:"receiverLabel"` +} + +// ToMap converts TransferOfferAccept to a map for DAML arguments +func (t TransferOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["receiverLabel"] = string(t.ReceiverLabel) + + return m +} + +func (t TransferOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferAccept to hex string (Canton MCMS format) +func (t TransferOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferAccept from hex string (Canton MCMS format) +func (t *TransferOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferAcceptResult is a Record type +type TransferOfferAcceptResult struct { + AcceptedTransferCid types.CONTRACT_ID `json:"acceptedTransferCid"` +} + +// ToMap converts TransferOfferAcceptResult to a map for DAML arguments +func (t TransferOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedTransferCid"] = model.NestedToDAMLValue(t.AcceptedTransferCid) + + return m +} + +func (t TransferOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferAcceptResult to hex string (Canton MCMS format) +func (t TransferOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferAcceptResult from hex string (Canton MCMS format) +func (t *TransferOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferCancel is a Record type +type TransferOfferCancel struct { +} + +// ToMap converts TransferOfferCancel to a map for DAML arguments +func (t TransferOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t TransferOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferCancel to hex string (Canton MCMS format) +func (t TransferOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferCancel from hex string (Canton MCMS format) +func (t *TransferOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferCancelResult is a Record type +type TransferOfferCancelResult struct { +} + +// ToMap converts TransferOfferCancelResult to a map for DAML arguments +func (t TransferOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t TransferOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferCancelResult to hex string (Canton MCMS format) +func (t TransferOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferCancelResult from hex string (Canton MCMS format) +func (t *TransferOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferClean is a Record type +type TransferOfferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts TransferOfferClean to a map for DAML arguments +func (t TransferOfferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t TransferOfferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferClean to hex string (Canton MCMS format) +func (t TransferOfferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferClean from hex string (Canton MCMS format) +func (t *TransferOfferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferReject is a Record type +type TransferOfferReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts TransferOfferReject to a map for DAML arguments +func (t TransferOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t TransferOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferReject to hex string (Canton MCMS format) +func (t TransferOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferReject from hex string (Canton MCMS format) +func (t *TransferOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferOfferRejectResult is a Record type +type TransferOfferRejectResult struct { + RejectedTransferCid types.CONTRACT_ID `json:"rejectedTransferCid"` +} + +// ToMap converts TransferOfferRejectResult to a map for DAML arguments +func (t TransferOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedTransferCid"] = model.NestedToDAMLValue(t.RejectedTransferCid) + + return m +} + +func (t TransferOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferOfferRejectResult to hex string (Canton MCMS format) +func (t TransferOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferOfferRejectResult from hex string (Canton MCMS format) +func (t *TransferOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequest is a Template type +type TransferRequest struct { + Transfer Transfer2 `json:"transfer"` + ReceiverLabel types.TEXT `json:"receiverLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t TransferRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t TransferRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t TransferRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t TransferRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["transfer"] = model.NestedToDAMLValue(t.Transfer) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["receiverLabel"] = string(t.ReceiverLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t TransferRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequest to hex string (Canton MCMS format) +func (t TransferRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequest from hex string (Canton MCMS format) +func (t *TransferRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for TransferRequest + +// TransferRequestClean exercises the TransferRequest_Clean choice on this TransferRequest contract +// This method uses the package name in the template ID +func (t TransferRequest) TransferRequestClean(contractID string, args TransferRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Clean", + Arguments: argsToMap(args), + } +} + +// TransferRequestCleanWithPackageID exercises the TransferRequest_Clean choice using the provided package ID instead of package name +func (t TransferRequest) TransferRequestCleanWithPackageID(contractID string, packageID string, args TransferRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Clean", + Arguments: argsToMap(args), + } +} + +// TransferRequestAccept exercises the TransferRequest_Accept choice on this TransferRequest contract +// This method uses the package name in the template ID +func (t TransferRequest) TransferRequestAccept(contractID string, args TransferRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Accept", + Arguments: argsToMap(args), + } +} + +// TransferRequestAcceptWithPackageID exercises the TransferRequest_Accept choice using the provided package ID instead of package name +func (t TransferRequest) TransferRequestAcceptWithPackageID(contractID string, packageID string, args TransferRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Accept", + Arguments: argsToMap(args), + } +} + +// TransferRequestReject exercises the TransferRequest_Reject choice on this TransferRequest contract +// This method uses the package name in the template ID +func (t TransferRequest) TransferRequestReject(contractID string, args TransferRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Reject", + Arguments: argsToMap(args), + } +} + +// TransferRequestRejectWithPackageID exercises the TransferRequest_Reject choice using the provided package ID instead of package name +func (t TransferRequest) TransferRequestRejectWithPackageID(contractID string, packageID string, args TransferRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Reject", + Arguments: argsToMap(args), + } +} + +// TransferRequestCancel exercises the TransferRequest_Cancel choice on this TransferRequest contract +// This method uses the package name in the template ID +func (t TransferRequest) TransferRequestCancel(contractID string, args TransferRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// TransferRequestCancelWithPackageID exercises the TransferRequest_Cancel choice using the provided package ID instead of package name +func (t TransferRequest) TransferRequestCancelWithPackageID(contractID string, packageID string, args TransferRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "TransferRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this TransferRequest contract +// This method uses the package name in the template ID +func (t TransferRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t TransferRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Transfer", "TransferRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferRequestAccept is a Record type +type TransferRequestAccept struct { + SenderLabel types.TEXT `json:"senderLabel"` +} + +// ToMap converts TransferRequestAccept to a map for DAML arguments +func (t TransferRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["senderLabel"] = string(t.SenderLabel) + + return m +} + +func (t TransferRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestAccept to hex string (Canton MCMS format) +func (t TransferRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestAccept from hex string (Canton MCMS format) +func (t *TransferRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestAcceptResult is a Record type +type TransferRequestAcceptResult struct { + AcceptedTransferCid types.CONTRACT_ID `json:"acceptedTransferCid"` +} + +// ToMap converts TransferRequestAcceptResult to a map for DAML arguments +func (t TransferRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedTransferCid"] = model.NestedToDAMLValue(t.AcceptedTransferCid) + + return m +} + +func (t TransferRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestAcceptResult to hex string (Canton MCMS format) +func (t TransferRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestAcceptResult from hex string (Canton MCMS format) +func (t *TransferRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestCancel is a Record type +type TransferRequestCancel struct { +} + +// ToMap converts TransferRequestCancel to a map for DAML arguments +func (t TransferRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t TransferRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestCancel to hex string (Canton MCMS format) +func (t TransferRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestCancel from hex string (Canton MCMS format) +func (t *TransferRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestCancelResult is a Record type +type TransferRequestCancelResult struct { +} + +// ToMap converts TransferRequestCancelResult to a map for DAML arguments +func (t TransferRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t TransferRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestCancelResult to hex string (Canton MCMS format) +func (t TransferRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestCancelResult from hex string (Canton MCMS format) +func (t *TransferRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestClean is a Record type +type TransferRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts TransferRequestClean to a map for DAML arguments +func (t TransferRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t TransferRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestClean to hex string (Canton MCMS format) +func (t TransferRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestClean from hex string (Canton MCMS format) +func (t *TransferRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestReject is a Record type +type TransferRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts TransferRequestReject to a map for DAML arguments +func (t TransferRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t TransferRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestReject to hex string (Canton MCMS format) +func (t TransferRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestReject from hex string (Canton MCMS format) +func (t *TransferRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRequestRejectResult is a Record type +type TransferRequestRejectResult struct { + RejectedTransferCid types.CONTRACT_ID `json:"rejectedTransferCid"` +} + +// ToMap converts TransferRequestRejectResult to a map for DAML arguments +func (t TransferRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedTransferCid"] = model.NestedToDAMLValue(t.RejectedTransferCid) + + return m +} + +func (t TransferRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRequestRejectResult to hex string (Canton MCMS format) +func (t TransferRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRequestRejectResult from hex string (Canton MCMS format) +func (t *TransferRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRule is a Template type +type TransferRule struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t TransferRule) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t TransferRule) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t TransferRule) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t TransferRule) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["operator"] = t.Operator.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["provider"] = t.Provider.ToMap() + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["registrar"] = t.Registrar.ToMap() + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t TransferRule) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRule) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRule to hex string (Canton MCMS format) +func (t TransferRule) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRule from hex string (Canton MCMS format) +func (t *TransferRule) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for TransferRule + +// TransferRuleDirectTransfer exercises the TransferRule_DirectTransfer choice on this TransferRule contract +// This method uses the package name in the template ID +func (t TransferRule) TransferRuleDirectTransfer(contractID string, args TransferRuleDirectTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_DirectTransfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleDirectTransferWithPackageID exercises the TransferRule_DirectTransfer choice using the provided package ID instead of package name +func (t TransferRule) TransferRuleDirectTransferWithPackageID(contractID string, packageID string, args TransferRuleDirectTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_DirectTransfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleTwoStepTransfer exercises the TransferRule_TwoStepTransfer choice on this TransferRule contract +// This method uses the package name in the template ID +func (t TransferRule) TransferRuleTwoStepTransfer(contractID string, args TransferRuleTwoStepTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_TwoStepTransfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleTwoStepTransferWithPackageID exercises the TransferRule_TwoStepTransfer choice using the provided package ID instead of package name +func (t TransferRule) TransferRuleTwoStepTransferWithPackageID(contractID string, packageID string, args TransferRuleTwoStepTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_TwoStepTransfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleExecuteAllocation exercises the TransferRule_ExecuteAllocation choice on this TransferRule contract +// This method uses the package name in the template ID +func (t TransferRule) TransferRuleExecuteAllocation(contractID string, args TransferRuleExecuteAllocation) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_ExecuteAllocation", + Arguments: argsToMap(args), + } +} + +// TransferRuleExecuteAllocationWithPackageID exercises the TransferRule_ExecuteAllocation choice using the provided package ID instead of package name +func (t TransferRule) TransferRuleExecuteAllocationWithPackageID(contractID string, packageID string, args TransferRuleExecuteAllocation) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_ExecuteAllocation", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this TransferRule contract +// This method uses the package name in the template ID +func (t TransferRule) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t TransferRule) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// TransferRuleTransfer exercises the TransferRule_Transfer choice on this TransferRule contract +// This method uses the package name in the template ID +func (t TransferRule) TransferRuleTransfer(contractID string, args TransferRuleTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleTransferWithPackageID exercises the TransferRule_Transfer choice using the provided package ID instead of package name +func (t TransferRule) TransferRuleTransferWithPackageID(contractID string, packageID string, args TransferRuleTransfer) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Rule.Transfer", "TransferRule"), + ContractID: contractID, + Choice: "TransferRule_Transfer", + Arguments: argsToMap(args), + } +} + +// TransferRuleAcceptTransferOfferResult is a Record type +type TransferRuleAcceptTransferOfferResult struct { + ReceiverHoldingCid types.CONTRACT_ID `json:"receiverHoldingCid"` + SenderHoldingCid *types.CONTRACT_ID `json:"senderHoldingCid" hex:"optional"` +} + +// ToMap converts TransferRuleAcceptTransferOfferResult to a map for DAML arguments +func (t TransferRuleAcceptTransferOfferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["receiverHoldingCid"] = model.NestedToDAMLValue(t.ReceiverHoldingCid) + + if t.SenderHoldingCid != nil { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.SenderHoldingCid), + } + } else { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleAcceptTransferOfferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleAcceptTransferOfferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleAcceptTransferOfferResult to hex string (Canton MCMS format) +func (t TransferRuleAcceptTransferOfferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleAcceptTransferOfferResult from hex string (Canton MCMS format) +func (t *TransferRuleAcceptTransferOfferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleDirectTransfer is a Record type +type TransferRuleDirectTransfer struct { + Transfer splice_api_token_transfer_instruction_v1.Transfer `json:"transfer"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` + ExpectedOperator types.PARTY `json:"expectedOperator"` + ExpectedProvider *types.PARTY `json:"expectedProvider" hex:"optional"` +} + +// ToMap converts TransferRuleDirectTransfer to a map for DAML arguments +func (t TransferRuleDirectTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["transfer"] = model.NestedToDAMLValue(t.Transfer) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + m["expectedOperator"] = t.ExpectedOperator.ToMap() + + if t.ExpectedProvider != nil { + m["expectedProvider"] = map[string]any{ + "_type": "optional", + "value": (*t.ExpectedProvider).ToMap(), + } + } else { + m["expectedProvider"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleDirectTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleDirectTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleDirectTransfer to hex string (Canton MCMS format) +func (t TransferRuleDirectTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleDirectTransfer from hex string (Canton MCMS format) +func (t *TransferRuleDirectTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleDirectTransferResult is a Record type +type TransferRuleDirectTransferResult struct { + ReceiverHoldingCid types.CONTRACT_ID `json:"receiverHoldingCid"` + SenderHoldingCid *types.CONTRACT_ID `json:"senderHoldingCid" hex:"optional"` +} + +// ToMap converts TransferRuleDirectTransferResult to a map for DAML arguments +func (t TransferRuleDirectTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["receiverHoldingCid"] = model.NestedToDAMLValue(t.ReceiverHoldingCid) + + if t.SenderHoldingCid != nil { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.SenderHoldingCid), + } + } else { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleDirectTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleDirectTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleDirectTransferResult to hex string (Canton MCMS format) +func (t TransferRuleDirectTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleDirectTransferResult from hex string (Canton MCMS format) +func (t *TransferRuleDirectTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleExecuteAllocation is a Record type +type TransferRuleExecuteAllocation struct { + Allocation splice_api_token_allocation_v1.AllocationView `json:"allocation"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` + ExpectedOperator types.PARTY `json:"expectedOperator"` + ExpectedProvider types.PARTY `json:"expectedProvider"` +} + +// ToMap converts TransferRuleExecuteAllocation to a map for DAML arguments +func (t TransferRuleExecuteAllocation) ToMap() map[string]any { + m := make(map[string]any) + + m["allocation"] = model.NestedToDAMLValue(t.Allocation) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + m["expectedOperator"] = t.ExpectedOperator.ToMap() + + m["expectedProvider"] = t.ExpectedProvider.ToMap() + + return m +} + +func (t TransferRuleExecuteAllocation) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleExecuteAllocation) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleExecuteAllocation to hex string (Canton MCMS format) +func (t TransferRuleExecuteAllocation) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleExecuteAllocation from hex string (Canton MCMS format) +func (t *TransferRuleExecuteAllocation) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleExecuteAllocationResult is a Record type +type TransferRuleExecuteAllocationResult struct { + ReceiverHoldingCid types.CONTRACT_ID `json:"receiverHoldingCid"` + SenderHoldingCid *types.CONTRACT_ID `json:"senderHoldingCid" hex:"optional"` +} + +// ToMap converts TransferRuleExecuteAllocationResult to a map for DAML arguments +func (t TransferRuleExecuteAllocationResult) ToMap() map[string]any { + m := make(map[string]any) + + m["receiverHoldingCid"] = model.NestedToDAMLValue(t.ReceiverHoldingCid) + + if t.SenderHoldingCid != nil { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.SenderHoldingCid), + } + } else { + m["senderHoldingCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleExecuteAllocationResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleExecuteAllocationResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleExecuteAllocationResult to hex string (Canton MCMS format) +func (t TransferRuleExecuteAllocationResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleExecuteAllocationResult from hex string (Canton MCMS format) +func (t *TransferRuleExecuteAllocationResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleTransfer is a Record type +type TransferRuleTransfer struct { + Transfer splice_api_token_transfer_instruction_v1.Transfer `json:"transfer"` + InstrumentConfigurationCid types.CONTRACT_ID `json:"instrumentConfigurationCid"` + SenderCredentialCids []types.CONTRACT_ID `json:"senderCredentialCids"` + ReceiverCredentialCids []types.CONTRACT_ID `json:"receiverCredentialCids"` + AppRewardConfigurationCid *types.CONTRACT_ID `json:"appRewardConfigurationCid" hex:"optional"` + FeaturedAppRightCid *types.CONTRACT_ID `json:"featuredAppRightCid" hex:"optional"` +} + +// ToMap converts TransferRuleTransfer to a map for DAML arguments +func (t TransferRuleTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["transfer"] = model.NestedToDAMLValue(t.Transfer) + + m["instrumentConfigurationCid"] = model.NestedToDAMLValue(t.InstrumentConfigurationCid) + + m["senderCredentialCids"] = func() []any { + res := make([]any, 0, len(t.SenderCredentialCids)) + for _, e := range t.SenderCredentialCids { + res = append(res, e) + } + return res + }() + + m["receiverCredentialCids"] = func() []any { + res := make([]any, 0, len(t.ReceiverCredentialCids)) + for _, e := range t.ReceiverCredentialCids { + res = append(res, e) + } + return res + }() + + if t.AppRewardConfigurationCid != nil { + m["appRewardConfigurationCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.AppRewardConfigurationCid), + } + } else { + m["appRewardConfigurationCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + if t.FeaturedAppRightCid != nil { + m["featuredAppRightCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.FeaturedAppRightCid), + } + } else { + m["featuredAppRightCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleTransfer to hex string (Canton MCMS format) +func (t TransferRuleTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleTransfer from hex string (Canton MCMS format) +func (t *TransferRuleTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleTransferResult is a Record type +type TransferRuleTransferResult struct { + ReceiverHoldingCid types.CONTRACT_ID `json:"receiverHoldingCid"` + SenderChangeCid *types.CONTRACT_ID `json:"senderChangeCid" hex:"optional"` +} + +// ToMap converts TransferRuleTransferResult to a map for DAML arguments +func (t TransferRuleTransferResult) ToMap() map[string]any { + m := make(map[string]any) + + m["receiverHoldingCid"] = model.NestedToDAMLValue(t.ReceiverHoldingCid) + + if t.SenderChangeCid != nil { + m["senderChangeCid"] = map[string]any{ + "_type": "optional", + "value": model.NestedToDAMLValue(*t.SenderChangeCid), + } + } else { + m["senderChangeCid"] = map[string]any{ + "_type": "optional", + "value": nil, + } + } + + return m +} + +func (t TransferRuleTransferResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleTransferResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleTransferResult to hex string (Canton MCMS format) +func (t TransferRuleTransferResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleTransferResult from hex string (Canton MCMS format) +func (t *TransferRuleTransferResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TransferRuleTwoStepTransfer is a Record type +type TransferRuleTwoStepTransfer struct { + Transfer splice_api_token_transfer_instruction_v1.Transfer `json:"transfer"` + ExtraArgs splice_api_token_metadata_v1.ExtraArgs `json:"extraArgs"` + ExpectedOperator types.PARTY `json:"expectedOperator"` + ExpectedProvider types.PARTY `json:"expectedProvider"` +} + +// ToMap converts TransferRuleTwoStepTransfer to a map for DAML arguments +func (t TransferRuleTwoStepTransfer) ToMap() map[string]any { + m := make(map[string]any) + + m["transfer"] = model.NestedToDAMLValue(t.Transfer) + + m["extraArgs"] = model.NestedToDAMLValue(t.ExtraArgs) + + m["expectedOperator"] = t.ExpectedOperator.ToMap() + + m["expectedProvider"] = t.ExpectedProvider.ToMap() + + return m +} + +func (t TransferRuleTwoStepTransfer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *TransferRuleTwoStepTransfer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes TransferRuleTwoStepTransfer to hex string (Canton MCMS format) +func (t TransferRuleTwoStepTransfer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes TransferRuleTwoStepTransfer from hex string (Canton MCMS format) +func (t *TransferRuleTwoStepTransfer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// TxKind is an enum type +type TxKind string + +const ( + TxKindTxKind_Transfer TxKind = "TxKind_Transfer" + + TxKindTxKind_Unlock TxKind = "TxKind_Unlock" + + TxKindTxKind_MergeSplit TxKind = "TxKind_MergeSplit" + + TxKindTxKind_Burn TxKind = "TxKind_Burn" + + TxKindTxKind_Mint TxKind = "TxKind_Mint" + + TxKindTxKind_ExpireDust TxKind = "TxKind_ExpireDust" +) + +func (e TxKind) GetEnumConstructor() string { return string(e) } + +func (e TxKind) GetEnumTypeID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.TokenApiUtils", "TxKind") +} + +// GetEnumTypeIDWithPackageID returns the enum type ID using the provided package ID instead of package name +func (e TxKind) GetEnumTypeIDWithPackageID(packageID string) string { + return fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.TokenApiUtils", "TxKind") +} + +func (e TxKind) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(e) +} + +func (e *TxKind) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, e) +} + +// MarshalHex encodes TxKind to hex string (Canton MCMS format) +func (e TxKind) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(e) +} + +// UnmarshalHex decodes TxKind from hex string (Canton MCMS format) +func (e *TxKind) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, e) +} + +var _ types.ENUM = TxKind("") + +// Unlock is a Record type +type Unlock struct { + Operator types.PARTY `json:"operator"` + Provider types.PARTY `json:"provider"` + Registrar types.PARTY `json:"registrar"` + Holder types.PARTY `json:"holder"` + Locker types.PARTY `json:"locker"` + LockContext types.TEXT `json:"lockContext"` + InstrumentIdentifier registry_holding_v0.InstrumentIdentifier `json:"instrumentIdentifier"` + Amount types.NUMERIC `json:"amount"` + Reference types.TEXT `json:"reference"` + Batch Batch `json:"batch"` +} + +// ToMap converts Unlock to a map for DAML arguments +func (t Unlock) ToMap() map[string]any { + m := make(map[string]any) + + m["operator"] = t.Operator.ToMap() + + m["provider"] = t.Provider.ToMap() + + m["registrar"] = t.Registrar.ToMap() + + m["holder"] = t.Holder.ToMap() + + m["locker"] = t.Locker.ToMap() + + m["lockContext"] = string(t.LockContext) + + m["instrumentIdentifier"] = model.NestedToDAMLValue(t.InstrumentIdentifier) + + m["amount"] = t.Amount + + m["reference"] = string(t.Reference) + + m["batch"] = model.NestedToDAMLValue(t.Batch) + + return m +} + +func (t Unlock) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *Unlock) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes Unlock to hex string (Canton MCMS format) +func (t Unlock) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes Unlock from hex string (Canton MCMS format) +func (t *Unlock) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOffer is a Template type +type UnlockOffer struct { + Unlock Unlock `json:"unlock"` + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t UnlockOffer) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t UnlockOffer) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t UnlockOffer) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t UnlockOffer) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["holdingLabel"] = string(t.HoldingLabel) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t UnlockOffer) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOffer) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOffer to hex string (Canton MCMS format) +func (t UnlockOffer) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOffer from hex string (Canton MCMS format) +func (t *UnlockOffer) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for UnlockOffer + +// UnlockOfferClean exercises the UnlockOffer_Clean choice on this UnlockOffer contract +// This method uses the package name in the template ID +func (t UnlockOffer) UnlockOfferClean(contractID string, args UnlockOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Clean", + Arguments: argsToMap(args), + } +} + +// UnlockOfferCleanWithPackageID exercises the UnlockOffer_Clean choice using the provided package ID instead of package name +func (t UnlockOffer) UnlockOfferCleanWithPackageID(contractID string, packageID string, args UnlockOfferClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Clean", + Arguments: argsToMap(args), + } +} + +// UnlockOfferAccept exercises the UnlockOffer_Accept choice on this UnlockOffer contract +// This method uses the package name in the template ID +func (t UnlockOffer) UnlockOfferAccept(contractID string, args UnlockOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Accept", + Arguments: argsToMap(args), + } +} + +// UnlockOfferAcceptWithPackageID exercises the UnlockOffer_Accept choice using the provided package ID instead of package name +func (t UnlockOffer) UnlockOfferAcceptWithPackageID(contractID string, packageID string, args UnlockOfferAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Accept", + Arguments: argsToMap(args), + } +} + +// UnlockOfferReject exercises the UnlockOffer_Reject choice on this UnlockOffer contract +// This method uses the package name in the template ID +func (t UnlockOffer) UnlockOfferReject(contractID string, args UnlockOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Reject", + Arguments: argsToMap(args), + } +} + +// UnlockOfferRejectWithPackageID exercises the UnlockOffer_Reject choice using the provided package ID instead of package name +func (t UnlockOffer) UnlockOfferRejectWithPackageID(contractID string, packageID string, args UnlockOfferReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Reject", + Arguments: argsToMap(args), + } +} + +// UnlockOfferCancel exercises the UnlockOffer_Cancel choice on this UnlockOffer contract +// This method uses the package name in the template ID +func (t UnlockOffer) UnlockOfferCancel(contractID string, args UnlockOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// UnlockOfferCancelWithPackageID exercises the UnlockOffer_Cancel choice using the provided package ID instead of package name +func (t UnlockOffer) UnlockOfferCancelWithPackageID(contractID string, packageID string, args UnlockOfferCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "UnlockOffer_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this UnlockOffer contract +// This method uses the package name in the template ID +func (t UnlockOffer) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t UnlockOffer) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockOffer"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// UnlockOfferAccept is a Record type +type UnlockOfferAccept struct { +} + +// ToMap converts UnlockOfferAccept to a map for DAML arguments +func (t UnlockOfferAccept) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t UnlockOfferAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferAccept to hex string (Canton MCMS format) +func (t UnlockOfferAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferAccept from hex string (Canton MCMS format) +func (t *UnlockOfferAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferAcceptResult is a Record type +type UnlockOfferAcceptResult struct { + AcceptedUnlockCid types.CONTRACT_ID `json:"acceptedUnlockCid"` +} + +// ToMap converts UnlockOfferAcceptResult to a map for DAML arguments +func (t UnlockOfferAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedUnlockCid"] = model.NestedToDAMLValue(t.AcceptedUnlockCid) + + return m +} + +func (t UnlockOfferAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferAcceptResult to hex string (Canton MCMS format) +func (t UnlockOfferAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferAcceptResult from hex string (Canton MCMS format) +func (t *UnlockOfferAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferCancel is a Record type +type UnlockOfferCancel struct { +} + +// ToMap converts UnlockOfferCancel to a map for DAML arguments +func (t UnlockOfferCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t UnlockOfferCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferCancel to hex string (Canton MCMS format) +func (t UnlockOfferCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferCancel from hex string (Canton MCMS format) +func (t *UnlockOfferCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferCancelResult is a Record type +type UnlockOfferCancelResult struct { +} + +// ToMap converts UnlockOfferCancelResult to a map for DAML arguments +func (t UnlockOfferCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t UnlockOfferCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferCancelResult to hex string (Canton MCMS format) +func (t UnlockOfferCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferCancelResult from hex string (Canton MCMS format) +func (t *UnlockOfferCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferClean is a Record type +type UnlockOfferClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts UnlockOfferClean to a map for DAML arguments +func (t UnlockOfferClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t UnlockOfferClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferClean to hex string (Canton MCMS format) +func (t UnlockOfferClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferClean from hex string (Canton MCMS format) +func (t *UnlockOfferClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferReject is a Record type +type UnlockOfferReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts UnlockOfferReject to a map for DAML arguments +func (t UnlockOfferReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t UnlockOfferReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferReject to hex string (Canton MCMS format) +func (t UnlockOfferReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferReject from hex string (Canton MCMS format) +func (t *UnlockOfferReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockOfferRejectResult is a Record type +type UnlockOfferRejectResult struct { + RejectedUnlockCid types.CONTRACT_ID `json:"rejectedUnlockCid"` +} + +// ToMap converts UnlockOfferRejectResult to a map for DAML arguments +func (t UnlockOfferRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedUnlockCid"] = model.NestedToDAMLValue(t.RejectedUnlockCid) + + return m +} + +func (t UnlockOfferRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockOfferRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockOfferRejectResult to hex string (Canton MCMS format) +func (t UnlockOfferRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockOfferRejectResult from hex string (Canton MCMS format) +func (t *UnlockOfferRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequest is a Template type +type UnlockRequest struct { + Unlock Unlock `json:"unlock"` +} + +// GetTemplateID returns the template ID for this template using the package name +func (t UnlockRequest) GetTemplateID() string { + return fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest") +} + +// GetTemplateIDWithPackageID returns the template ID using the provided package ID instead of package name +func (t UnlockRequest) GetTemplateIDWithPackageID(packageID string) string { + return fmt.Sprintf("%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest") +} + +// CreateCommand returns a CreateCommand for this template using the package name +func (t UnlockRequest) CreateCommand() *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateID(), + Arguments: args, + } +} + +// CreateCommandWithPackageID returns a CreateCommand using the provided package ID instead of package name +func (t UnlockRequest) CreateCommandWithPackageID(packageID string) *model.CreateCommand { + args := make(map[string]any) + + // IMPORTANT: always include non-optional fields (GENMAP/MAP/LIST/[] etc), even if empty + args["unlock"] = model.NestedToDAMLValue(t.Unlock) + + return &model.CreateCommand{ + TemplateID: t.GetTemplateIDWithPackageID(packageID), + Arguments: args, + } +} + +func (t UnlockRequest) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequest) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequest to hex string (Canton MCMS format) +func (t UnlockRequest) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequest from hex string (Canton MCMS format) +func (t *UnlockRequest) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// Choice methods for UnlockRequest + +// UnlockRequestClean exercises the UnlockRequest_Clean choice on this UnlockRequest contract +// This method uses the package name in the template ID +func (t UnlockRequest) UnlockRequestClean(contractID string, args UnlockRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Clean", + Arguments: argsToMap(args), + } +} + +// UnlockRequestCleanWithPackageID exercises the UnlockRequest_Clean choice using the provided package ID instead of package name +func (t UnlockRequest) UnlockRequestCleanWithPackageID(contractID string, packageID string, args UnlockRequestClean) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Clean", + Arguments: argsToMap(args), + } +} + +// UnlockRequestAccept exercises the UnlockRequest_Accept choice on this UnlockRequest contract +// This method uses the package name in the template ID +func (t UnlockRequest) UnlockRequestAccept(contractID string, args UnlockRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Accept", + Arguments: argsToMap(args), + } +} + +// UnlockRequestAcceptWithPackageID exercises the UnlockRequest_Accept choice using the provided package ID instead of package name +func (t UnlockRequest) UnlockRequestAcceptWithPackageID(contractID string, packageID string, args UnlockRequestAccept) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Accept", + Arguments: argsToMap(args), + } +} + +// UnlockRequestReject exercises the UnlockRequest_Reject choice on this UnlockRequest contract +// This method uses the package name in the template ID +func (t UnlockRequest) UnlockRequestReject(contractID string, args UnlockRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Reject", + Arguments: argsToMap(args), + } +} + +// UnlockRequestRejectWithPackageID exercises the UnlockRequest_Reject choice using the provided package ID instead of package name +func (t UnlockRequest) UnlockRequestRejectWithPackageID(contractID string, packageID string, args UnlockRequestReject) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Reject", + Arguments: argsToMap(args), + } +} + +// UnlockRequestCancel exercises the UnlockRequest_Cancel choice on this UnlockRequest contract +// This method uses the package name in the template ID +func (t UnlockRequest) UnlockRequestCancel(contractID string, args UnlockRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// UnlockRequestCancelWithPackageID exercises the UnlockRequest_Cancel choice using the provided package ID instead of package name +func (t UnlockRequest) UnlockRequestCancelWithPackageID(contractID string, packageID string, args UnlockRequestCancel) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "UnlockRequest_Cancel", + Arguments: argsToMap(args), + } +} + +// Archive exercises the Archive choice on this UnlockRequest contract +// This method uses the package name in the template ID +func (t UnlockRequest) Archive(contractID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", PackageName, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// ArchiveWithPackageID exercises the Archive choice using the provided package ID instead of package name +func (t UnlockRequest) ArchiveWithPackageID(contractID string, packageID string) *model.ExerciseCommand { + return &model.ExerciseCommand{ + TemplateID: fmt.Sprintf("#%s:%s:%s", packageID, "Utility.Registry.V0.Holding.Unlock", "UnlockRequest"), + ContractID: contractID, + Choice: "Archive", + Arguments: map[string]any{}, + } +} + +// UnlockRequestAccept is a Record type +type UnlockRequestAccept struct { + HoldingLabel types.TEXT `json:"holdingLabel"` +} + +// ToMap converts UnlockRequestAccept to a map for DAML arguments +func (t UnlockRequestAccept) ToMap() map[string]any { + m := make(map[string]any) + + m["holdingLabel"] = string(t.HoldingLabel) + + return m +} + +func (t UnlockRequestAccept) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestAccept) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestAccept to hex string (Canton MCMS format) +func (t UnlockRequestAccept) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestAccept from hex string (Canton MCMS format) +func (t *UnlockRequestAccept) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestAcceptResult is a Record type +type UnlockRequestAcceptResult struct { + AcceptedUnlockCid types.CONTRACT_ID `json:"acceptedUnlockCid"` +} + +// ToMap converts UnlockRequestAcceptResult to a map for DAML arguments +func (t UnlockRequestAcceptResult) ToMap() map[string]any { + m := make(map[string]any) + + m["acceptedUnlockCid"] = model.NestedToDAMLValue(t.AcceptedUnlockCid) + + return m +} + +func (t UnlockRequestAcceptResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestAcceptResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestAcceptResult to hex string (Canton MCMS format) +func (t UnlockRequestAcceptResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestAcceptResult from hex string (Canton MCMS format) +func (t *UnlockRequestAcceptResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestCancel is a Record type +type UnlockRequestCancel struct { +} + +// ToMap converts UnlockRequestCancel to a map for DAML arguments +func (t UnlockRequestCancel) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t UnlockRequestCancel) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestCancel) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestCancel to hex string (Canton MCMS format) +func (t UnlockRequestCancel) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestCancel from hex string (Canton MCMS format) +func (t *UnlockRequestCancel) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestCancelResult is a Record type +type UnlockRequestCancelResult struct { +} + +// ToMap converts UnlockRequestCancelResult to a map for DAML arguments +func (t UnlockRequestCancelResult) ToMap() map[string]any { + m := make(map[string]any) + return m +} + +func (t UnlockRequestCancelResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestCancelResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestCancelResult to hex string (Canton MCMS format) +func (t UnlockRequestCancelResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestCancelResult from hex string (Canton MCMS format) +func (t *UnlockRequestCancelResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestClean is a Record type +type UnlockRequestClean struct { + Actor types.PARTY `json:"actor"` +} + +// ToMap converts UnlockRequestClean to a map for DAML arguments +func (t UnlockRequestClean) ToMap() map[string]any { + m := make(map[string]any) + + m["actor"] = t.Actor.ToMap() + + return m +} + +func (t UnlockRequestClean) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestClean) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestClean to hex string (Canton MCMS format) +func (t UnlockRequestClean) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestClean from hex string (Canton MCMS format) +func (t *UnlockRequestClean) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestReject is a Record type +type UnlockRequestReject struct { + Reason types.TEXT `json:"reason"` +} + +// ToMap converts UnlockRequestReject to a map for DAML arguments +func (t UnlockRequestReject) ToMap() map[string]any { + m := make(map[string]any) + + m["reason"] = string(t.Reason) + + return m +} + +func (t UnlockRequestReject) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestReject) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestReject to hex string (Canton MCMS format) +func (t UnlockRequestReject) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestReject from hex string (Canton MCMS format) +func (t *UnlockRequestReject) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// UnlockRequestRejectResult is a Record type +type UnlockRequestRejectResult struct { + RejectedUnlockCid types.CONTRACT_ID `json:"rejectedUnlockCid"` +} + +// ToMap converts UnlockRequestRejectResult to a map for DAML arguments +func (t UnlockRequestRejectResult) ToMap() map[string]any { + m := make(map[string]any) + + m["rejectedUnlockCid"] = model.NestedToDAMLValue(t.RejectedUnlockCid) + + return m +} + +func (t UnlockRequestRejectResult) MarshalJSON() ([]byte, error) { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Marshal(t) +} + +func (t *UnlockRequestRejectResult) UnmarshalJSON(data []byte) error { + jsonCodec := codec.NewJsonCodec() + return jsonCodec.Unmarshal(data, t) +} + +// MarshalHex encodes UnlockRequestRejectResult to hex string (Canton MCMS format) +func (t UnlockRequestRejectResult) MarshalHex() (string, error) { + hexCodec := codec.NewHexCodec() + return hexCodec.Marshal(t) +} + +// UnmarshalHex decodes UnlockRequestRejectResult from hex string (Canton MCMS format) +func (t *UnlockRequestRejectResult) UnmarshalHex(data string) error { + hexCodec := codec.NewHexCodec() + return hexCodec.Unmarshal(data, t) +} + +// MCMSEncoder interface for typed encoding methods. +// Implemented by Encoder for method-based encoding. +type MCMSEncoder interface { + AcceptedBurnClean(args AcceptedBurnClean) (*bind.EncodedChoice, error) + AcceptedBurnExecute(args AcceptedBurnExecute) (*bind.EncodedChoice, error) + AcceptedBurnFail(args AcceptedBurnFail) (*bind.EncodedChoice, error) + AcceptedForceTransferExecute(args AcceptedForceTransferExecute) (*bind.EncodedChoice, error) + AcceptedForceTransferFail(args AcceptedForceTransferFail) (*bind.EncodedChoice, error) + AcceptedLockClean(args AcceptedLockClean) (*bind.EncodedChoice, error) + AcceptedLockExecute(args AcceptedLockExecute) (*bind.EncodedChoice, error) + AcceptedLockFail(args AcceptedLockFail) (*bind.EncodedChoice, error) + AcceptedMintClean(args AcceptedMintClean) (*bind.EncodedChoice, error) + AcceptedMintExecute(args AcceptedMintExecute) (*bind.EncodedChoice, error) + AcceptedMintFail(args AcceptedMintFail) (*bind.EncodedChoice, error) + AcceptedTransferClean(args AcceptedTransferClean) (*bind.EncodedChoice, error) + AcceptedTransferExecute(args AcceptedTransferExecute) (*bind.EncodedChoice, error) + AcceptedTransferFail(args AcceptedTransferFail) (*bind.EncodedChoice, error) + AcceptedUnlockClean(args AcceptedUnlockClean) (*bind.EncodedChoice, error) + AcceptedUnlockExecute(args AcceptedUnlockExecute) (*bind.EncodedChoice, error) + AcceptedUnlockFail(args AcceptedUnlockFail) (*bind.EncodedChoice, error) + AppRewardConfigurationModify(args AppRewardConfigurationModify) (*bind.EncodedChoice, error) + BurnOfferAccept(args BurnOfferAccept) (*bind.EncodedChoice, error) + BurnOfferCancel(args BurnOfferCancel) (*bind.EncodedChoice, error) + BurnOfferClean(args BurnOfferClean) (*bind.EncodedChoice, error) + BurnOfferReject(args BurnOfferReject) (*bind.EncodedChoice, error) + BurnRequestAccept(args BurnRequestAccept) (*bind.EncodedChoice, error) + BurnRequestCancel(args BurnRequestCancel) (*bind.EncodedChoice, error) + BurnRequestClean(args BurnRequestClean) (*bind.EncodedChoice, error) + BurnRequestReject(args BurnRequestReject) (*bind.EncodedChoice, error) + ExecutedBurnClean(args ExecutedBurnClean) (*bind.EncodedChoice, error) + ExecutedBurnDelete(args ExecutedBurnDelete) (*bind.EncodedChoice, error) + ExecutedForceTransferDelete(args ExecutedForceTransferDelete) (*bind.EncodedChoice, error) + ExecutedLockClean(args ExecutedLockClean) (*bind.EncodedChoice, error) + ExecutedLockDelete(args ExecutedLockDelete) (*bind.EncodedChoice, error) + ExecutedMintClean(args ExecutedMintClean) (*bind.EncodedChoice, error) + ExecutedMintDelete(args ExecutedMintDelete) (*bind.EncodedChoice, error) + ExecutedTransferDelete(args ExecutedTransferDelete) (*bind.EncodedChoice, error) + ExecutedUnlockClean(args ExecutedUnlockClean) (*bind.EncodedChoice, error) + ExecutedUnlockDelete(args ExecutedUnlockDelete) (*bind.EncodedChoice, error) + FailedBurnClean(args FailedBurnClean) (*bind.EncodedChoice, error) + FailedBurnDelete(args FailedBurnDelete) (*bind.EncodedChoice, error) + FailedForceTransferDelete(args FailedForceTransferDelete) (*bind.EncodedChoice, error) + FailedLockClean(args FailedLockClean) (*bind.EncodedChoice, error) + FailedLockDelete(args FailedLockDelete) (*bind.EncodedChoice, error) + FailedMintClean(args FailedMintClean) (*bind.EncodedChoice, error) + FailedMintDelete(args FailedMintDelete) (*bind.EncodedChoice, error) + FailedTransferClean(args FailedTransferClean) (*bind.EncodedChoice, error) + FailedTransferDelete(args FailedTransferDelete) (*bind.EncodedChoice, error) + FailedUnlockClean(args FailedUnlockClean) (*bind.EncodedChoice, error) + FailedUnlockDelete(args FailedUnlockDelete) (*bind.EncodedChoice, error) + ForceTransferRequestAccept(args ForceTransferRequestAccept) (*bind.EncodedChoice, error) + ForceTransferRequestCancel(args ForceTransferRequestCancel) (*bind.EncodedChoice, error) + ForceTransferRequestReject(args ForceTransferRequestReject) (*bind.EncodedChoice, error) + InstrumentConfigurationGet(args InstrumentConfigurationGet) (*bind.EncodedChoice, error) + InstrumentConfigurationSetProviderAppRewardBeneficiaries(args InstrumentConfigurationSetProviderAppRewardBeneficiaries) (*bind.EncodedChoice, error) + LockOfferAccept(args LockOfferAccept) (*bind.EncodedChoice, error) + LockOfferCancel(args LockOfferCancel) (*bind.EncodedChoice, error) + LockOfferClean(args LockOfferClean) (*bind.EncodedChoice, error) + LockOfferReject(args LockOfferReject) (*bind.EncodedChoice, error) + LockRequestAccept(args LockRequestAccept) (*bind.EncodedChoice, error) + LockRequestCancel(args LockRequestCancel) (*bind.EncodedChoice, error) + LockRequestClean(args LockRequestClean) (*bind.EncodedChoice, error) + LockRequestReject(args LockRequestReject) (*bind.EncodedChoice, error) + MintOfferAccept(args MintOfferAccept) (*bind.EncodedChoice, error) + MintOfferCancel(args MintOfferCancel) (*bind.EncodedChoice, error) + MintOfferClean(args MintOfferClean) (*bind.EncodedChoice, error) + MintOfferReject(args MintOfferReject) (*bind.EncodedChoice, error) + MintRequestAccept(args MintRequestAccept) (*bind.EncodedChoice, error) + MintRequestCancel(args MintRequestCancel) (*bind.EncodedChoice, error) + MintRequestClean(args MintRequestClean) (*bind.EncodedChoice, error) + MintRequestReject(args MintRequestReject) (*bind.EncodedChoice, error) + RejectedBurnClean(args RejectedBurnClean) (*bind.EncodedChoice, error) + RejectedBurnDelete(args RejectedBurnDelete) (*bind.EncodedChoice, error) + RejectedForceTransferDelete(args RejectedForceTransferDelete) (*bind.EncodedChoice, error) + RejectedLockClean(args RejectedLockClean) (*bind.EncodedChoice, error) + RejectedLockDelete(args RejectedLockDelete) (*bind.EncodedChoice, error) + RejectedMintClean(args RejectedMintClean) (*bind.EncodedChoice, error) + RejectedMintDelete(args RejectedMintDelete) (*bind.EncodedChoice, error) + RejectedTransferDelete(args RejectedTransferDelete) (*bind.EncodedChoice, error) + RejectedUnlockClean(args RejectedUnlockClean) (*bind.EncodedChoice, error) + RejectedUnlockDelete(args RejectedUnlockDelete) (*bind.EncodedChoice, error) + TransferOfferAccept(args TransferOfferAccept) (*bind.EncodedChoice, error) + TransferOfferCancel(args TransferOfferCancel) (*bind.EncodedChoice, error) + TransferOfferClean(args TransferOfferClean) (*bind.EncodedChoice, error) + TransferOfferReject(args TransferOfferReject) (*bind.EncodedChoice, error) + TransferRequestAccept(args TransferRequestAccept) (*bind.EncodedChoice, error) + TransferRequestCancel(args TransferRequestCancel) (*bind.EncodedChoice, error) + TransferRequestClean(args TransferRequestClean) (*bind.EncodedChoice, error) + TransferRequestReject(args TransferRequestReject) (*bind.EncodedChoice, error) + TransferRuleDirectTransfer(args TransferRuleDirectTransfer) (*bind.EncodedChoice, error) + TransferRuleExecuteAllocation(args TransferRuleExecuteAllocation) (*bind.EncodedChoice, error) + TransferRuleTransfer(args TransferRuleTransfer) (*bind.EncodedChoice, error) + TransferRuleTwoStepTransfer(args TransferRuleTwoStepTransfer) (*bind.EncodedChoice, error) + UnlockOfferAccept(args UnlockOfferAccept) (*bind.EncodedChoice, error) + UnlockOfferCancel(args UnlockOfferCancel) (*bind.EncodedChoice, error) + UnlockOfferClean(args UnlockOfferClean) (*bind.EncodedChoice, error) + UnlockOfferReject(args UnlockOfferReject) (*bind.EncodedChoice, error) + UnlockRequestAccept(args UnlockRequestAccept) (*bind.EncodedChoice, error) + UnlockRequestCancel(args UnlockRequestCancel) (*bind.EncodedChoice, error) + UnlockRequestClean(args UnlockRequestClean) (*bind.EncodedChoice, error) + UnlockRequestReject(args UnlockRequestReject) (*bind.EncodedChoice, error) +} + +// encoder provides typed encoding methods for choice parameters (unexported). +// It wraps bind.BoundTemplate to encode parameters to hex-encoded operation data. +type encoder struct { + *bind.BoundTemplate +} + +// Contract wraps template operations with Sui-style API access. +// Use NewContract to create instances, then call Encoder() for encoding methods. +type Contract struct { + enc *encoder +} + +// NewContract creates a Contract with encoder for the given template. +// This provides Sui-style API: contract.Encoder().Method(args) +func NewContract(packageID, moduleName, templateName string) *Contract { + return &Contract{ + enc: &encoder{ + BoundTemplate: bind.NewBoundTemplate(packageID, moduleName, templateName), + }, + } +} + +// Encoder returns the encoder for Sui-style contract.Encoder().Method() usage. +func (c *Contract) Encoder() MCMSEncoder { + return c.enc +} + +// AcceptedBurnClean encodes parameters for the AcceptedBurn_Clean choice. +func (e *encoder) AcceptedBurnClean(args AcceptedBurnClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedBurn_Clean", args) +} + +// AcceptedBurnExecute encodes parameters for the AcceptedBurn_Execute choice. +func (e *encoder) AcceptedBurnExecute(args AcceptedBurnExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedBurn_Execute", args) +} + +// AcceptedBurnFail encodes parameters for the AcceptedBurn_Fail choice. +func (e *encoder) AcceptedBurnFail(args AcceptedBurnFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedBurn_Fail", args) +} + +// AcceptedForceTransferExecute encodes parameters for the AcceptedForceTransfer_Execute choice. +func (e *encoder) AcceptedForceTransferExecute(args AcceptedForceTransferExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedForceTransfer_Execute", args) +} + +// AcceptedForceTransferFail encodes parameters for the AcceptedForceTransfer_Fail choice. +func (e *encoder) AcceptedForceTransferFail(args AcceptedForceTransferFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedForceTransfer_Fail", args) +} + +// AcceptedLockClean encodes parameters for the AcceptedLock_Clean choice. +func (e *encoder) AcceptedLockClean(args AcceptedLockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedLock_Clean", args) +} + +// AcceptedLockExecute encodes parameters for the AcceptedLock_Execute choice. +func (e *encoder) AcceptedLockExecute(args AcceptedLockExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedLock_Execute", args) +} + +// AcceptedLockFail encodes parameters for the AcceptedLock_Fail choice. +func (e *encoder) AcceptedLockFail(args AcceptedLockFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedLock_Fail", args) +} + +// AcceptedMintClean encodes parameters for the AcceptedMint_Clean choice. +func (e *encoder) AcceptedMintClean(args AcceptedMintClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedMint_Clean", args) +} + +// AcceptedMintExecute encodes parameters for the AcceptedMint_Execute choice. +func (e *encoder) AcceptedMintExecute(args AcceptedMintExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedMint_Execute", args) +} + +// AcceptedMintFail encodes parameters for the AcceptedMint_Fail choice. +func (e *encoder) AcceptedMintFail(args AcceptedMintFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedMint_Fail", args) +} + +// AcceptedTransferClean encodes parameters for the AcceptedTransfer_Clean choice. +func (e *encoder) AcceptedTransferClean(args AcceptedTransferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedTransfer_Clean", args) +} + +// AcceptedTransferExecute encodes parameters for the AcceptedTransfer_Execute choice. +func (e *encoder) AcceptedTransferExecute(args AcceptedTransferExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedTransfer_Execute", args) +} + +// AcceptedTransferFail encodes parameters for the AcceptedTransfer_Fail choice. +func (e *encoder) AcceptedTransferFail(args AcceptedTransferFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedTransfer_Fail", args) +} + +// AcceptedUnlockClean encodes parameters for the AcceptedUnlock_Clean choice. +func (e *encoder) AcceptedUnlockClean(args AcceptedUnlockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedUnlock_Clean", args) +} + +// AcceptedUnlockExecute encodes parameters for the AcceptedUnlock_Execute choice. +func (e *encoder) AcceptedUnlockExecute(args AcceptedUnlockExecute) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedUnlock_Execute", args) +} + +// AcceptedUnlockFail encodes parameters for the AcceptedUnlock_Fail choice. +func (e *encoder) AcceptedUnlockFail(args AcceptedUnlockFail) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AcceptedUnlock_Fail", args) +} + +// AppRewardConfigurationModify encodes parameters for the AppRewardConfiguration_Modify choice. +func (e *encoder) AppRewardConfigurationModify(args AppRewardConfigurationModify) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("AppRewardConfiguration_Modify", args) +} + +// BurnOfferAccept encodes parameters for the BurnOffer_Accept choice. +func (e *encoder) BurnOfferAccept(args BurnOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Accept", args) +} + +// BurnOfferCancel encodes parameters for the BurnOffer_Cancel choice. +func (e *encoder) BurnOfferCancel(args BurnOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Cancel", args) +} + +// BurnOfferClean encodes parameters for the BurnOffer_Clean choice. +func (e *encoder) BurnOfferClean(args BurnOfferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Clean", args) +} + +// BurnOfferReject encodes parameters for the BurnOffer_Reject choice. +func (e *encoder) BurnOfferReject(args BurnOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnOffer_Reject", args) +} + +// BurnRequestAccept encodes parameters for the BurnRequest_Accept choice. +func (e *encoder) BurnRequestAccept(args BurnRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Accept", args) +} + +// BurnRequestCancel encodes parameters for the BurnRequest_Cancel choice. +func (e *encoder) BurnRequestCancel(args BurnRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Cancel", args) +} + +// BurnRequestClean encodes parameters for the BurnRequest_Clean choice. +func (e *encoder) BurnRequestClean(args BurnRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Clean", args) +} + +// BurnRequestReject encodes parameters for the BurnRequest_Reject choice. +func (e *encoder) BurnRequestReject(args BurnRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("BurnRequest_Reject", args) +} + +// ExecutedBurnClean encodes parameters for the ExecutedBurn_Clean choice. +func (e *encoder) ExecutedBurnClean(args ExecutedBurnClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedBurn_Clean", args) +} + +// ExecutedBurnDelete encodes parameters for the ExecutedBurn_Delete choice. +func (e *encoder) ExecutedBurnDelete(args ExecutedBurnDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedBurn_Delete", args) +} + +// ExecutedForceTransferDelete encodes parameters for the ExecutedForceTransfer_Delete choice. +func (e *encoder) ExecutedForceTransferDelete(args ExecutedForceTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedForceTransfer_Delete", args) +} + +// ExecutedLockClean encodes parameters for the ExecutedLock_Clean choice. +func (e *encoder) ExecutedLockClean(args ExecutedLockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedLock_Clean", args) +} + +// ExecutedLockDelete encodes parameters for the ExecutedLock_Delete choice. +func (e *encoder) ExecutedLockDelete(args ExecutedLockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedLock_Delete", args) +} + +// ExecutedMintClean encodes parameters for the ExecutedMint_Clean choice. +func (e *encoder) ExecutedMintClean(args ExecutedMintClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedMint_Clean", args) +} + +// ExecutedMintDelete encodes parameters for the ExecutedMint_Delete choice. +func (e *encoder) ExecutedMintDelete(args ExecutedMintDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedMint_Delete", args) +} + +// ExecutedTransferDelete encodes parameters for the ExecutedTransfer_Delete choice. +func (e *encoder) ExecutedTransferDelete(args ExecutedTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedTransfer_Delete", args) +} + +// ExecutedUnlockClean encodes parameters for the ExecutedUnlock_Clean choice. +func (e *encoder) ExecutedUnlockClean(args ExecutedUnlockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedUnlock_Clean", args) +} + +// ExecutedUnlockDelete encodes parameters for the ExecutedUnlock_Delete choice. +func (e *encoder) ExecutedUnlockDelete(args ExecutedUnlockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ExecutedUnlock_Delete", args) +} + +// FailedBurnClean encodes parameters for the FailedBurn_Clean choice. +func (e *encoder) FailedBurnClean(args FailedBurnClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedBurn_Clean", args) +} + +// FailedBurnDelete encodes parameters for the FailedBurn_Delete choice. +func (e *encoder) FailedBurnDelete(args FailedBurnDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedBurn_Delete", args) +} + +// FailedForceTransferDelete encodes parameters for the FailedForceTransfer_Delete choice. +func (e *encoder) FailedForceTransferDelete(args FailedForceTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedForceTransfer_Delete", args) +} + +// FailedLockClean encodes parameters for the FailedLock_Clean choice. +func (e *encoder) FailedLockClean(args FailedLockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedLock_Clean", args) +} + +// FailedLockDelete encodes parameters for the FailedLock_Delete choice. +func (e *encoder) FailedLockDelete(args FailedLockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedLock_Delete", args) +} + +// FailedMintClean encodes parameters for the FailedMint_Clean choice. +func (e *encoder) FailedMintClean(args FailedMintClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedMint_Clean", args) +} + +// FailedMintDelete encodes parameters for the FailedMint_Delete choice. +func (e *encoder) FailedMintDelete(args FailedMintDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedMint_Delete", args) +} + +// FailedTransferClean encodes parameters for the FailedTransfer_Clean choice. +func (e *encoder) FailedTransferClean(args FailedTransferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedTransfer_Clean", args) +} + +// FailedTransferDelete encodes parameters for the FailedTransfer_Delete choice. +func (e *encoder) FailedTransferDelete(args FailedTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedTransfer_Delete", args) +} + +// FailedUnlockClean encodes parameters for the FailedUnlock_Clean choice. +func (e *encoder) FailedUnlockClean(args FailedUnlockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedUnlock_Clean", args) +} + +// FailedUnlockDelete encodes parameters for the FailedUnlock_Delete choice. +func (e *encoder) FailedUnlockDelete(args FailedUnlockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("FailedUnlock_Delete", args) +} + +// ForceTransferRequestAccept encodes parameters for the ForceTransferRequest_Accept choice. +func (e *encoder) ForceTransferRequestAccept(args ForceTransferRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ForceTransferRequest_Accept", args) +} + +// ForceTransferRequestCancel encodes parameters for the ForceTransferRequest_Cancel choice. +func (e *encoder) ForceTransferRequestCancel(args ForceTransferRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ForceTransferRequest_Cancel", args) +} + +// ForceTransferRequestReject encodes parameters for the ForceTransferRequest_Reject choice. +func (e *encoder) ForceTransferRequestReject(args ForceTransferRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("ForceTransferRequest_Reject", args) +} + +// InstrumentConfigurationGet encodes parameters for the InstrumentConfiguration_Get choice. +func (e *encoder) InstrumentConfigurationGet(args InstrumentConfigurationGet) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("InstrumentConfiguration_Get", args) +} + +// InstrumentConfigurationSetProviderAppRewardBeneficiaries encodes parameters for the InstrumentConfiguration_SetProviderAppRewardBeneficiaries choice. +func (e *encoder) InstrumentConfigurationSetProviderAppRewardBeneficiaries(args InstrumentConfigurationSetProviderAppRewardBeneficiaries) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("InstrumentConfiguration_SetProviderAppRewardBeneficiaries", args) +} + +// LockOfferAccept encodes parameters for the LockOffer_Accept choice. +func (e *encoder) LockOfferAccept(args LockOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockOffer_Accept", args) +} + +// LockOfferCancel encodes parameters for the LockOffer_Cancel choice. +func (e *encoder) LockOfferCancel(args LockOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockOffer_Cancel", args) +} + +// LockOfferClean encodes parameters for the LockOffer_Clean choice. +func (e *encoder) LockOfferClean(args LockOfferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockOffer_Clean", args) +} + +// LockOfferReject encodes parameters for the LockOffer_Reject choice. +func (e *encoder) LockOfferReject(args LockOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockOffer_Reject", args) +} + +// LockRequestAccept encodes parameters for the LockRequest_Accept choice. +func (e *encoder) LockRequestAccept(args LockRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockRequest_Accept", args) +} + +// LockRequestCancel encodes parameters for the LockRequest_Cancel choice. +func (e *encoder) LockRequestCancel(args LockRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockRequest_Cancel", args) +} + +// LockRequestClean encodes parameters for the LockRequest_Clean choice. +func (e *encoder) LockRequestClean(args LockRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockRequest_Clean", args) +} + +// LockRequestReject encodes parameters for the LockRequest_Reject choice. +func (e *encoder) LockRequestReject(args LockRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("LockRequest_Reject", args) +} + +// MintOfferAccept encodes parameters for the MintOffer_Accept choice. +func (e *encoder) MintOfferAccept(args MintOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Accept", args) +} + +// MintOfferCancel encodes parameters for the MintOffer_Cancel choice. +func (e *encoder) MintOfferCancel(args MintOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Cancel", args) +} + +// MintOfferClean encodes parameters for the MintOffer_Clean choice. +func (e *encoder) MintOfferClean(args MintOfferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Clean", args) +} + +// MintOfferReject encodes parameters for the MintOffer_Reject choice. +func (e *encoder) MintOfferReject(args MintOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintOffer_Reject", args) +} + +// MintRequestAccept encodes parameters for the MintRequest_Accept choice. +func (e *encoder) MintRequestAccept(args MintRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Accept", args) +} + +// MintRequestCancel encodes parameters for the MintRequest_Cancel choice. +func (e *encoder) MintRequestCancel(args MintRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Cancel", args) +} + +// MintRequestClean encodes parameters for the MintRequest_Clean choice. +func (e *encoder) MintRequestClean(args MintRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Clean", args) +} + +// MintRequestReject encodes parameters for the MintRequest_Reject choice. +func (e *encoder) MintRequestReject(args MintRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("MintRequest_Reject", args) +} + +// RejectedBurnClean encodes parameters for the RejectedBurn_Clean choice. +func (e *encoder) RejectedBurnClean(args RejectedBurnClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedBurn_Clean", args) +} + +// RejectedBurnDelete encodes parameters for the RejectedBurn_Delete choice. +func (e *encoder) RejectedBurnDelete(args RejectedBurnDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedBurn_Delete", args) +} + +// RejectedForceTransferDelete encodes parameters for the RejectedForceTransfer_Delete choice. +func (e *encoder) RejectedForceTransferDelete(args RejectedForceTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedForceTransfer_Delete", args) +} + +// RejectedLockClean encodes parameters for the RejectedLock_Clean choice. +func (e *encoder) RejectedLockClean(args RejectedLockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedLock_Clean", args) +} + +// RejectedLockDelete encodes parameters for the RejectedLock_Delete choice. +func (e *encoder) RejectedLockDelete(args RejectedLockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedLock_Delete", args) +} + +// RejectedMintClean encodes parameters for the RejectedMint_Clean choice. +func (e *encoder) RejectedMintClean(args RejectedMintClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedMint_Clean", args) +} + +// RejectedMintDelete encodes parameters for the RejectedMint_Delete choice. +func (e *encoder) RejectedMintDelete(args RejectedMintDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedMint_Delete", args) +} + +// RejectedTransferDelete encodes parameters for the RejectedTransfer_Delete choice. +func (e *encoder) RejectedTransferDelete(args RejectedTransferDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedTransfer_Delete", args) +} + +// RejectedUnlockClean encodes parameters for the RejectedUnlock_Clean choice. +func (e *encoder) RejectedUnlockClean(args RejectedUnlockClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedUnlock_Clean", args) +} + +// RejectedUnlockDelete encodes parameters for the RejectedUnlock_Delete choice. +func (e *encoder) RejectedUnlockDelete(args RejectedUnlockDelete) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("RejectedUnlock_Delete", args) +} + +// TransferOfferAccept encodes parameters for the TransferOffer_Accept choice. +func (e *encoder) TransferOfferAccept(args TransferOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferOffer_Accept", args) +} + +// TransferOfferCancel encodes parameters for the TransferOffer_Cancel choice. +func (e *encoder) TransferOfferCancel(args TransferOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferOffer_Cancel", args) +} + +// TransferOfferClean encodes parameters for the TransferOffer_Clean choice. +func (e *encoder) TransferOfferClean(args TransferOfferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferOffer_Clean", args) +} + +// TransferOfferReject encodes parameters for the TransferOffer_Reject choice. +func (e *encoder) TransferOfferReject(args TransferOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferOffer_Reject", args) +} + +// TransferRequestAccept encodes parameters for the TransferRequest_Accept choice. +func (e *encoder) TransferRequestAccept(args TransferRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRequest_Accept", args) +} + +// TransferRequestCancel encodes parameters for the TransferRequest_Cancel choice. +func (e *encoder) TransferRequestCancel(args TransferRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRequest_Cancel", args) +} + +// TransferRequestClean encodes parameters for the TransferRequest_Clean choice. +func (e *encoder) TransferRequestClean(args TransferRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRequest_Clean", args) +} + +// TransferRequestReject encodes parameters for the TransferRequest_Reject choice. +func (e *encoder) TransferRequestReject(args TransferRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRequest_Reject", args) +} + +// TransferRuleDirectTransfer encodes parameters for the TransferRule_DirectTransfer choice. +func (e *encoder) TransferRuleDirectTransfer(args TransferRuleDirectTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRule_DirectTransfer", args) +} + +// TransferRuleExecuteAllocation encodes parameters for the TransferRule_ExecuteAllocation choice. +func (e *encoder) TransferRuleExecuteAllocation(args TransferRuleExecuteAllocation) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRule_ExecuteAllocation", args) +} + +// TransferRuleTransfer encodes parameters for the TransferRule_Transfer choice. +func (e *encoder) TransferRuleTransfer(args TransferRuleTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRule_Transfer", args) +} + +// TransferRuleTwoStepTransfer encodes parameters for the TransferRule_TwoStepTransfer choice. +func (e *encoder) TransferRuleTwoStepTransfer(args TransferRuleTwoStepTransfer) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("TransferRule_TwoStepTransfer", args) +} + +// UnlockOfferAccept encodes parameters for the UnlockOffer_Accept choice. +func (e *encoder) UnlockOfferAccept(args UnlockOfferAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockOffer_Accept", args) +} + +// UnlockOfferCancel encodes parameters for the UnlockOffer_Cancel choice. +func (e *encoder) UnlockOfferCancel(args UnlockOfferCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockOffer_Cancel", args) +} + +// UnlockOfferClean encodes parameters for the UnlockOffer_Clean choice. +func (e *encoder) UnlockOfferClean(args UnlockOfferClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockOffer_Clean", args) +} + +// UnlockOfferReject encodes parameters for the UnlockOffer_Reject choice. +func (e *encoder) UnlockOfferReject(args UnlockOfferReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockOffer_Reject", args) +} + +// UnlockRequestAccept encodes parameters for the UnlockRequest_Accept choice. +func (e *encoder) UnlockRequestAccept(args UnlockRequestAccept) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockRequest_Accept", args) +} + +// UnlockRequestCancel encodes parameters for the UnlockRequest_Cancel choice. +func (e *encoder) UnlockRequestCancel(args UnlockRequestCancel) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockRequest_Cancel", args) +} + +// UnlockRequestClean encodes parameters for the UnlockRequest_Clean choice. +func (e *encoder) UnlockRequestClean(args UnlockRequestClean) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockRequest_Clean", args) +} + +// UnlockRequestReject encodes parameters for the UnlockRequest_Reject choice. +func (e *encoder) UnlockRequestReject(args UnlockRequestReject) (*bind.EncodedChoice, error) { + return e.EncodeChoiceArgs("UnlockRequest_Reject", args) +} + +// Verify MCMSEncoder interface implementation +var _ MCMSEncoder = (*encoder)(nil) diff --git a/contracts/cmd/bindings/main.go b/contracts/cmd/bindings/main.go index 116a8e41a..2ed0f9322 100644 --- a/contracts/cmd/bindings/main.go +++ b/contracts/cmd/bindings/main.go @@ -146,6 +146,16 @@ func main() { log.Fatal().Err(err).Str("package", string(p)).Str("outputFile", outputFile).Msg("Failed to write generated bindings to file") } } + + // Utility DARs need post-processing: Tuple2 shims (prim dalfs skipped above) and + // splice Transfer2 collision fix when registry packages define a local Transfer2 type. + if err := writeTuple2Shims(*artifactsDir); err != nil { + log.Fatal().Err(err).Msg("Failed to write utility Tuple2 shims") + } + if err := patchUtilityBindingCollisions(*artifactsDir); err != nil { + log.Fatal().Err(err).Msg("Failed to patch utility binding collisions") + } + log.Info().Msg("Successfully generated all bindings") } @@ -183,7 +193,11 @@ func generatePackage(dar []byte, pkgFile string, externalPackages model.External } dalfLower := strings.ToLower(dalf) - if strings.Contains(dalfLower, "prim") || strings.Contains(dalfLower, "stdlib") { + if strings.Contains(dalfLower, "stdlib") { + continue + } + // Skip prim dalfs; utility Tuple2 references are shimmed in per-package tuple2.go. + if strings.Contains(dalfLower, "prim") { continue } diff --git a/contracts/cmd/bindings/utility_patch.go b/contracts/cmd/bindings/utility_patch.go new file mode 100644 index 000000000..7c74230c6 --- /dev/null +++ b/contracts/cmd/bindings/utility_patch.go @@ -0,0 +1,90 @@ +package main + +import ( + "fmt" + "os" + "path/filepath" + "strings" +) + +// spliceTransferCollision is the incorrect type go-daml emits when a utility package +// defines a local Transfer2 (Utility.Registry.Transfer) and also references +// Splice.Api.Token.Transfer via a qualified import. +const spliceTransferCollision = "splice_api_token_transfer_instruction_v1.Transfer2" + +const spliceTransferCorrect = "splice_api_token_transfer_instruction_v1.Transfer" + +const tuple2ShimBody = ` +// Code generated by contracts/cmd/bindings. DO NOT EDIT. + +// Tuple2 mirrors GHC.Tuple from daml-prim (referenced by utility DARs, not emitted by codegen). +type Tuple2 struct { + First any ` + "`json:\"_1\"`" + ` + Second any ` + "`json:\"_2\"`" + ` +} +` + +var tuple2ShimPackages = []struct { + dir string + packageAs string +}{ + {dir: filepath.Join("utility", "credential_v0"), packageAs: "credential_v0"}, + {dir: filepath.Join("utility", "registry_holding_v0"), packageAs: "registry_holding_v0"}, +} + +func writeTuple2Shims(artifactsDir string) error { + for _, pkg := range tuple2ShimPackages { + content := "package " + pkg.packageAs + tuple2ShimBody + + outputFile := filepath.Join(artifactsDir, pkg.dir, "tuple2.go") + if err := os.MkdirAll(filepath.Dir(outputFile), 0o755); err != nil { + return fmt.Errorf("create tuple2 shim dir %q: %w", filepath.Dir(outputFile), err) + } + if err := os.WriteFile(outputFile, []byte(content), 0o644); err != nil { + return fmt.Errorf("write tuple2 shim %q: %w", outputFile, err) + } + } + + return nil +} + +func patchUtilityBindingCollisions(artifactsDir string) error { + utilityDir := filepath.Join(artifactsDir, "utility") + entries, err := os.ReadDir(utilityDir) + if err != nil { + if os.IsNotExist(err) { + return nil + } + return fmt.Errorf("read utility bindings dir %q: %w", utilityDir, err) + } + + for _, entry := range entries { + if !entry.IsDir() { + continue + } + + goFile := filepath.Join(utilityDir, entry.Name(), entry.Name()+".go") + data, err := os.ReadFile(goFile) + if err != nil { + if os.IsNotExist(err) { + continue + } + return fmt.Errorf("read utility bindings %q: %w", goFile, err) + } + + patched := patchSpliceTransferCollision(data) + if string(patched) == string(data) { + continue + } + + if err := os.WriteFile(goFile, patched, 0o644); err != nil { + return fmt.Errorf("write patched utility bindings %q: %w", goFile, err) + } + } + + return nil +} + +func patchSpliceTransferCollision(data []byte) []byte { + return []byte(strings.ReplaceAll(string(data), spliceTransferCollision, spliceTransferCorrect)) +} diff --git a/contracts/contracts.go b/contracts/contracts.go index 350169e66..bad0f5fff 100644 --- a/contracts/contracts.go +++ b/contracts/contracts.go @@ -50,10 +50,31 @@ const ( CCIPPerPartyRouter = CCIPRuntime CCIPPoolInterfaces = CCIPExtensionAPI - SpliceApiTokenBurnMintV1 = Package("splice-api-token-burn-mint-v1") - SpliceApiTokenHoldingV1 = Package("splice-api-token-holding-v1") - SpliceApiTokenMetadataV1 = Package("splice-api-token-metadata-v1") - SpliceApiTokenTransferInstructionV1 = Package("splice-api-token-transfer-instruction-v1") + SpliceApiFeaturedAppV1 = Package("splice-api-featured-app-v1") + SpliceApiTokenAllocationV1 = Package("splice-api-token-allocation-v1") + SpliceApiTokenAllocationInstructionV1 = Package("splice-api-token-allocation-instruction-v1") + SpliceApiTokenBurnMintV1 = Package("splice-api-token-burn-mint-v1") + SpliceApiTokenHoldingV1 = Package("splice-api-token-holding-v1") + SpliceApiTokenMetadataV1 = Package("splice-api-token-metadata-v1") + SpliceApiTokenTransferInstructionV1 = Package("splice-api-token-transfer-instruction-v1") + + // Canton Network Utility DARs (bundle 0.12.5). Package IDs pinned in dar-versions.md. + UtilityCredentialV0 = Package("utility-credential-v0") + UtilityRegistryV0 = Package("utility-registry-v0") + UtilityRegistryHoldingV0 = Package("utility-registry-holding-v0") + UtilityRegistryAppV0 = Package("utility-registry-app-v0") +) + +// Pinned package IDs from canton-network-utility-dars-0.12.5 / dar-versions.md. +// +//nolint:gosec // G101: These are safe package IDs +const ( + UtilityCommercialsV0PackageID = "fa5b1cc5c8368dff7c2e6a74aa2af9d520d755e2a508f44acd17343326e41839" + UtilityCredentialAppV0PackageID = "e9a3b7df354dfd2f15c7d015328c34256308c90ba96f86f185dad58ffca8299b" + UtilityCredentialV0PackageID = "5a29ead611a0abd5f5b3fc3caf7d0f67c0ff802032ab6d392824aa9060e56d70" + UtilityRegistryAppV0PackageID = "7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab" + UtilityRegistryV0PackageID = "a236e8e22a3b5f199e37d5554e82bafd2df688f901de02b00be3964bdfa8c1ab" + UtilityRegistryHoldingV0PackageID = "8107899ac4723ce986bf7d27416534e576e54b92161e46150a595fb78ff3d3a1" ) const CurrentVersion = "current" @@ -85,10 +106,19 @@ var Versions map[Package][]string = map[Package][]string{ CCIPFactory: []string{"2.0.0", CurrentVersion}, CCIPTest: []string{CurrentVersion}, - SpliceApiTokenBurnMintV1: []string{"1.0.0"}, - SpliceApiTokenHoldingV1: []string{"1.0.0"}, - SpliceApiTokenMetadataV1: []string{"1.0.0"}, - SpliceApiTokenTransferInstructionV1: []string{"1.0.0"}, + SpliceApiFeaturedAppV1: []string{"1.0.0"}, + SpliceApiTokenAllocationV1: []string{"1.0.0"}, + SpliceApiTokenAllocationInstructionV1: []string{"1.0.0"}, + SpliceApiTokenBurnMintV1: []string{"1.0.0"}, + SpliceApiTokenHoldingV1: []string{"1.0.0"}, + SpliceApiTokenMetadataV1: []string{"1.0.0"}, + SpliceApiTokenTransferInstructionV1: []string{"1.0.0"}, + + // Vendored from canton-network-utility-dars-0.12.5; semver pinned in Utility*PackageID constants. + UtilityCredentialV0: []string{CurrentVersion}, + UtilityRegistryV0: []string{CurrentVersion}, + UtilityRegistryHoldingV0: []string{CurrentVersion}, + UtilityRegistryAppV0: []string{CurrentVersion}, } // VersionDir maps a DAR version string to its artifact subdirectory. @@ -147,8 +177,16 @@ var OutputDirs = map[Package][]string{ CCIPBurnMintTokenPool: []string{"ccip", "burnminttokenpool"}, CCIPFactory: []string{"ccip", "factory"}, - SpliceApiTokenBurnMintV1: []string{"splice", "splice_api_token_burn_mint_v1"}, - SpliceApiTokenHoldingV1: []string{"splice", "splice_api_token_holding_v1"}, - SpliceApiTokenMetadataV1: []string{"splice", "splice_api_token_metadata_v1"}, - SpliceApiTokenTransferInstructionV1: []string{"splice", "splice_api_token_transfer_instruction_v1"}, + SpliceApiFeaturedAppV1: []string{"splice", "splice_api_featured_app_v1"}, + SpliceApiTokenAllocationV1: []string{"splice", "splice_api_token_allocation_v1"}, + SpliceApiTokenAllocationInstructionV1: []string{"splice", "splice_api_token_allocation_instruction_v1"}, + SpliceApiTokenBurnMintV1: []string{"splice", "splice_api_token_burn_mint_v1"}, + SpliceApiTokenHoldingV1: []string{"splice", "splice_api_token_holding_v1"}, + SpliceApiTokenMetadataV1: []string{"splice", "splice_api_token_metadata_v1"}, + SpliceApiTokenTransferInstructionV1: []string{"splice", "splice_api_token_transfer_instruction_v1"}, + + UtilityCredentialV0: []string{"utility", "credential_v0"}, + UtilityRegistryV0: []string{"utility", "registry_v0"}, + UtilityRegistryHoldingV0: []string{"utility", "registry_holding_v0"}, + UtilityRegistryAppV0: []string{"utility", "registry_app_v0"}, } diff --git a/contracts/dars/current/utility-credential-v0-current.dar b/contracts/dars/current/utility-credential-v0-current.dar new file mode 100644 index 000000000..ec56cbfaf Binary files /dev/null and b/contracts/dars/current/utility-credential-v0-current.dar differ diff --git a/contracts/dars/current/utility-registry-app-v0-current.dar b/contracts/dars/current/utility-registry-app-v0-current.dar new file mode 100644 index 000000000..b42b7c6a8 Binary files /dev/null and b/contracts/dars/current/utility-registry-app-v0-current.dar differ diff --git a/contracts/dars/current/utility-registry-holding-v0-current.dar b/contracts/dars/current/utility-registry-holding-v0-current.dar new file mode 100644 index 000000000..15888f064 Binary files /dev/null and b/contracts/dars/current/utility-registry-holding-v0-current.dar differ diff --git a/contracts/dars/current/utility-registry-v0-current.dar b/contracts/dars/current/utility-registry-v0-current.dar new file mode 100644 index 000000000..a6a90be4f Binary files /dev/null and b/contracts/dars/current/utility-registry-v0-current.dar differ diff --git a/integration-tests/ccip/ccip_execute_test.go b/integration-tests/ccip/ccip_execute_test.go index 30114c958..1c6947d39 100644 --- a/integration-tests/ccip/ccip_execute_test.go +++ b/integration-tests/ccip/ccip_execute_test.go @@ -78,17 +78,10 @@ import ( _ "github.com/smartcontractkit/chainlink-canton/deployment/adapters" ) -func finalityConfigValueFromBlockConfirmations(blockConfirmations uint16) *apiv2.Value { - if blockConfirmations == 0 { - return &apiv2.Value{Sum: &apiv2.Value_Variant{Variant: &apiv2.Variant{ - Constructor: "WaitForFinality", - Value: &apiv2.Value{Sum: &apiv2.Value_Unit{}}, - }}} - } - +func finalityConfigValueFromBlockConfirmations() *apiv2.Value { return &apiv2.Value{Sum: &apiv2.Value_Variant{Variant: &apiv2.Variant{ Constructor: "BlockDepth", - Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: int64(blockConfirmations)}}, + Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: 2000}}, }}} } @@ -520,7 +513,7 @@ func TestCCIPExecuteE2E(t *testing.T) { CreateArguments: &apiv2.Record{Fields: []*apiv2.RecordField{ {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-ccipreceiver"}}}, {Label: "owner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partyReceiver}}}, - {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations(2000)}, + {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations()}, {Label: "requiredCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalThreshold", Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: 0}}}, diff --git a/integration-tests/ccip/ccip_execute_token_bnm_test.go b/integration-tests/ccip/ccip_execute_token_bnm_test.go index ba3ca7270..8829f6ad3 100644 --- a/integration-tests/ccip/ccip_execute_token_bnm_test.go +++ b/integration-tests/ccip/ccip_execute_token_bnm_test.go @@ -655,7 +655,7 @@ func runBnMTokenPoolReceiveFlowTest(t *testing.T, tc bnmTokenPoolReceiveFlowTest CreateArguments: &apiv2.Record{Fields: []*apiv2.RecordField{ {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-ccipreceiver"}}}, {Label: "owner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partyReceiver}}}, - {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations(2000)}, + {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations()}, {Label: "requiredCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalThreshold", Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: 0}}}, diff --git a/integration-tests/ccip/ccip_execute_token_lnr_test.go b/integration-tests/ccip/ccip_execute_token_lnr_test.go index 37e27743c..a9c8d5dff 100644 --- a/integration-tests/ccip/ccip_execute_token_lnr_test.go +++ b/integration-tests/ccip/ccip_execute_token_lnr_test.go @@ -672,7 +672,7 @@ func runLnRTokenPoolReceiveFlowTest(t *testing.T, tc lnrTokenPoolReceiveFlowTest CreateArguments: &apiv2.Record{Fields: []*apiv2.RecordField{ {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-ccipreceiver"}}}, {Label: "owner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partyReceiver}}}, - {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations(2000)}, + {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations()}, {Label: "requiredCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, {Label: "optionalThreshold", Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: 0}}}, diff --git a/integration-tests/ccip/ccip_execute_token_registry_test.go b/integration-tests/ccip/ccip_execute_token_registry_test.go new file mode 100644 index 000000000..923ae3b47 --- /dev/null +++ b/integration-tests/ccip/ccip_execute_token_registry_test.go @@ -0,0 +1,678 @@ +package tests + +import ( + "context" + "crypto/ecdsa" + "encoding/hex" + "errors" + "fmt" + "math/big" + "os" + "slices" + "strconv" + "testing" + "time" + + "github.com/Masterminds/semver/v3" + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/crypto" + "github.com/google/uuid" + "github.com/rs/zerolog" + "github.com/rs/zerolog/log" + "github.com/stretchr/testify/require" + + chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/smartcontractkit/chainlink-ccip/deployment/lanes" + devenvcommon "github.com/smartcontractkit/chainlink-ccv/build/devenv/common" + "github.com/smartcontractkit/chainlink-ccv/protocol" + "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink-deployments-framework/chain" + "github.com/smartcontractkit/chainlink-deployments-framework/datastore" + cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment" + cld_ops "github.com/smartcontractkit/chainlink-deployments-framework/operations" + "github.com/smartcontractkit/freeport" + "github.com/smartcontractkit/go-daml/pkg/service/ledger" + "github.com/smartcontractkit/go-daml/pkg/types" + + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/ccipruntime" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/committeeverifier" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + executorBinding "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/executor" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/receiver" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/chainlink/chainlinkapi" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/chainlink-canton/commonconfig" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/deployment/changesets" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/committee_verifier" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/fee_quoter" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/global_config" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/offramp" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/onramp" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/per_party_router_factory" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/rmn_remote" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/token_admin_registry" + "github.com/smartcontractkit/chainlink-canton/deployment/sequences" + contractops "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract" + "github.com/smartcontractkit/chainlink-canton/eds/config" + "github.com/smartcontractkit/chainlink-canton/eds/service" + oapiCCIP "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/ccip" + oapiCCV "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/ccv" + rkccip "github.com/smartcontractkit/chainlink-canton/registry-kit/ccip" + rkledger "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + edsTesthelpers "github.com/smartcontractkit/chainlink-canton/testhelpers/eds" + + _ "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v2_0_0/adapters" + + _ "github.com/smartcontractkit/chainlink-canton/deployment/adapters" +) + +const ( + registryExecuteInstrumentID = "CCIP-REGISTRY-EXECUTE" + registryExecutePoolInstanceID = "ccip-registry-execute-pool" + registryExecuteDefaultRLInstance = "ccip-registry-execute-rl-in-default" + registryExecuteCustomRLInstance = "ccip-registry-execute-rl-in-custom" +) + +// TestRegistryTokenPool_FullReceiveFlow exercises CCIPReceiver.Execute with a Canton Registry Holding +// minted through a registrar-owned BurnMintTokenPool (hybrid EDS: CCIP/CCV via EDS, Registry pool +// context assembled manually). +// +//nolint:paralleltest // Holding balance assertions require exclusive CTF env +func TestRegistryTokenPool_FullReceiveFlow(t *testing.T) { + runRegistryTokenPoolReceiveFlowTest(t, bnmTokenPoolReceiveFlowTestCase{ + tokenAmount: big.NewInt(50e10), + expectedTransferAmount: 50, + defaultInboundLimiterCapacity: "1000000000000", + customInboundLimiterCapacity: "10000000000000", + expectedCustomLimiterTokens: "9500000000000.", + }) +} + +func runRegistryTokenPoolReceiveFlowTest(t *testing.T, tc bnmTokenPoolReceiveFlowTestCase) { + t.Helper() + + env := testhelpers.NewTestEnvironment(t, testhelpers.WithNumberOfParticipants(3)) + + ccipParticipant := env.Chain.Participants[0] + receiverParticipant := env.Chain.Participants[1] + tokenPoolOwnerParticipant := env.Chain.Participants[0] + + t.Cleanup(func() { + ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) + defer cancel() + testhelpers.ContractCleanup(t, ctx, env.Chain.Participants) + }) + + uploadRegistryDARs(t, ccipParticipant, receiverParticipant, tokenPoolOwnerParticipant) + + rmnDar, err := contracts.GetDar(contracts.CCIPRMN, contracts.CurrentVersion) + require.NoError(t, err) + commonDar, err := contracts.GetDar(contracts.CCIPCommon, contracts.CurrentVersion) + require.NoError(t, err) + offRampDar, err := contracts.GetDar(contracts.CCIPOffRamp, contracts.CurrentVersion) + require.NoError(t, err) + tokenAdminRegistryDar, err := contracts.GetDar(contracts.CCIPTokenAdminRegistry, contracts.CurrentVersion) + require.NoError(t, err) + committeeVerifierDar, err := contracts.GetDar(contracts.CCIPCommitteeVerifier, contracts.CurrentVersion) + require.NoError(t, err) + tokenPoolDar, err := contracts.GetDar(contracts.CCIPBurnMintTokenPool, contracts.CurrentVersion) + require.NoError(t, err) + perPartyRouterDar, err := contracts.GetDar(contracts.CCIPPerPartyRouter, contracts.CurrentVersion) + require.NoError(t, err) + ccipReceiverDar, err := contracts.GetDar(contracts.CCIPReceiver, contracts.CurrentVersion) + require.NoError(t, err) + onRampDar, err := contracts.GetDar(contracts.CCIPOnRamp, contracts.CurrentVersion) + require.NoError(t, err) + feeQuoterDar, err := contracts.GetDar(contracts.CCIPFeeQuoter, contracts.CurrentVersion) + require.NoError(t, err) + executorDar, err := contracts.GetDar(contracts.CCIPExecutor, contracts.CurrentVersion) + require.NoError(t, err) + + dars := [][]byte{rmnDar, commonDar, offRampDar, tokenAdminRegistryDar, committeeVerifierDar, tokenPoolDar, perPartyRouterDar, ccipReceiverDar, onRampDar, feeQuoterDar, executorDar} + packageIds, err := testhelpers.UploadDARstoMultipleParticipants(t.Context(), dars, ccipParticipant, receiverParticipant, tokenPoolOwnerParticipant) + require.NoError(t, err) + t.Logf("Uploaded CCIP DARs to all participants: %v", packageIds) + + ctx := t.Context() + partyCCIP := ccipParticipant.PartyID + partyReceiver := receiverParticipant.PartyID + partyRegistrar := testhelpers.AllocateParty(t, ccipParticipant, "registry-execute-registrar") + testhelpers.GrantCanActAs(t, ccipParticipant, partyRegistrar) + t.Logf("Parties: CCIP=%s, Receiver=%s, Registrar=%s", partyCCIP, partyReceiver, partyRegistrar) + + ccipClient := rkledger.NewCTFClient(ccipParticipant) + registrarClient := rkledger.NewCTFClient(ccipParticipant) + + _, tokenMetadataClient, _, err := testhelpers.NewValidatorAPIClients(ccipParticipant) + require.NoError(t, err) + + registryAdmin, err := testhelpers.GetRegistryAdmin(ctx, tokenMetadataClient) + require.NoError(t, err) + + nativeInstrumentId := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(registryAdmin), + Id: types.TEXT("Amulet"), + } + registryInstrumentId := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(partyRegistrar), + Id: types.TEXT(registryExecuteInstrumentID), + } + hashedRegistryInstrumentId := contracts.EncodeInstrumentID(registryInstrumentId) + + sourceChainSelector := fmt.Sprintf("%d", chainsel.ETHEREUM_TESTNET_SEPOLIA.Selector) + remoteSelector := chainsel.ETHEREUM_TESTNET_SEPOLIA.Selector + + ccvSignerKeys := make([]*ecdsa.PrivateKey, 0, 3) + ccvSignerPubKeys := make([]string, 0, 3) + for range 3 { + pk, err := crypto.GenerateKey() + require.NoError(t, err) + ccvSignerKeys = append(ccvSignerKeys, pk) + pubKeyHex := hex.EncodeToString(crypto.FromECDSAPub(&pk.PublicKey)) + ccvSignerPubKeys = append(ccvSignerPubKeys, pubKeyHex) + } + + versionTag := "e9a05a20" + ccvQualifier := devenvcommon.DefaultCommitteeVerifierQualifier + + reporter := cld_ops.NewMemoryReporter() + bundle := cld_ops.NewBundle(t.Context, logger.Test(t), reporter) + cldfEnv := cldf.Environment{ + Logger: logger.Test(t), + GetContext: t.Context, + DataStore: datastore.NewMemoryDataStore().Seal(), + BlockChains: chain.NewBlockChainsFromSlice([]chain.BlockChain{env.Chain}), + OperationsBundle: bundle, + } + + out, err := changesets.DeployChainContracts{}.Apply(cldfEnv, changesets.CantonCSDeps[changesets.DeployChainContractsConfig]{ + ChainSelector: env.Chain.ChainSelector(), + Participant: 0, + Config: changesets.DeployChainContractsConfig{ + Params: sequences.DeployChainContractsParams{ + CCIPOwnerParty: partyCCIP, + RMNOwnerParty: partyCCIP, + CommitteeVerifiers: []sequences.CommitteeVerifierParams{ + { + Qualifier: ccvQualifier, + Template: committeeverifier.CommitteeVerifier{ + Owner: types.PARTY(partyCCIP), + CcipOwner: types.PARTY(partyCCIP), + VersionTag: types.TEXT(versionTag), + MessageSentObservers: nil, + StorageLocations: []types.TEXT{"ipfs://test-registry-execute"}, + StorageLocationsAdmin: types.PARTY(partyCCIP), + PendingStorageLocationsAdmin: types.PARTY(partyCCIP), + Deps: committeeverifier.CommitteeVerifierDeps{}, + }, + }, + }, + GlobalConfig: sequences.GlobalConfigParams{ + Template: core.GlobalConfig{ + CcipOwner: "", + ChainSelector: types.NUMERIC(strconv.FormatUint(env.Chain.ChainSelector(), 10)), + }, + }, + Executors: []sequences.ExecutorParams{ + { + Qualifier: devenvcommon.DefaultExecutorQualifier, + Template: executorBinding.Executor{ + Owner: types.PARTY(partyCCIP), + MaxCCVsPerMsg: 10, + DynamicConfig: executorBinding.DynamicConfig{ + FeeAggregator: nil, + AllowedFinalityConfig: core.FinalityConfig{WaitForFinality: &types.UNIT{}}, + CcvAllowlistEnabled: false, + }, + AllowedCCVs: nil, + }, + }, + }, + RMNRemote: sequences.RMNRemoteParams{ + Template: core.RMNRemote{ + CcipOwner: "", + RmnOwner: types.PARTY(partyCCIP), + CursedSubjects: nil, + }, + }, + NativeInstrumentId: nativeInstrumentId, + }, + }, + }) + require.NoError(t, err) + err = out.DataStore.Merge(cldfEnv.DataStore) + require.NoError(t, err) + cldfEnv.DataStore = out.DataStore.Seal() + + globalConfigRef, globalConfigAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), global_config.ContractType, global_config.Version, "") + require.NoError(t, err) + _, feeQuoterAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), fee_quoter.ContractType, fee_quoter.Version, "") + require.NoError(t, err) + _, onRampAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), onramp.ContractType, onramp.Version, "") + require.NoError(t, err) + _, offRampAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), offramp.ContractType, offramp.Version, "") + require.NoError(t, err) + committeeVerifierRef, committeeVerifierAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), committee_verifier.ContractType, committee_verifier.Version, ccvQualifier) + require.NoError(t, err) + _, tokenAdminRegistryAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), token_admin_registry.ContractType, token_admin_registry.Version, "") + require.NoError(t, err) + _, rmnRemoteAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), rmn_remote.ContractType, rmn_remote.Version, "") + require.NoError(t, err) + _, perPartyRouterFactoryAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), per_party_router_factory.ContractType, per_party_router_factory.Version, "") + require.NoError(t, err) + + cantonAdapter, ok := lanes.GetLaneAdapterRegistry().GetLaneAdapter(chainsel.FamilyCanton, semver.MustParse("2.0.0")) + require.True(t, ok) + deployLaneLegReport, err := cld_ops.ExecuteSequence(cldfEnv.OperationsBundle, cantonAdapter.ConfigureLaneLegAsDest(), cldfEnv.BlockChains, lanes.UpdateLanesInput{ + Source: &lanes.ChainDefinition{ + Selector: remoteSelector, + OnRamp: hexutil.MustDecode("0xf6eced5e96fff2de4f0ecd722beb57556fc443fd"), + OffRamp: hexutil.MustDecode("0xd8c9ec8cad3fb34aeca3ddbebfabe9f28a9bfaed"), + }, + Dest: &lanes.ChainDefinition{ + Selector: env.Chain.ChainSelector(), + CommitteeVerifiers: []lanes.CommitteeVerifierConfig[datastore.AddressRef]{ + { + CommitteeVerifier: []datastore.AddressRef{committeeVerifierRef}, + RemoteChains: map[uint64]lanes.CommitteeVerifierRemoteChainConfig{ + remoteSelector: { + AllowlistEnabled: false, + AddedAllowlistedSenders: nil, + RemovedAllowlistedSenders: nil, + FeeUSDCents: 50, + GasForVerification: 50_000, + PayloadSizeBytes: 6*64 + 2*32, + SignatureConfig: lanes.CommitteeVerifierSignatureQuorumConfig{ + Signers: ccvSignerPubKeys, + Threshold: 2, + }, + }, + }, + }, + }, + LaneMandatedInboundCCVs: []datastore.AddressRef{committeeVerifierRef}, + DefaultInboundCCVs: nil, + CantonLaneConfig: &lanes.CantonLaneConfig{ + GlobalConfig: globalConfigRef, + }, + }, + IsDisabled: false, + TestRouter: false, + ExtraConfigs: lanes.ExtraConfigs{}, + }) + require.NoError(t, err) + runningDs := datastore.NewMemoryDataStore() + for _, address := range deployLaneLegReport.Output.Addresses { + err = runningDs.Addresses().Add(address) + require.NoError(t, err) + } + err = runningDs.Merge(cldfEnv.DataStore) + require.NoError(t, err) + cldfEnv.DataStore = runningDs.Seal() + + bootstrap, err := registry.BootstrapServices(ctx, registrarClient, partyRegistrar, registryExecuteInstrumentID) + require.NoError(t, err) + + now := time.Now() + inboundRateLimiterAddr, err := rkccip.DeployInboundRateLimiterForOwner(ctx, registrarClient, partyRegistrar, core.RateLimiter{ + InstanceId: types.TEXT(registryExecuteDefaultRLInstance), + PoolInstanceId: types.TEXT(registryExecutePoolInstanceID), + PoolOwner: types.PARTY(partyRegistrar), + RemoteChainSelector: types.NUMERIC(sourceChainSelector), + Direction: core.RateLimitDirectionRateLimitDirection_Inbound, + Mode: core.RateLimitModeRateLimitMode_DefaultFinality, + IsEnabled: true, + Capacity: types.NUMERIC(tc.defaultInboundLimiterCapacity), + Rate: types.NUMERIC(tc.defaultInboundLimiterCapacity), + Tokens: types.NUMERIC(tc.defaultInboundLimiterCapacity), + LastUpdated: types.TIMESTAMP(now), + }) + require.NoError(t, err) + + inboundCustomRateLimiterAddr, err := rkccip.DeployInboundRateLimiterForOwner(ctx, registrarClient, partyRegistrar, core.RateLimiter{ + InstanceId: types.TEXT(registryExecuteCustomRLInstance), + PoolInstanceId: types.TEXT(registryExecutePoolInstanceID), + PoolOwner: types.PARTY(partyRegistrar), + RemoteChainSelector: types.NUMERIC(sourceChainSelector), + Direction: core.RateLimitDirectionRateLimitDirection_Inbound, + Mode: core.RateLimitModeRateLimitMode_CustomFinality, + IsEnabled: true, + Capacity: types.NUMERIC(tc.customInboundLimiterCapacity), + Rate: types.NUMERIC(tc.customInboundLimiterCapacity), + Tokens: types.NUMERIC(tc.customInboundLimiterCapacity), + LastUpdated: types.TIMESTAMP(now), + }) + require.NoError(t, err) + + outboundRateLimiterAddr, err := rkccip.DeployOutboundRateLimiterForOwner(ctx, registrarClient, partyRegistrar, core.RateLimiter{ + InstanceId: types.TEXT("ccip-registry-execute-rl-out"), + PoolInstanceId: types.TEXT(registryExecutePoolInstanceID), + PoolOwner: types.PARTY(partyRegistrar), + RemoteChainSelector: types.NUMERIC(sourceChainSelector), + Direction: core.RateLimitDirectionRateLimitDirection_Outbound, + Mode: core.RateLimitModeRateLimitMode_DefaultFinality, + IsEnabled: false, + Capacity: types.NUMERIC("0"), + Rate: types.NUMERIC("0"), + Tokens: types.NUMERIC("0"), + LastUpdated: types.TIMESTAMP(now), + }) + require.NoError(t, err) + + remotePoolAddress := hexutil.MustDecode("0x7e3febbdaf80e7e96c1ae107508ec3fafc36d7f3") + remoteTokenAddress := hexutil.MustDecode("0xacdafefb07bff5b120b7afa6ea777cf7eabacc0d") + + poolAddr, err := rkccip.DeployBurnMintPoolForOwner(ctx, registrarClient, rkccip.PoolDeployDeps{ + CcipOwner: partyCCIP, + TokenAdminRegistry: tokenAdminRegistryAddress, + RMNRemote: rmnRemoteAddress, + FeeQuoter: feeQuoterAddress, + }, partyRegistrar, registryInstrumentId, registryExecutePoolInstanceID, + map[types.NUMERIC]burnminttokenpool.RemoteChainConfig{ + types.NUMERIC(sourceChainSelector): { + RemotePools: []types.TEXT{types.TEXT(hex.EncodeToString(remotePoolAddress))}, + RemoteTokenAddress: types.TEXT(hex.EncodeToString(remoteTokenAddress)), + InboundCCVs: []chainlinkapi.RawInstanceAddress{}, + OutboundCCVs: []chainlinkapi.RawInstanceAddress{}, + FinalityConfig: core.FinalityConfig{ + BlockDepth: new(types.INT64(2000)), + }, + InboundRateLimiter: inboundRateLimiterAddr.Binding(), + InboundCustomBlockConfirmationsRateLimiter: inboundCustomRateLimiterAddr.Binding(), + OutboundRateLimiter: outboundRateLimiterAddr.Binding(), + }, + }, + ) + require.NoError(t, err) + + initialTarCID, err := contractops.FindActiveContractIDByInstanceAddress( + ctx, + ccipParticipant.LedgerServices.State, + []string{partyCCIP}, + core.TokenAdminRegistry{}.GetTemplateID(), + tokenAdminRegistryAddress.InstanceAddress(), + ) + require.NoError(t, err) + + tokenConfigCID, tarCID, err := rkccip.RegisterTokenPoolViaClient(ctx, ccipClient, rkccip.RegisterTokenPoolClientInput{ + TokenAdminRegistryCID: initialTarCID, + InstrumentId: registryInstrumentId, + PoolInstanceID: registryExecutePoolInstanceID, + CcipParty: partyCCIP, + PoolOwnerParty: partyRegistrar, + PoolOwnerClient: registrarClient, + }) + require.NoError(t, err) + + tokenConfigCID, err = rkccip.SetBurnMintFactory(ctx, registrarClient, rkccip.SetBurnMintFactoryInput{ + TokenAdminRegistryCID: tarCID, + TokenConfigCID: tokenConfigCID, + InstrumentId: registryInstrumentId, + BurnMintFactoryCID: bootstrap.AllocationFactory, + CcipParty: partyCCIP, + PoolOwnerParty: partyRegistrar, + CcipClient: ccipClient, + PoolOwnerClient: registrarClient, + }) + require.NoError(t, err) + _ = tokenConfigCID + + edsParticipant := env.Chain.Participants[0] + edsToken, _ := edsParticipant.TokenSource.Token() + edsPort := freeport.GetOne(t) + go func() { + log.Info().Msg("Running EDS...") + err := service.RunEDS(ctx, log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.TraceLevel), &config.Config{ + ChainSelector: strconv.FormatUint(env.Chain.ChainSelector(), 10), + Server: config.ServerConfig{ + Host: "0.0.0.0", + Port: uint16(edsPort), + }, + Node: config.NodeConfig{ + URL: edsParticipant.Endpoints.GRPCLedgerAPIURL, + AuthConfig: commonconfig.AuthConfig{ + Type: commonconfig.AuthTypeInsecureStatic, + UserID: edsParticipant.UserID, + JWT: edsToken.AccessToken, + }, + MaxRetries: 0, + }, + CCIPAPIConfig: config.CCIPAPIConfig{ + Enabled: true, + PerPartyRouterFactory: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: perPartyRouterFactoryAddress.InstanceAddress(), + }, + OnRamp: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: onRampAddress.InstanceAddress(), + }, + OffRamp: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: offRampAddress.InstanceAddress(), + }, + GlobalConfig: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: globalConfigAddress.InstanceAddress(), + }, + TokenAdminRegistry: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: tokenAdminRegistryAddress.InstanceAddress(), + }, + RMNRemote: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: rmnRemoteAddress.InstanceAddress(), + }, + FeeQuoter: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: feeQuoterAddress.InstanceAddress(), + }, + }, + CCVAPIConfig: config.CCVAPIConfig{ + Enabled: true, + CCVs: []config.CCV{ + { + ContractIdentifier: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: committeeVerifierAddress.InstanceAddress(), + }, + }, + }, + }, + }) + log.Info().Err(err).Msg("EDS terminated") + if !errors.Is(err, context.Canceled) { + log.Error().Err(err).Msg("EDS server exited with error") + t.Fail() + } + }() + + ccipAPIClient, err := oapiCCIP.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + ccvAPIClient, err := oapiCCV.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + + time.Sleep(1 * time.Second) + + perPartyRouterFactoryDisclosure, err := edsTesthelpers.GetPerPartyRouterFactoryDisclosure(ctx, ccipAPIClient, partyReceiver) + require.NoError(t, err) + + res, err := receiverParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{Exercise: &apiv2.ExerciseCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#" + ccipruntime.PackageName, ModuleName: "CCIP.PerPartyRouter", EntityName: "PerPartyRouterFactory"}, + ContractId: perPartyRouterFactoryDisclosure.ContractId, + Choice: "CreateRouter", + ChoiceArgument: &apiv2.Value{Sum: &apiv2.Value_Record{Record: &apiv2.Record{Fields: []*apiv2.RecordField{ + {Label: "partyOwner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partyReceiver}}}, + {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-router-registry-execute"}}}, + }}}}, + }}, + }}, + ActAs: []string{partyReceiver}, + DisclosedContracts: perPartyRouterFactoryDisclosure.DisclosedContracts, + }, + }) + require.NoError(t, err) + routerCid := "" + for _, event := range res.GetTransaction().GetEvents() { + if e, ok := event.GetEvent().(*apiv2.Event_Created); ok { + if e.Created.GetTemplateId().GetEntityName() == "PerPartyRouter" { + routerCid = e.Created.ContractId + break + } + } + } + require.NotEmpty(t, routerCid) + + tokenTransfer := buildTokenTransferV1(tc.tokenAmount, remotePoolAddress, remoteTokenAddress, hashedRegistryInstrumentId, partyReceiver, tc.sourcePoolData) + + msg := protocol.Message{ + Version: 1, + SourceChainSelector: protocol.ChainSelector(remoteSelector), + DestChainSelector: protocol.ChainSelector(env.Chain.ChainSelector()), + SequenceNumber: 1, + ExecutionGasLimit: 200000, + CcipReceiveGasLimit: 100000, + Finality: protocol.NewFinality().WithBlockDepth(2000), + CcvAndExecutorHash: [32]byte{}, + OnRampAddress: gethcommon.LeftPadBytes(gethcommon.HexToAddress("0xf6eced5e96fff2de4f0ecd722beb57556fc443fd").Bytes(), 32), + OnRampAddressLength: 32, + OffRampAddress: offRampAddress.InstanceAddress().Bytes(), + OffRampAddressLength: 32, + Sender: gethcommon.HexToAddress("0000000000000000000000000000000000000003").Bytes(), + SenderLength: 20, + Receiver: contracts.HashedPartyFromString(partyReceiver).Bytes(), + ReceiverLength: 32, + DestBlob: nil, + DestBlobLength: 0, + TokenTransfer: tokenTransfer, + Data: nil, + DataLength: 0, + } + encodedMessage, err := msg.Encode() + require.NoError(t, err) + encodedMessageHex := hex.EncodeToString(encodedMessage) + + verifierResults, err := GenerateVerifierResults(encodedMessage, ccvSignerKeys[:2]) + require.NoError(t, err) + verifierResultsHex := hex.EncodeToString(verifierResults) + + res, err = receiverParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Create{Create: &apiv2.CreateCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#ccip-receiver", ModuleName: "CCIP.CCIPReceiver", EntityName: "CCIPReceiver"}, + CreateArguments: &apiv2.Record{Fields: []*apiv2.RecordField{ + {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-ccipreceiver-registry"}}}, + {Label: "owner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partyReceiver}}}, + {Label: "receiverFinalityConfig", Value: finalityConfigValueFromBlockConfirmations()}, + {Label: "requiredCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, + {Label: "optionalCCVs", Value: &apiv2.Value{Sum: &apiv2.Value_List{List: &apiv2.List{Elements: nil}}}}, + {Label: "optionalThreshold", Value: &apiv2.Value{Sum: &apiv2.Value_Int64{Int64: 0}}}, + }}, + }}, + }}, + ActAs: []string{partyReceiver}, + }, + }) + require.NoError(t, err) + ccipReceiverCid := extractCreatedContractId(res) + + receiverBalanceRatBefore, err := testhelpers.GetHoldingsBalance(ctx, receiverParticipant, ®istryInstrumentId, testhelpers.WithHoldingOwner(partyReceiver)) + require.NoError(t, err) + receiverBalanceBefore, _ := new(big.Float).SetRat(receiverBalanceRatBefore).Float64() + + ccipExecuteDisclosure, err := edsTesthelpers.GetCCIPExecuteDisclosure(ctx, ccipAPIClient, encodedMessageHex) + require.NoError(t, err) + ccvExecuteDisclosure, err := edsTesthelpers.GetCCVExecuteDisclosure(ctx, ccvAPIClient, encodedMessageHex, committeeVerifierAddress.InstanceAddress()) + require.NoError(t, err) + + poolExecuteDeps := registryPoolExecuteDeps{ + Client: registrarClient, + CcipClient: ccipClient, + RegistrarParty: partyRegistrar, + CcipParty: partyCCIP, + Bootstrap: bootstrap, + PoolInstanceID: registryExecutePoolInstanceID, + DefaultRateLimiterInstanceID: registryExecuteDefaultRLInstance, + CustomRateLimiterInstanceID: registryExecuteCustomRLInstance, + PoolAddress: poolAddr, + TokenAdminRegistryCID: tarCID, + RMNRemoteAddress: rmnRemoteAddress, + } + tokenPoolDisclosure := buildRegistryTokenPoolExecuteDisclosure(t, ctx, ccipParticipant, ccipParticipant, ccipAPIClient, poolExecuteDeps, hashedRegistryInstrumentId, true) + + executeArgs := receiver.Execute{ + Context: ccipExecuteDisclosure.ChoiceContext, + RouterCid: types.CONTRACT_ID(routerCid), + EncodedMessage: types.TEXT(encodedMessageHex), + TokenTransfer: &receiver.TokenTransferInput{ + TokenPoolCid: types.CONTRACT_ID(tokenPoolDisclosure.ContractId), + TokenReceiverParty: types.PARTY(partyReceiver), + PoolExtraContext: tokenPoolDisclosure.ChoiceContext, + }, + CcvInputs: []receiver.CCVInput{ + { + CcvCid: types.CONTRACT_ID(ccvExecuteDisclosure.ContractId), + VerifierResults: types.TEXT(verifierResultsHex), + CcvExtraContext: ccvExecuteDisclosure.ChoiceContext, + }, + }, + } + + _, err = receiverParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{Exercise: &apiv2.ExerciseCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#ccip-receiver", ModuleName: "CCIP.CCIPReceiver", EntityName: "CCIPReceiver"}, + ContractId: ccipReceiverCid, + Choice: "Execute", + ChoiceArgument: ledger.MapToValue(executeArgs), + }}, + }}, + ActAs: []string{partyReceiver}, + DisclosedContracts: slices.Concat( + tokenPoolDisclosure.DisclosedContracts, + ccipExecuteDisclosure.DisclosedContracts, + ccvExecuteDisclosure.DisclosedContracts, + ), + }, + }) + require.NoError(t, err) + t.Log("CCIPReceiver.Execute completed") + + receiverBalanceRatAfter, err := testhelpers.GetHoldingsBalance(ctx, receiverParticipant, ®istryInstrumentId, testhelpers.WithHoldingOwner(partyReceiver)) + require.NoError(t, err) + receiverBalanceAfter, _ := new(big.Float).SetRat(receiverBalanceRatAfter).Float64() + + actualTransferAmount := receiverBalanceAfter - receiverBalanceBefore + require.InDelta(t, tc.expectedTransferAmount, actualTransferAmount, 0.01, "Receiver balance should increase by transfer amount") + t.Logf("Receiver balance: %.2f -> %.2f (transferred %.2f)", receiverBalanceBefore, receiverBalanceAfter, actualTransferAmount) + + registrarQueryParticipant := ccipParticipant + registrarQueryParticipant.PartyID = partyRegistrar + + if tc.expectedDefaultLimiterTokens != "" { + defaultRateLimiter, err := findActiveRateLimiterByInstanceID(ctx, registrarQueryParticipant, registryExecuteDefaultRLInstance) + require.NoError(t, err) + require.Equal(t, tc.expectedDefaultLimiterTokens, getRateLimiterTokens(defaultRateLimiter)) + } + if tc.expectedCustomLimiterTokens != "" { + customRateLimiter, err := findActiveRateLimiterByInstanceID(ctx, registrarQueryParticipant, registryExecuteCustomRLInstance) + require.NoError(t, err) + require.Equal(t, tc.expectedCustomLimiterTokens, getRateLimiterTokens(customRateLimiter)) + } + + t.Log("Success") +} diff --git a/integration-tests/ccip/ccip_send_with_token_registry_test.go b/integration-tests/ccip/ccip_send_with_token_registry_test.go new file mode 100644 index 000000000..fde37c583 --- /dev/null +++ b/integration-tests/ccip/ccip_send_with_token_registry_test.go @@ -0,0 +1,815 @@ +package tests + +import ( + "context" + "encoding/binary" + "encoding/hex" + "errors" + "fmt" + "math/big" + "os" + "slices" + "strconv" + "strings" + "testing" + "time" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/crypto" + "github.com/google/uuid" + "github.com/rs/zerolog" + "github.com/rs/zerolog/log" + "github.com/stretchr/testify/require" + + chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/smartcontractkit/chainlink-ccip/deployment/lanes" + devenvcommon "github.com/smartcontractkit/chainlink-ccv/build/devenv/common" + "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink-deployments-framework/chain" + "github.com/smartcontractkit/chainlink-deployments-framework/datastore" + cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment" + cld_ops "github.com/smartcontractkit/chainlink-deployments-framework/operations" + "github.com/smartcontractkit/freeport" + "github.com/smartcontractkit/go-daml/pkg/service/ledger" + "github.com/smartcontractkit/go-daml/pkg/types" + + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/ccipruntime" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/committeeverifier" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + executorBinding "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/executor" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/sender" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/chainlink-canton/commonconfig" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/deployment/changesets" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/committee_verifier" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/executor" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/fee_quoter" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/global_config" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/offramp" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/onramp" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/per_party_router_factory" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/rmn_remote" + "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/token_admin_registry" + "github.com/smartcontractkit/chainlink-canton/deployment/sequences" + contractops "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract" + "github.com/smartcontractkit/chainlink-canton/eds/config" + "github.com/smartcontractkit/chainlink-canton/eds/service" + oapiCCIP "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/ccip" + oapiCCV "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/ccv" + oapiCommon "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/common" + oapiExecutor "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/executor" + oapiGlobal "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/global" + rkccip "github.com/smartcontractkit/chainlink-canton/registry-kit/ccip" + rkledger "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + edsTesthelpers "github.com/smartcontractkit/chainlink-canton/testhelpers/eds" + + _ "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v2_0_0/adapters" +) + +const ( + registrySendInstrumentID = "CCIP-REGISTRY-SEND" + registrySendPoolInstanceID = "ccip-registry-send-pool" + registrySendRLInstanceID = "ccip-registry-send-rl-out" + registrySendMintAmount = "10.0" +) + +// TestRegistryTokenPool_FullSendFlow exercises CCIPSender.Send with a Canton Registry Holding +// bridged through a registrar-owned BurnMintTokenPool (hybrid EDS: CCIP/CCV/Executor via EDS, +// Registry pool context assembled manually). +// +//nolint:paralleltest // Holding balance assertions require exclusive CTF env +func TestRegistryTokenPool_FullSendFlow(t *testing.T) { + env := testhelpers.NewTestEnvironment(t, testhelpers.WithNumberOfParticipants(2)) + + ccipParticipant := env.Chain.Participants[0] + senderParticipant := env.Chain.Participants[1] + + t.Cleanup(func() { + ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) + defer cancel() + testhelpers.ContractCleanup(t, ctx, env.Chain.Participants) + }) + + uploadRegistryDARs(t, ccipParticipant, senderParticipant) + + commonDar, err := contracts.GetDar(contracts.CCIPCommon, contracts.CurrentVersion) + require.NoError(t, err) + offRampDar, err := contracts.GetDar(contracts.CCIPOffRamp, contracts.CurrentVersion) + require.NoError(t, err) + onRampDar, err := contracts.GetDar(contracts.CCIPOnRamp, contracts.CurrentVersion) + require.NoError(t, err) + feeQuoterDar, err := contracts.GetDar(contracts.CCIPFeeQuoter, contracts.CurrentVersion) + require.NoError(t, err) + tokenAdminRegistryDar, err := contracts.GetDar(contracts.CCIPTokenAdminRegistry, contracts.CurrentVersion) + require.NoError(t, err) + committeeVerifierDar, err := contracts.GetDar(contracts.CCIPCommitteeVerifier, contracts.CurrentVersion) + require.NoError(t, err) + perPartyRouterDar, err := contracts.GetDar(contracts.CCIPPerPartyRouter, contracts.CurrentVersion) + require.NoError(t, err) + rmnDar, err := contracts.GetDar(contracts.CCIPRMN, contracts.CurrentVersion) + require.NoError(t, err) + ccipSenderDar, err := contracts.GetDar(contracts.CCIPSender, contracts.CurrentVersion) + require.NoError(t, err) + ccipExecutorDar, err := contracts.GetDar(contracts.CCIPExecutor, contracts.CurrentVersion) + require.NoError(t, err) + tokenPoolDar, err := contracts.GetDar(contracts.CCIPBurnMintTokenPool, contracts.CurrentVersion) + require.NoError(t, err) + ccipTestDar, err := contracts.GetDar(contracts.CCIPTest, contracts.CurrentVersion) + require.NoError(t, err) + + dars := [][]byte{commonDar, offRampDar, onRampDar, feeQuoterDar, tokenAdminRegistryDar, committeeVerifierDar, perPartyRouterDar, rmnDar, ccipSenderDar, ccipExecutorDar, tokenPoolDar, ccipTestDar} + packageIds, err := testhelpers.UploadDARstoMultipleParticipants(t.Context(), dars, ccipParticipant, senderParticipant) + require.NoError(t, err) + t.Logf("Uploaded CCIP DARs to all participants: %v", packageIds) + + partyCCIP := ccipParticipant.PartyID + partySender := senderParticipant.PartyID + partyRegistrar := testhelpers.AllocateParty(t, senderParticipant, "registry-send-registrar") + testhelpers.GrantCanActAs(t, senderParticipant, partyRegistrar) + t.Logf("Parties: CCIP=%s, Sender=%s, Registrar=%s", partyCCIP, partySender, partyRegistrar) + + ctx := t.Context() + senderClient := rkledger.NewCTFClient(senderParticipant) + ccipClient := rkledger.NewCTFClient(ccipParticipant) + + ccvSignerPubKeys := make([]string, 0, 3) + for range 3 { + pk, err := crypto.GenerateKey() + require.NoError(t, err) + pubKeyHex := hex.EncodeToString(crypto.FromECDSAPub(&pk.PublicKey)) + ccvSignerPubKeys = append(ccvSignerPubKeys, pubKeyHex) + } + + versionTag := "e9a05a20" + ccvQualifier := devenvcommon.DefaultCommitteeVerifierQualifier + remoteSelector := chainsel.ETHEREUM_TESTNET_SEPOLIA.Selector + + scanProxyClient, tokenMetadataClient, transferInstructionClient, err := testhelpers.NewValidatorAPIClients(ccipParticipant) + require.NoError(t, err) + + registryAdmin, err := testhelpers.GetRegistryAdmin(ctx, tokenMetadataClient) + require.NoError(t, err) + + nativeInstrumentId := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(registryAdmin), + Id: types.TEXT("Amulet"), + } + registryInstrumentId := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(partyRegistrar), + Id: types.TEXT(registrySendInstrumentID), + } + hashedRegistryInstrumentId := contracts.EncodeInstrumentID(registryInstrumentId) + + reporter := cld_ops.NewMemoryReporter() + bundle := cld_ops.NewBundle(t.Context, logger.Test(t), reporter) + cldfEnv := cldf.Environment{ + Logger: logger.Test(t), + GetContext: t.Context, + DataStore: datastore.NewMemoryDataStore().Seal(), + BlockChains: chain.NewBlockChainsFromSlice([]chain.BlockChain{env.Chain}), + OperationsBundle: bundle, + } + + tokenPriceExponentUSDCents := uint64(1e6) + tokenPriceExponentUSD := 1e2 * tokenPriceExponentUSDCents + + out, err := changesets.DeployChainContracts{}.Apply(cldfEnv, changesets.CantonCSDeps[changesets.DeployChainContractsConfig]{ + ChainSelector: env.Chain.ChainSelector(), + Participant: 0, + Config: changesets.DeployChainContractsConfig{ + Params: sequences.DeployChainContractsParams{ + CCIPOwnerParty: partyCCIP, + RMNOwnerParty: partyCCIP, + CommitteeVerifiers: []sequences.CommitteeVerifierParams{ + { + Qualifier: ccvQualifier, + Template: committeeverifier.CommitteeVerifier{ + Owner: types.PARTY(partyCCIP), + CcipOwner: types.PARTY(partyCCIP), + VersionTag: types.TEXT(versionTag), + MessageSentObservers: nil, + StorageLocations: []types.TEXT{"ipfs://test-registry-send"}, + StorageLocationsAdmin: types.PARTY(partyCCIP), + PendingStorageLocationsAdmin: types.PARTY(partyCCIP), + Deps: committeeverifier.CommitteeVerifierDeps{}, + }, + }, + }, + Executors: []sequences.ExecutorParams{ + { + Qualifier: devenvcommon.DefaultExecutorQualifier, + Template: executorBinding.Executor{ + Owner: types.PARTY(partyCCIP), + MaxCCVsPerMsg: 10, + DynamicConfig: executorBinding.DynamicConfig{ + FeeAggregator: nil, + AllowedFinalityConfig: core.FinalityConfig{WaitForFinality: &types.UNIT{}}, + CcvAllowlistEnabled: false, + }, + AllowedCCVs: nil, + }, + }, + }, + GlobalConfig: sequences.GlobalConfigParams{ + Template: core.GlobalConfig{ + CcipOwner: "", + ChainSelector: types.NUMERIC(strconv.FormatUint(chainsel.CANTON_LOCALNET.Selector, 10)), + }, + }, + RMNRemote: sequences.RMNRemoteParams{ + Template: core.RMNRemote{ + CcipOwner: "", + RmnOwner: types.PARTY(partyCCIP), + CursedSubjects: nil, + }, + }, + FeeQuoterConfig: sequences.FeeQuoterParams{ + Template: core.FeeQuoter{ + PriceUpdaters: []types.PARTY{types.PARTY(partyCCIP)}, + }, + USDPerNative: big.NewInt(int64(1 * tokenPriceExponentUSD)), + }, + NativeInstrumentId: nativeInstrumentId, + }, + }, + }) + require.NoError(t, err) + err = out.DataStore.Merge(cldfEnv.DataStore) + require.NoError(t, err) + cldfEnv.DataStore = out.DataStore.Seal() + + globalConfigRef, globalConfigAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), global_config.ContractType, global_config.Version, "") + require.NoError(t, err) + _, feeQuoterAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), fee_quoter.ContractType, fee_quoter.Version, "") + require.NoError(t, err) + _, onRampAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), onramp.ContractType, onramp.Version, "") + require.NoError(t, err) + _, offRampAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), offramp.ContractType, offramp.Version, "") + require.NoError(t, err) + committeeVerifierRef, committeeVerifierAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), committee_verifier.ContractType, committee_verifier.Version, ccvQualifier) + require.NoError(t, err) + _, tokenAdminRegistryAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), token_admin_registry.ContractType, token_admin_registry.Version, "") + require.NoError(t, err) + _, rmnRemoteAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), rmn_remote.ContractType, rmn_remote.Version, "") + require.NoError(t, err) + _, perPartyRouterFactoryAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), per_party_router_factory.ContractType, per_party_router_factory.Version, "") + require.NoError(t, err) + executorRef, executorAddress, err := testhelpers.ResolveAddressFromDatastore(cldfEnv.DataStore, env.Chain.ChainSelector(), executor.ContractType, executor.Version, devenvcommon.DefaultExecutorQualifier) + require.NoError(t, err) + + ccvFeeUSDCents := 7 + feeQuoterDestChainConfig := lanes.FeeQuoterDestChainConfig{ + IsEnabled: true, + MaxDataBytes: 30_000, + MaxPerMsgGasLimit: 3_000_000, + DestGasOverhead: 300_000, + DestGasPerPayloadByteBase: 16, + ChainFamilySelector: binary.BigEndian.Uint32([]byte{0x28, 0x12, 0xd5, 0x2c}), + DefaultTokenFeeUSDCents: 10, + DefaultTokenDestGasOverhead: 90_000, + DefaultTxGasLimit: 200_000, + NetworkFeeUSDCents: 25, + V2Params: &lanes.FeeQuoterV2Params{ + LinkFeeMultiplierPercent: 100, + USDPerUnitGas: big.NewInt(38), + }, + } + + deployLaneLegReport, err := cld_ops.ExecuteSequence(cldfEnv.OperationsBundle, sequences.ConfigureLaneLegAsSourceWithInput, cldfEnv.BlockChains, sequences.ConfigureLaneLegInput{ + DataStore: cldfEnv.DataStore, + Lane: lanes.UpdateLanesInput{ + Source: &lanes.ChainDefinition{ + Selector: env.Chain.ChainSelector(), + CommitteeVerifiers: []lanes.CommitteeVerifierConfig[datastore.AddressRef]{ + { + CommitteeVerifier: []datastore.AddressRef{committeeVerifierRef}, + RemoteChains: map[uint64]lanes.CommitteeVerifierRemoteChainConfig{ + remoteSelector: { + AllowlistEnabled: false, + FeeUSDCents: uint16(ccvFeeUSDCents), + GasForVerification: 50_000, + PayloadSizeBytes: 6*64 + 2*32, + SignatureConfig: lanes.CommitteeVerifierSignatureQuorumConfig{ + Signers: ccvSignerPubKeys, + Threshold: 2, + }, + }, + }, + }, + }, + LaneMandatedOutboundCCVs: []datastore.AddressRef{committeeVerifierRef}, + CantonLaneConfig: &lanes.CantonLaneConfig{ + GlobalConfig: globalConfigRef, + }, + DefaultExecutor: executorRef, + FeeQuoter: feeQuoterAddress.InstanceAddress().Bytes(), + OnRamp: onRampAddress.InstanceAddress().Bytes(), + OffRamp: offRampAddress.InstanceAddress().Bytes(), + }, + Dest: &lanes.ChainDefinition{ + Selector: remoteSelector, + AddressBytesLength: 20, + FeeQuoterDestChainConfig: feeQuoterDestChainConfig, + ExecutorDestChainConfig: lanes.ExecutorDestChainConfig{ + USDCentsFee: 50, + Enabled: true, + }, + OnRamp: hexutil.MustDecode("0xf6eced5e96fff2de4f0ecd722beb57556fc443fd"), + OffRamp: hexutil.MustDecode("0xd8c9ec8cad3fb34aeca3ddbebfabe9f28a9bfaed"), + Router: hexutil.MustDecode("0xe3ddcb2fde5d27a33c450fddc54a3f9bb2ecaa9f"), + }, + IsDisabled: false, + TestRouter: false, + ExtraConfigs: lanes.ExtraConfigs{}, + }, + }) + require.NoError(t, err) + runningDs := datastore.NewMemoryDataStore() + for _, address := range deployLaneLegReport.Output.Addresses { + err = runningDs.Addresses().Add(address) + require.NoError(t, err) + } + err = runningDs.Merge(cldfEnv.DataStore) + require.NoError(t, err) + cldfEnv.DataStore = runningDs.Seal() + + bootstrap, err := registry.BootstrapServices(ctx, senderClient, partyRegistrar, registrySendInstrumentID) + require.NoError(t, err) + + _, err = registry.MintViaAllocationFactory(ctx, senderClient, bootstrap, partySender, registrySendMintAmount) + require.NoError(t, err) + + tokenTransferFeeUSDCents := 10 + tokenTransferFeeBps := 500 + remotePoolAddress := hexutil.MustDecode("0x7e3febbdaf80e7e96c1ae107508ec3fafc36d7f3") + remoteTokenAddress := hexutil.MustDecode("0xacdafefb07bff5b120b7afa6ea777cf7eabacc0d") + + now := time.Now() + outboundRLAddr, err := rkccip.DeployOutboundRateLimiterForOwner(ctx, senderClient, partyRegistrar, core.RateLimiter{ + InstanceId: types.TEXT(registrySendRLInstanceID), + PoolInstanceId: types.TEXT(registrySendPoolInstanceID), + PoolOwner: types.PARTY(partyRegistrar), + RemoteChainSelector: types.NUMERIC(strconv.FormatUint(remoteSelector, 10)), + Direction: core.RateLimitDirectionRateLimitDirection_Outbound, + Mode: core.RateLimitModeRateLimitMode_DefaultFinality, + IsEnabled: true, + Capacity: types.NUMERIC("10000000000"), + Rate: types.NUMERIC("10000000000"), + Tokens: types.NUMERIC("10000000000"), + LastUpdated: types.TIMESTAMP(now), + }) + require.NoError(t, err) + + poolAddr, err := rkccip.DeployBurnMintPoolForOwner(ctx, senderClient, rkccip.PoolDeployDeps{ + CcipOwner: partyCCIP, + TokenAdminRegistry: tokenAdminRegistryAddress, + RMNRemote: rmnRemoteAddress, + FeeQuoter: feeQuoterAddress, + }, partyRegistrar, registryInstrumentId, registrySendPoolInstanceID, + map[types.NUMERIC]burnminttokenpool.RemoteChainConfig{ + types.NUMERIC(strconv.FormatUint(remoteSelector, 10)): { + RemotePools: []types.TEXT{types.TEXT(hex.EncodeToString(remotePoolAddress))}, + RemoteTokenAddress: types.TEXT(hex.EncodeToString(remoteTokenAddress)), + FinalityConfig: core.FinalityConfig{WaitForFinality: &types.UNIT{}}, + OutboundRateLimiter: outboundRLAddr.Binding(), + }, + }, + map[types.NUMERIC]burnminttokenpool.TokenTransferFeeConfig{ + types.NUMERIC(strconv.FormatUint(remoteSelector, 10)): { + IsEnabled: true, + DestGasOverhead: types.INT64(25_000), + DestBytesOverhead: types.INT64(32), + FeeUSDCents: types.NUMERIC(strconv.Itoa(tokenTransferFeeUSDCents)), + FeeBps: types.NUMERIC(strconv.Itoa(tokenTransferFeeBps)), + }, + }, + ) + require.NoError(t, err) + + initialTarCID, err := contractops.FindActiveContractIDByInstanceAddress( + ctx, + ccipParticipant.LedgerServices.State, + []string{partyCCIP}, + core.TokenAdminRegistry{}.GetTemplateID(), + tokenAdminRegistryAddress.InstanceAddress(), + ) + require.NoError(t, err) + + tokenConfigCID, tarCID, err := rkccip.RegisterTokenPoolViaClient(ctx, ccipClient, rkccip.RegisterTokenPoolClientInput{ + TokenAdminRegistryCID: initialTarCID, + InstrumentId: registryInstrumentId, + PoolInstanceID: registrySendPoolInstanceID, + CcipParty: partyCCIP, + PoolOwnerParty: partyRegistrar, + PoolOwnerClient: senderClient, + }) + require.NoError(t, err) + + _, err = rkccip.SetBurnMintFactory(ctx, senderClient, rkccip.SetBurnMintFactoryInput{ + TokenAdminRegistryCID: tarCID, + TokenConfigCID: tokenConfigCID, + InstrumentId: registryInstrumentId, + BurnMintFactoryCID: bootstrap.AllocationFactory, + CcipParty: partyCCIP, + PoolOwnerParty: partyRegistrar, + CcipClient: ccipClient, + PoolOwnerClient: senderClient, + }) + require.NoError(t, err) + + edsParticipant := env.Chain.Participants[0] + edsToken, _ := edsParticipant.TokenSource.Token() + edsPort := freeport.GetOne(t) + go func() { + log.Info().Msg("Running EDS...") + err := service.RunEDS(ctx, log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.TraceLevel), &config.Config{ + ChainSelector: strconv.FormatUint(env.Chain.ChainSelector(), 10), + Server: config.ServerConfig{ + Host: "0.0.0.0", + Port: uint16(edsPort), + }, + Node: config.NodeConfig{ + URL: edsParticipant.Endpoints.GRPCLedgerAPIURL, + AuthConfig: commonconfig.AuthConfig{ + Type: commonconfig.AuthTypeInsecureStatic, + UserID: edsParticipant.UserID, + JWT: edsToken.AccessToken, + }, + MaxRetries: 0, + }, + CCIPAPIConfig: config.CCIPAPIConfig{ + Enabled: true, + PerPartyRouterFactory: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: perPartyRouterFactoryAddress.InstanceAddress(), + }, + OnRamp: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: onRampAddress.InstanceAddress(), + }, + OffRamp: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: offRampAddress.InstanceAddress(), + }, + GlobalConfig: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: globalConfigAddress.InstanceAddress(), + }, + TokenAdminRegistry: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: tokenAdminRegistryAddress.InstanceAddress(), + }, + RMNRemote: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: rmnRemoteAddress.InstanceAddress(), + }, + FeeQuoter: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: feeQuoterAddress.InstanceAddress(), + }, + }, + CCVAPIConfig: config.CCVAPIConfig{ + Enabled: true, + CCVs: []config.CCV{ + { + ContractIdentifier: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: committeeVerifierAddress.InstanceAddress(), + }, + }, + }, + }, + ExecutorAPIConfig: config.ExecutorAPIConfig{ + Enabled: true, + Executors: []config.Executor{ + { + ContractIdentifier: config.ContractIdentifier{ + PartyID: partyCCIP, + InstanceAddress: executorAddress.InstanceAddress(), + }, + }, + }, + }, + // TokenPool API omitted: hybrid send assembles Registry pool context manually. + // Enabling it would register partyRegistrar with the instrument-holding store on the + // CCIP participant, which cannot backfill holdings hosted on the sender participant. + }) + log.Info().Err(err).Msg("EDS terminated") + if !errors.Is(err, context.Canceled) { + log.Error().Err(err).Msg("EDS server exited with error") + t.Fail() + } + }() + + globalAPIClient, err := oapiGlobal.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + ccipAPIClient, err := oapiCCIP.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + ccvAPIClient, err := oapiCCV.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + executorAPIClient, err := oapiExecutor.NewClientWithResponses(fmt.Sprintf("http://localhost:%d", edsPort)) + require.NoError(t, err) + + time.Sleep(1 * time.Second) + + perPartyRouterFactoryDisclosure, err := edsTesthelpers.GetPerPartyRouterFactoryDisclosure(ctx, ccipAPIClient, partySender) + require.NoError(t, err) + + res, err := senderParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{Exercise: &apiv2.ExerciseCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#" + ccipruntime.PackageName, ModuleName: "CCIP.PerPartyRouter", EntityName: "PerPartyRouterFactory"}, + ContractId: perPartyRouterFactoryDisclosure.ContractId, + Choice: "CreateRouter", + ChoiceArgument: &apiv2.Value{Sum: &apiv2.Value_Record{Record: &apiv2.Record{Fields: []*apiv2.RecordField{ + {Label: "partyOwner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partySender}}}, + {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-router-registry-send"}}}, + }}}}, + }}, + }}, + ActAs: []string{partySender}, + DisclosedContracts: perPartyRouterFactoryDisclosure.DisclosedContracts, + }, + }) + require.NoError(t, err) + routerCid := extractCreatedContractId(res) + require.NotEmpty(t, routerCid) + + testPayload := []byte("Hello CCIP Registry - full send test!") + testPayloadHex := hex.EncodeToString(testPayload) + + res, err = senderParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Create{Create: &apiv2.CreateCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#ccip-sender", ModuleName: "CCIP.CCIPSender", EntityName: "CCIPSender"}, + CreateArguments: &apiv2.Record{Fields: []*apiv2.RecordField{ + {Label: "instanceId", Value: &apiv2.Value{Sum: &apiv2.Value_Text{Text: "test-ccipsender-registry"}}}, + {Label: "owner", Value: &apiv2.Value{Sum: &apiv2.Value_Party{Party: partySender}}}, + }}, + }}, + }}, + ActAs: []string{partySender}, + }, + }) + require.NoError(t, err) + ccipSenderCid := extractCreatedContractId(res) + + feeTokenHoldingCid, err := testhelpers.MintAMT(ctx, senderParticipant, tokenMetadataClient, transferInstructionClient, scanProxyClient, partySender, strconv.Itoa(100*int(tokenPriceExponentUSD))) + require.NoError(t, err) + + holdingRows, err := testhelpers.ListHoldingsForInstrument(ctx, senderParticipant, ®istryInstrumentId, + testhelpers.WithHoldingOwner(partySender), testhelpers.WithUnlockedHoldingsOnly()) + require.NoError(t, err) + require.NotEmpty(t, holdingRows) + senderHoldingCids := make([]types.CONTRACT_ID, len(holdingRows)) + for i, row := range holdingRows { + senderHoldingCids[i] = types.CONTRACT_ID(row.ContractID) + } + + transferFactoryCid, transferFactoryDisclosures, choiceContextRaw, err := testhelpers.GetTransferFactory(ctx, transferInstructionClient, registryAdmin, partySender, partyCCIP) + require.NoError(t, err) + choiceContext, err := testhelpers.ChoiceContextFromData(choiceContextRaw) + require.NoError(t, err) + transferFactoryContextValues := testhelpers.ExtractChoiceContextValues(choiceContext) + + const tokenTransferAmountDecimal = "0.0000010000" + + senderBalanceBefore, err := testhelpers.GetHoldingsBalance(ctx, senderParticipant, &nativeInstrumentId) + require.NoError(t, err) + senderRegistryBalanceBefore, err := testhelpers.GetHoldingsBalance(ctx, senderParticipant, ®istryInstrumentId, testhelpers.WithHoldingOwner(partySender)) + require.NoError(t, err) + + receiver := hexutil.MustDecode("0xcf8def9adfe3dd90b3dffe42c8eabbf7cd4ee6ca") + receiverHex := hex.EncodeToString(receiver) + + executorRawOrHashedAddress := oapiCommon.RawOrHashedAddress{} + _ = executorRawOrHashedAddress.FromRawInstanceAddress(executorAddress.String()) + msg := oapiCommon.Message{ + DestinationChainSelector: strconv.FormatUint(remoteSelector, 10), + Executor: struct { + Address *oapiCommon.RawOrHashedAddress `json:"address,omitempty"` + Type oapiCommon.MessageExecutorType `json:"type"` + }{ + Type: oapiCommon.WithAddress, + Address: &executorRawOrHashedAddress, + }, + FeeToken: oapiCommon.InstrumentId{ + Admin: oapiCommon.PartyId(nativeInstrumentId.Admin), + Id: string(nativeInstrumentId.Id), + }, + TokenTransfer: &oapiCommon.TokenTransfer{ + Amount: tokenTransferAmountDecimal, + Token: oapiCommon.InstrumentId{ + Admin: oapiCommon.PartyId(registryInstrumentId.Admin), + Id: string(registryInstrumentId.Id), + }, + }, + } + + poolSendDeps := registryPoolSendDeps{ + Client: senderClient, + CcipClient: ccipClient, + RegistrarParty: partyRegistrar, + CcipParty: partyCCIP, + Bootstrap: bootstrap, + PoolInstanceID: registrySendPoolInstanceID, + RateLimiterInstanceID: registrySendRLInstanceID, + PoolAddress: poolAddr, + TokenAdminRegistryAddress: tokenAdminRegistryAddress, + TokenAdminRegistryCID: tarCID, + RMNRemoteAddress: rmnRemoteAddress, + } + + buildSendBundle := func(enableResultContracts bool) (sender.Send, []*apiv2.DisclosedContract) { + tokenPoolSendDisclosure := buildRegistryTokenPoolSendDisclosure(t, ctx, senderParticipant, ccipParticipant, ccipAPIClient, poolSendDeps, hashedRegistryInstrumentId, enableResultContracts) + ccipSendDisclosure, err := edsTesthelpers.GetCCIPSendDisclosure(ctx, ccipAPIClient, msg, nil, tokenPoolSendDisclosure.RequiredCCVs) + require.NoError(t, err) + ccvAddressEDS, err := contracts.RawInstanceAddressFromString(ccipSendDisclosure.CCVs[0]) + require.NoError(t, err) + executorAddressEDS, err := contracts.RawInstanceAddressFromString(*ccipSendDisclosure.Executor) + require.NoError(t, err) + ccvSendDisclosure, err := edsTesthelpers.GetCCVSendDisclosure(ctx, ccvAPIClient, msg, ccvAddressEDS.InstanceAddress()) + require.NoError(t, err) + executorSendDisclosure, err := edsTesthelpers.GetExecutorSendDisclosure(ctx, executorAPIClient, msg, executorAddressEDS.InstanceAddress(), ccipSendDisclosure.CCVs) + require.NoError(t, err) + + sendArgs := sender.Send{ + Context: ccipSendDisclosure.ChoiceContext, + RouterCid: types.CONTRACT_ID(routerCid), + DestinationChainSelector: types.NUMERIC(strconv.FormatUint(remoteSelector, 10)), + Message: core.Canton2AnyMessage{ + Receiver: types.TEXT(receiverHex), + Payload: types.TEXT(testPayloadHex), + TokenTransfer: &core.TokenTransfer{ + Token: registryInstrumentId, + Amount: types.NUMERIC(tokenTransferAmountDecimal), + }, + FeeToken: nativeInstrumentId, + ExtraArgs: core.ExtraArgs{ + V3: &core.GenericExtraArgsV3{ + GasLimit: 0, + Ccvs: []core.CCVExtraArg{ + { + CcvAddress: committeeVerifierAddress.Binding(), + CcvArgs: types.TEXT(""), + }, + }, + Executor: core.ExecutorExtraArg{ + ExecutorWithAddress: &core.ExecutorWithAddress{ + ExecutorAddress: executorAddress.Binding(), + ExecutorArgs: types.TEXT(""), + }, + }, + TokenReceiver: types.TEXT(""), + TokenArgs: types.TEXT(""), + }, + }, + }, + FeeTokenInput: sender.FeeTokenInput{ + SenderInputCids: []types.CONTRACT_ID{types.CONTRACT_ID(feeTokenHoldingCid)}, + FeeTokenConfigCid: types.CONTRACT_ID(ccipSendDisclosure.FeeTokenConfigCid), + FeeTokenTransferFactory: types.CONTRACT_ID(transferFactoryCid), + FeeTokenExtraArgs: splice_api_token_metadata_v1.ExtraArgs{ + Context: splice_api_token_metadata_v1.ChoiceContext{ + Values: transferFactoryContextValues, + }, + Meta: splice_api_token_metadata_v1.Metadata{Values: map[string]types.TEXT{}}, + }, + }, + CcvSendInputs: []sender.CCVSendInput{ + { + CcvAddress: ccvSendDisclosure.Address.Binding(), + CcvCid: types.CONTRACT_ID(ccvSendDisclosure.ContractId), + CcvExtraContext: ccvSendDisclosure.ChoiceContext, + }, + }, + TokenTransferInput: &sender.TokenTransferInput{ + SenderInputCids: senderHoldingCids, + TokenPoolCid: types.CONTRACT_ID(tokenPoolSendDisclosure.ContractId), + PoolExtraContext: tokenPoolSendDisclosure.ChoiceContext, + }, + ExecutorInput: &sender.ExecutorInput{ + ExecutorCid: types.CONTRACT_ID(executorSendDisclosure.ContractId), + ExecutorExtraContext: executorSendDisclosure.ChoiceContext, + }, + } + + sendDisclosures := testhelpers.DeduplicateDisclosedContracts(slices.Concat( + transferFactoryDisclosures, + ccipSendDisclosure.DisclosedContracts, + tokenPoolSendDisclosure.DisclosedContracts, + ccvSendDisclosure.DisclosedContracts, + executorSendDisclosure.DisclosedContracts, + )...) + + return sendArgs, sendDisclosures + } + + sendArgs, sendDisclosures := buildSendBundle(false) + quotedFee := quoteCCIPSenderFee(t, senderParticipant, partySender, ccipSenderCid, sendArgs, sendDisclosures) + feeStr := strings.TrimSuffix(string(quotedFee.FeeTokenAmount), ".") + poolFeeStr := strings.TrimSuffix(string(quotedFee.PoolFeeTokenAmount), ".") + require.NotEqual(t, "0", feeStr) + require.NotEqual(t, "0", poolFeeStr) + + disclosedContracts, err := edsTesthelpers.GetGlobalDisclosureBatch(ctx, globalAPIClient, []contracts.InstanceAddress{ + perPartyRouterFactoryAddress.InstanceAddress(), + globalConfigAddress.InstanceAddress(), + feeQuoterAddress.InstanceAddress(), + onRampAddress.InstanceAddress(), + offRampAddress.InstanceAddress(), + tokenAdminRegistryAddress.InstanceAddress(), + rmnRemoteAddress.InstanceAddress(), + committeeVerifierAddress.InstanceAddress(), + executorAddress.InstanceAddress(), + }) + require.NoError(t, err) + require.Len(t, disclosedContracts, 9) + + var sendRes *apiv2.SubmitAndWaitForTransactionResponse + var enableResultContracts bool + for _, enable := range []bool{false, true} { + sendArgs, sendDisclosures = buildSendBundle(enable) + + sendRes, err = senderParticipant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{Exercise: &apiv2.ExerciseCommand{ + TemplateId: &apiv2.Identifier{PackageId: "#ccip-sender", ModuleName: "CCIP.CCIPSender", EntityName: "CCIPSender"}, + ContractId: ccipSenderCid, + Choice: "Send", + ChoiceArgument: ledger.MapToValue(sendArgs), + }}, + }}, + ActAs: []string{partySender}, + DisclosedContracts: sendDisclosures, + }, + }) + if err == nil { + enableResultContracts = enable + break + } + t.Logf("CCIPSender.Send with enable-result-contracts=%v failed: %v", enable, err) + } + require.NoError(t, err, "CCIPSender.Send failed with both enable-result-contracts values") + t.Logf("CCIPSender.Send succeeded with enable-result-contracts=%v", enableResultContracts) + + var returnedMessageId string + var returnedEncodedMessage string + for _, event := range sendRes.GetTransaction().GetEvents() { + if e, ok := event.GetEvent().(*apiv2.Event_Created); ok { + if e.Created.GetTemplateId().GetEntityName() == "CCIPMessageSent" { + fields := e.Created.GetCreateArguments().GetFields() + if len(fields) >= 5 { + eventField := fields[4].GetValue().GetRecord() + if eventField != nil { + for _, field := range eventField.Fields { + if field.GetLabel() == "messageId" { + returnedMessageId = field.GetValue().GetText() + } + if field.GetLabel() == "encodedMessage" { + returnedEncodedMessage = field.GetValue().GetText() + } + } + } + } + + break + } + } + } + require.NotEmpty(t, returnedMessageId) + require.NotEmpty(t, returnedEncodedMessage) + require.Equal(t, int64(9500), extractTokenTransferAmountFromEncodedMessageHex(t, returnedEncodedMessage)) + + senderBalanceAfter, err := testhelpers.GetHoldingsBalance(ctx, senderParticipant, &nativeInstrumentId) + require.NoError(t, err) + senderDelta := new(big.Rat).Sub(senderBalanceBefore, senderBalanceAfter) + require.Positive(t, senderDelta.Sign()) + + quotedFeeAmount, ok := new(big.Rat).SetString(feeStr) + require.True(t, ok) + expectedSenderDelta := new(big.Rat).Set(quotedFeeAmount) + require.Zero(t, senderDelta.Cmp(expectedSenderDelta)) + + senderRegistryBalanceAfter, err := testhelpers.GetHoldingsBalance(ctx, senderParticipant, ®istryInstrumentId, testhelpers.WithHoldingOwner(partySender)) + require.NoError(t, err) + registryDelta := new(big.Rat).Sub(senderRegistryBalanceBefore, senderRegistryBalanceAfter) + tokenTransferAmountRat, ok := new(big.Rat).SetString(tokenTransferAmountDecimal) + require.True(t, ok) + require.Positive(t, registryDelta.Sign()) + require.Zero(t, registryDelta.Cmp(tokenTransferAmountRat)) + + t.Logf("Registry send completed: messageId=%s", returnedMessageId) +} diff --git a/integration-tests/ccip/registry_send_helpers_test.go b/integration-tests/ccip/registry_send_helpers_test.go new file mode 100644 index 000000000..d733521a4 --- /dev/null +++ b/integration-tests/ccip/registry_send_helpers_test.go @@ -0,0 +1,222 @@ +package tests + +import ( + "context" + "fmt" + "testing" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" + "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + "github.com/smartcontractkit/chainlink-canton/contracts" + contractops "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract" + oapiCCIP "github.com/smartcontractkit/chainlink-canton/openapi/gen/eds/ccip" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ccip" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + edsTesthelpers "github.com/smartcontractkit/chainlink-canton/testhelpers/eds" +) + +func uploadRegistryDARs(t *testing.T, participants ...canton.Participant) { + t.Helper() + + dars, err := registry.LoadUtilityDARs() + require.NoError(t, err, "load registry utility DARs") + _, err = testhelpers.UploadDARstoMultipleParticipants(t.Context(), dars, participants...) + require.NoError(t, err, "upload registry utility DARs") +} + +type registryPoolSendDeps struct { + Client ledger.Client + CcipClient ledger.Client + RegistrarParty string + CcipParty string + Bootstrap registry.BootstrapResult + PoolInstanceID string + RateLimiterInstanceID string + PoolAddress contracts.RawInstanceAddress + TokenAdminRegistryAddress contracts.RawInstanceAddress + TokenAdminRegistryCID string + RMNRemoteAddress contracts.RawInstanceAddress +} + +func findContractCIDByInstanceID( + ctx context.Context, + client ledger.Client, + queryParty string, + template interface{ GetTemplateID() string }, + instanceID string, +) (string, error) { + tpl := contracts.IdentifierFromBinding(template) + active, err := testhelpers.ListActiveContractsByTemplateId(ctx, client.ForParty(queryParty), tpl) + if err != nil { + return "", err + } + for _, ac := range active { + for _, field := range ac.GetCreatedEvent().GetCreateArguments().GetFields() { + if field.GetLabel() == "instanceId" && field.GetValue().GetText() == instanceID { + return ac.GetCreatedEvent().GetContractId(), nil + } + } + } + + return "", fmt.Errorf("contract with instanceId %s not found", instanceID) +} + +func contractCIDByInstance( + t *testing.T, + ctx context.Context, + participant canton.Participant, + party string, + template interface{ GetTemplateID() string }, + instanceAddr contracts.InstanceAddress, +) string { + t.Helper() + + cid, err := contractops.FindActiveContractIDByInstanceAddress( + ctx, + participant.LedgerServices.State, + []string{party}, + template.GetTemplateID(), + instanceAddr, + ) + require.NoError(t, err) + + return cid +} + +func buildRegistryTokenPoolSendDisclosure( + t *testing.T, + ctx context.Context, + registrarParticipant canton.Participant, + ccipParticipant canton.Participant, + ccipAPIClient oapiCCIP.ClientWithResponsesInterface, + deps registryPoolSendDeps, + hashedInstrumentID contracts.EncodedInstrumentID, + enableResultContracts bool, +) *edsTesthelpers.TokenPoolSendDisclosure { + t.Helper() + + poolAddressEDS, err := edsTesthelpers.GetTokenPoolForToken(ctx, ccipAPIClient, hashedInstrumentID) + require.NoError(t, err) + + outboundRLCID, err := findContractCIDByInstanceID(ctx, deps.Client, deps.RegistrarParty, core.RateLimiter{}, deps.RateLimiterInstanceID) + require.NoError(t, err) + + poolCID := contractCIDByInstance(t, ctx, registrarParticipant, deps.RegistrarParty, burnminttokenpool.BurnMintTokenPool{}, deps.PoolAddress.InstanceAddress()) + rmnCID := contractCIDByInstance(t, ctx, ccipParticipant, deps.CcipParty, core.RMNRemote{}, deps.RMNRemoteAddress.InstanceAddress()) + + choiceContext := ccip.RegistryPoolSendExtraContextV1( + outboundRLCID, + deps.Bootstrap.AllocationFactory, + deps.Bootstrap.InstrumentConfiguration, + enableResultContracts, + ) + + poolDisclosures, err := ccip.DisclosePoolSendContracts(ctx, deps.Client, ccip.PoolSendInput{ + RegistrarParty: deps.RegistrarParty, + CcipParty: deps.CcipParty, + CcipClient: deps.CcipClient, + InstrumentConfiguration: deps.Bootstrap.InstrumentConfiguration, + AllocationFactory: deps.Bootstrap.AllocationFactory, + PoolCID: poolCID, + TokenAdminRegistryCID: deps.TokenAdminRegistryCID, + OutboundRateLimiterCID: outboundRLCID, + RMNRemoteCID: rmnCID, + }) + require.NoError(t, err) + + var disclosedContracts []*apiv2.DisclosedContract + for _, d := range poolDisclosures.All() { + if d != nil { + disclosedContracts = append(disclosedContracts, d) + } + } + + return &edsTesthelpers.TokenPoolSendDisclosure{ + ContractId: poolCID, + Address: poolAddressEDS, + DisclosedContracts: disclosedContracts, + ChoiceContext: choiceContext, + RequiredCCVs: nil, + } +} + +type registryPoolExecuteDeps struct { + Client ledger.Client + CcipClient ledger.Client + RegistrarParty string + CcipParty string + Bootstrap registry.BootstrapResult + PoolInstanceID string + DefaultRateLimiterInstanceID string + CustomRateLimiterInstanceID string + PoolAddress contracts.RawInstanceAddress + TokenAdminRegistryCID string + RMNRemoteAddress contracts.RawInstanceAddress +} + +func buildRegistryTokenPoolExecuteDisclosure( + t *testing.T, + ctx context.Context, + registrarParticipant canton.Participant, + ccipParticipant canton.Participant, + ccipAPIClient oapiCCIP.ClientWithResponsesInterface, + deps registryPoolExecuteDeps, + hashedInstrumentID contracts.EncodedInstrumentID, + customFinality bool, +) *edsTesthelpers.TokenPoolExecuteDisclosure { + t.Helper() + + poolAddressEDS, err := edsTesthelpers.GetTokenPoolForToken(ctx, ccipAPIClient, hashedInstrumentID) + require.NoError(t, err) + + rlInstanceID := deps.DefaultRateLimiterInstanceID + if customFinality { + rlInstanceID = deps.CustomRateLimiterInstanceID + } + inboundRLCID, err := findContractCIDByInstanceID(ctx, deps.Client, deps.RegistrarParty, core.RateLimiter{}, rlInstanceID) + require.NoError(t, err) + + poolCID := contractCIDByInstance(t, ctx, registrarParticipant, deps.RegistrarParty, burnminttokenpool.BurnMintTokenPool{}, deps.PoolAddress.InstanceAddress()) + rmnCID := contractCIDByInstance(t, ctx, ccipParticipant, deps.CcipParty, core.RMNRemote{}, deps.RMNRemoteAddress.InstanceAddress()) + + choiceContext := ccip.RegistryPoolSendExtraContextV1( + inboundRLCID, + deps.Bootstrap.AllocationFactory, + deps.Bootstrap.InstrumentConfiguration, + true, + ) + + poolDisclosures, err := ccip.DisclosePoolExecuteContracts(ctx, deps.Client, ccip.PoolExecuteInput{ + RegistrarParty: deps.RegistrarParty, + CcipParty: deps.CcipParty, + CcipClient: deps.CcipClient, + InstrumentConfiguration: deps.Bootstrap.InstrumentConfiguration, + AllocationFactory: deps.Bootstrap.AllocationFactory, + PoolCID: poolCID, + TokenAdminRegistryCID: deps.TokenAdminRegistryCID, + InboundRateLimiterCID: inboundRLCID, + RMNRemoteCID: rmnCID, + }) + require.NoError(t, err) + + var disclosedContracts []*apiv2.DisclosedContract + for _, d := range poolDisclosures.All() { + if d != nil { + disclosedContracts = append(disclosedContracts, d) + } + } + + return &edsTesthelpers.TokenPoolExecuteDisclosure{ + ContractId: poolCID, + Address: poolAddressEDS, + DisclosedContracts: disclosedContracts, + ChoiceContext: choiceContext, + RequiredCCVs: nil, + } +} diff --git a/integration-tests/go.mod b/integration-tests/go.mod index 1283f8b08..ff16b7765 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -6,6 +6,8 @@ replace github.com/smartcontractkit/chainlink-canton => ../ replace github.com/smartcontractkit/chainlink-canton/party-ceremony => ../party-ceremony +replace github.com/smartcontractkit/chainlink-canton/registry-kit => ../registry-kit + // Coming from chainlink-deployments-framework replace github.com/fbsobreira/gotron-sdk => github.com/smartcontractkit/chainlink-tron/relayer/gotron-sdk v0.0.5-0.20251014120029-d73d15cc23f7 @@ -24,8 +26,9 @@ require ( github.com/google/uuid v1.6.0 github.com/rs/zerolog v1.35.1 github.com/smartcontractkit/chain-selectors v1.0.102 - github.com/smartcontractkit/chainlink-canton v0.0.0-20260602133237-99f834640c9d + github.com/smartcontractkit/chainlink-canton v0.0.0 github.com/smartcontractkit/chainlink-canton/party-ceremony v0.0.0-00010101000000-000000000000 + github.com/smartcontractkit/chainlink-canton/registry-kit v0.0.0 github.com/smartcontractkit/chainlink-ccip/chains/evm v0.0.0-20260608180601-efa81bfdfda9 github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260608180601-efa81bfdfda9 github.com/smartcontractkit/chainlink-ccv v0.0.2-0.20260608205628-b1fb1b311772 diff --git a/registry-kit/.gitignore b/registry-kit/.gitignore new file mode 100644 index 000000000..72d592aa2 --- /dev/null +++ b/registry-kit/.gitignore @@ -0,0 +1,3 @@ +/bin +registry-kit.toml +registry-kit.state.json diff --git a/registry-kit/Makefile b/registry-kit/Makefile new file mode 100644 index 000000000..67f4c12c7 --- /dev/null +++ b/registry-kit/Makefile @@ -0,0 +1,20 @@ +.PHONY: build +build: ## Build the binary. + go build -o bin/canton-registry-kit . + +.PHONY: test +test: ## Run all unit tests. + go test -v -count=1 -timeout=5m ./... + +.PHONY: lint +lint: ## Run golangci-lint. + golangci-lint run + +.PHONY: clean +clean: ## Remove build artifacts. + rm -rf bin/ + +.PHONY: help +help: ## Display this help. + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \ + awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' diff --git a/registry-kit/ccip/bundle.go b/registry-kit/ccip/bundle.go new file mode 100644 index 000000000..ce9fa3726 --- /dev/null +++ b/registry-kit/ccip/bundle.go @@ -0,0 +1,13 @@ +package ccip + +import ( + "context" + + "github.com/smartcontractkit/chainlink-common/pkg/logger" + cld_ops "github.com/smartcontractkit/chainlink-deployments-framework/operations" +) + +// NewBundle creates an operations bundle for deployment sequences. +func NewBundle(getCtx func() context.Context, log logger.Logger) cld_ops.Bundle { + return cld_ops.NewBundle(getCtx, log, cld_ops.NewMemoryReporter()) +} diff --git a/registry-kit/ccip/deploy.go b/registry-kit/ccip/deploy.go new file mode 100644 index 000000000..4461b7e63 --- /dev/null +++ b/registry-kit/ccip/deploy.go @@ -0,0 +1,113 @@ +package ccip + +import ( + "context" + "fmt" + + "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// PoolDeployDeps holds CCIP contract bindings required to create registrar-owned token pools. +type PoolDeployDeps struct { + CcipOwner string + TokenAdminRegistry contracts.RawInstanceAddress + RMNRemote contracts.RawInstanceAddress + FeeQuoter contracts.RawInstanceAddress +} + +// DeployInboundRateLimiterForOwner creates an inbound rate limiter with ownerParty as actAs. +func DeployInboundRateLimiterForOwner( + ctx context.Context, + client ledger.Client, + ownerParty string, + template ccipcore.RateLimiter, +) (contracts.RawInstanceAddress, error) { + res, err := client.SubmitCreate(ctx, ownerParty, template) + if err != nil { + return "", fmt.Errorf("deploy inbound rate limiter: %w", err) + } + if _, ok := ledger.CreatedContractID(res.GetTransaction(), "RateLimiter"); !ok { + return "", fmt.Errorf("RateLimiter not created") + } + + raw, err := contracts.RawInstanceAddressFromString(fmt.Sprintf("%s@%s", template.InstanceId, ownerParty)) + if err != nil { + return "", err + } + + return raw, nil +} + +// DeployOutboundRateLimiterForOwner creates an outbound rate limiter with ownerParty as actAs. +func DeployOutboundRateLimiterForOwner( + ctx context.Context, + client ledger.Client, + ownerParty string, + template ccipcore.RateLimiter, +) (contracts.RawInstanceAddress, error) { + res, err := client.SubmitCreate(ctx, ownerParty, template) + if err != nil { + return "", fmt.Errorf("deploy outbound rate limiter: %w", err) + } + if _, ok := ledger.CreatedContractID(res.GetTransaction(), "RateLimiter"); !ok { + return "", fmt.Errorf("RateLimiter not created") + } + + raw, err := contracts.RawInstanceAddressFromString(fmt.Sprintf("%s@%s", template.InstanceId, ownerParty)) + if err != nil { + return "", err + } + + return raw, nil +} + +// DeployBurnMintPoolForOwner creates a BurnMintTokenPool with poolOwner as actAs. +func DeployBurnMintPoolForOwner( + ctx context.Context, + client ledger.Client, + deps PoolDeployDeps, + poolOwner string, + instrumentID splice_api_token_holding_v1.InstrumentId, + poolInstanceID string, + remoteChainConfigs map[types.NUMERIC]burnminttokenpool.RemoteChainConfig, + feeConfigs ...map[types.NUMERIC]burnminttokenpool.TokenTransferFeeConfig, +) (contracts.RawInstanceAddress, error) { + if remoteChainConfigs == nil { + remoteChainConfigs = map[types.NUMERIC]burnminttokenpool.RemoteChainConfig{} + } + tokenTransferFeeConfigs := map[types.NUMERIC]burnminttokenpool.TokenTransferFeeConfig{} + if len(feeConfigs) > 0 && feeConfigs[0] != nil { + tokenTransferFeeConfigs = feeConfigs[0] + } + + pool := burnminttokenpool.BurnMintTokenPool{ + InstanceId: types.TEXT(poolInstanceID), + PoolOwner: types.PARTY(poolOwner), + CcipOwner: types.PARTY(deps.CcipOwner), + InstrumentId: instrumentID, + Decimals: types.INT64(10), + RemoteChainConfigs: remoteChainConfigs, + TokenTransferFeeConfigs: tokenTransferFeeConfigs, + TransferTimeout: burnminttokenpool.TransferTimeout{RelativeHours: new(types.INT64(24))}, + Deps: burnminttokenpool.BurnMintTokenPoolDeps{ + TokenAdminRegistry: deps.TokenAdminRegistry.Binding(), + RmnRemote: deps.RMNRemote.Binding(), + FeeQuoter: deps.FeeQuoter.Binding(), + }, + } + + res, err := client.SubmitCreate(ctx, poolOwner, pool) + if err != nil { + return "", fmt.Errorf("deploy burn mint token pool: %w", err) + } + if _, ok := ledger.CreatedContractID(res.GetTransaction(), "BurnMintTokenPool"); !ok { + return "", fmt.Errorf("BurnMintTokenPool not created") + } + + return contracts.NewRawInstanceAddress(contracts.InstanceID(poolInstanceID), types.PARTY(poolOwner)), nil +} diff --git a/registry-kit/ccip/pool_context.go b/registry-kit/ccip/pool_context.go new file mode 100644 index 000000000..bb6481a67 --- /dev/null +++ b/registry-kit/ccip/pool_context.go @@ -0,0 +1,311 @@ +package ccip + +import ( + "context" + "fmt" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + burnminttokenpool "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// PoolReleaseDisclosures holds disclosed contracts required for ReleaseFromTicket. +type PoolReleaseDisclosures struct { + InstrumentConfiguration *apiv2.DisclosedContract + AllocationFactory *apiv2.DisclosedContract + BurnMintTokenPool *apiv2.DisclosedContract + TokenAdminRegistry *apiv2.DisclosedContract + RateLimiter *apiv2.DisclosedContract + RMNRemote *apiv2.DisclosedContract + TokenReceiveTicket *apiv2.DisclosedContract +} + +func (d PoolReleaseDisclosures) All() []*apiv2.DisclosedContract { + return []*apiv2.DisclosedContract{ + d.InstrumentConfiguration, + d.AllocationFactory, + d.BurnMintTokenPool, + d.TokenAdminRegistry, + d.RateLimiter, + d.RMNRemote, + d.TokenReceiveTicket, + } +} + +// PoolReleaseInput identifies contracts needed for pool release disclosures. +type PoolReleaseInput struct { + RegistrarParty string + // CcipParty discloses CCIP-owned contracts (TAR, RMN) when they differ from the registrar. + CcipParty string + InstrumentConfiguration string + AllocationFactory string + PoolCID string + TokenAdminRegistryCID string + InboundRateLimiterCID string + RMNRemoteCID string + TokenReceiveTicketCID string +} + +func registryPoolBurnMintExtraContext( + rateLimiterCID, allocationFactoryCID, instrumentConfigCID string, + enableResultContracts bool, +) splice_api_token_metadata_v1.ChoiceContext { + nestedValues := registry.MintChoiceContext(instrumentConfigCID, enableResultContracts).Values + + return splice_api_token_metadata_v1.ChoiceContext{ + Values: map[string]splice_api_token_metadata_v1.AnyValue{ + string(ccipcore.RateLimiterKey): { + AVContractId: new(types.CONTRACT_ID(rateLimiterCID)), + }, + string(burnminttokenpool.BurnMintFactoryContextKey): { + AVContractId: new(types.CONTRACT_ID(allocationFactoryCID)), + }, + string(burnminttokenpool.BurnMintFactoryExtraArgsContextValuesContextKey): { + AVMap: &nestedValues, + }, + }, + } +} + +// RegistryPoolExtraContext builds pool extraContext for ReleaseFromTicket with AllocationFactory +// as burn-mint-factory and nested Registry mint choice-context values. +func RegistryPoolExtraContext(inboundRateLimiterCID, allocationFactoryCID, instrumentConfigCID string) splice_api_token_metadata_v1.ChoiceContext { + return registryPoolBurnMintExtraContext(inboundRateLimiterCID, allocationFactoryCID, instrumentConfigCID, true) +} + +// RegistryPoolSendExtraContext builds pool extraContext for LockOrBurn with AllocationFactory +// as burn-mint-factory and nested Registry burn choice-context values. +func RegistryPoolSendExtraContext(outboundRateLimiterCID, allocationFactoryCID, instrumentConfigCID string, enableResultContracts bool) splice_api_token_metadata_v1.ChoiceContext { + return registryPoolBurnMintExtraContext(outboundRateLimiterCID, allocationFactoryCID, instrumentConfigCID, enableResultContracts) +} + +// PoolSendDisclosures holds disclosed contracts required for LockOrBurn. +type PoolSendDisclosures struct { + InstrumentConfiguration *apiv2.DisclosedContract + AllocationFactory *apiv2.DisclosedContract + BurnMintTokenPool *apiv2.DisclosedContract + TokenAdminRegistry *apiv2.DisclosedContract + RateLimiter *apiv2.DisclosedContract + RMNRemote *apiv2.DisclosedContract + SendingMessage *apiv2.DisclosedContract +} + +func (d PoolSendDisclosures) All() []*apiv2.DisclosedContract { + out := []*apiv2.DisclosedContract{ + d.InstrumentConfiguration, + d.AllocationFactory, + d.BurnMintTokenPool, + d.TokenAdminRegistry, + d.RateLimiter, + d.RMNRemote, + } + if d.SendingMessage != nil { + out = append(out, d.SendingMessage) + } + + return out +} + +// PoolSendInput identifies contracts needed for pool send disclosures. +type PoolSendInput struct { + RegistrarParty string + CcipParty string + InstrumentConfiguration string + AllocationFactory string + PoolCID string + TokenAdminRegistryCID string + OutboundRateLimiterCID string + RMNRemoteCID string + SendingMessageCID string + // CcipClient optionally supplies the ledger client for CCIP-party disclosures when it + // differs from the client used for registrar-party disclosures (multi-participant CTF). + CcipClient ledger.Client +} + +// DisclosePoolSendContracts fetches stakeholder-party disclosures for the LockOrBurn path. +func DisclosePoolSendContracts(ctx context.Context, client ledger.Client, input PoolSendInput) (PoolSendDisclosures, error) { + registrar := input.RegistrarParty + ccipClient := input.CcipClient + if ccipClient == nil { + ccipClient = client + } + + instDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.InstrumentConfiguration) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose InstrumentConfiguration: %w", err) + } + allocDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.AllocationFactory) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose AllocationFactory: %w", err) + } + poolDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.PoolCID) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose BurnMintTokenPool: %w", err) + } + ccipParty := input.CcipParty + if ccipParty == "" { + ccipParty = registrar + } + tarDisclosed, err := registry.DiscloseByID(ctx, ccipClient, ccipParty, input.TokenAdminRegistryCID) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose TokenAdminRegistry: %w", err) + } + rlDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.OutboundRateLimiterCID) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose RateLimiter: %w", err) + } + rmnDisclosed, err := registry.DiscloseByID(ctx, ccipClient, ccipParty, input.RMNRemoteCID) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose RMNRemote: %w", err) + } + var msgDisclosed *apiv2.DisclosedContract + if input.SendingMessageCID != "" { + msgDisclosed, err = registry.DiscloseByID(ctx, ccipClient, ccipParty, input.SendingMessageCID) + if err != nil { + return PoolSendDisclosures{}, fmt.Errorf("disclose SendingMessageV1: %w", err) + } + } + + return PoolSendDisclosures{ + InstrumentConfiguration: instDisclosed, + AllocationFactory: allocDisclosed, + BurnMintTokenPool: poolDisclosed, + TokenAdminRegistry: tarDisclosed, + RateLimiter: rlDisclosed, + RMNRemote: rmnDisclosed, + SendingMessage: msgDisclosed, + }, nil +} + +// DisclosePoolReleaseContracts fetches stakeholder-party disclosures for the release path. +func DisclosePoolReleaseContracts(ctx context.Context, client ledger.Client, input PoolReleaseInput) (PoolReleaseDisclosures, error) { + registrar := input.RegistrarParty + + instDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.InstrumentConfiguration) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose InstrumentConfiguration: %w", err) + } + allocDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.AllocationFactory) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose AllocationFactory: %w", err) + } + poolDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.PoolCID) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose BurnMintTokenPool: %w", err) + } + ccipParty := input.CcipParty + if ccipParty == "" { + ccipParty = registrar + } + tarDisclosed, err := registry.DiscloseByID(ctx, client, ccipParty, input.TokenAdminRegistryCID) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose TokenAdminRegistry: %w", err) + } + rlDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.InboundRateLimiterCID) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose RateLimiter: %w", err) + } + rmnDisclosed, err := registry.DiscloseByID(ctx, client, ccipParty, input.RMNRemoteCID) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose RMNRemote: %w", err) + } + ticketDisclosed, err := registry.DiscloseByID(ctx, client, ccipParty, input.TokenReceiveTicketCID) + if err != nil { + return PoolReleaseDisclosures{}, fmt.Errorf("disclose TokenReceiveTicket: %w", err) + } + + return PoolReleaseDisclosures{ + InstrumentConfiguration: instDisclosed, + AllocationFactory: allocDisclosed, + BurnMintTokenPool: poolDisclosed, + TokenAdminRegistry: tarDisclosed, + RateLimiter: rlDisclosed, + RMNRemote: rmnDisclosed, + TokenReceiveTicket: ticketDisclosed, + }, nil +} + +// PoolExecuteDisclosures holds disclosed contracts required for CCIPReceiver.Execute mint path. +type PoolExecuteDisclosures struct { + InstrumentConfiguration *apiv2.DisclosedContract + AllocationFactory *apiv2.DisclosedContract + BurnMintTokenPool *apiv2.DisclosedContract + TokenAdminRegistry *apiv2.DisclosedContract + RateLimiter *apiv2.DisclosedContract + RMNRemote *apiv2.DisclosedContract +} + +func (d PoolExecuteDisclosures) All() []*apiv2.DisclosedContract { + return []*apiv2.DisclosedContract{ + d.InstrumentConfiguration, + d.AllocationFactory, + d.BurnMintTokenPool, + d.TokenAdminRegistry, + d.RateLimiter, + d.RMNRemote, + } +} + +// PoolExecuteInput identifies contracts needed for pool execute disclosures. +type PoolExecuteInput struct { + RegistrarParty string + CcipParty string + CcipClient ledger.Client + InstrumentConfiguration string + AllocationFactory string + PoolCID string + TokenAdminRegistryCID string + InboundRateLimiterCID string + RMNRemoteCID string +} + +// DisclosePoolExecuteContracts fetches stakeholder-party disclosures for the execute mint path. +func DisclosePoolExecuteContracts(ctx context.Context, client ledger.Client, input PoolExecuteInput) (PoolExecuteDisclosures, error) { + registrar := input.RegistrarParty + ccipClient := input.CcipClient + if ccipClient == nil { + ccipClient = client + } + + instDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.InstrumentConfiguration) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose InstrumentConfiguration: %w", err) + } + allocDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.AllocationFactory) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose AllocationFactory: %w", err) + } + poolDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.PoolCID) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose BurnMintTokenPool: %w", err) + } + ccipParty := input.CcipParty + if ccipParty == "" { + ccipParty = registrar + } + tarDisclosed, err := registry.DiscloseByID(ctx, ccipClient, ccipParty, input.TokenAdminRegistryCID) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose TokenAdminRegistry: %w", err) + } + rlDisclosed, err := registry.DiscloseByID(ctx, client, registrar, input.InboundRateLimiterCID) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose RateLimiter: %w", err) + } + rmnDisclosed, err := registry.DiscloseByID(ctx, ccipClient, ccipParty, input.RMNRemoteCID) + if err != nil { + return PoolExecuteDisclosures{}, fmt.Errorf("disclose RMNRemote: %w", err) + } + + return PoolExecuteDisclosures{ + InstrumentConfiguration: instDisclosed, + AllocationFactory: allocDisclosed, + BurnMintTokenPool: poolDisclosed, + TokenAdminRegistry: tarDisclosed, + RateLimiter: rlDisclosed, + RMNRemote: rmnDisclosed, + }, nil +} diff --git a/registry-kit/ccip/pool_context_v1.go b/registry-kit/ccip/pool_context_v1.go new file mode 100644 index 000000000..116d55065 --- /dev/null +++ b/registry-kit/ccip/pool_context_v1.go @@ -0,0 +1,41 @@ +package ccip + +import ( + burnminttokenpool "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// RegistryPoolSendExtraContextV1 builds pool extraContext for LockOrBurn / ReleaseFromTicket +// using latest CCIP bindings (integration-tests lane compatibility). +func RegistryPoolSendExtraContextV1( + rateLimiterCID, allocationFactoryCID, instrumentConfigCID string, + enableResultContracts bool, +) splice_api_token_metadata_v1.ChoiceContext { + emptyList := []splice_api_token_metadata_v1.AnyValue{} + nestedValues := map[string]splice_api_token_metadata_v1.AnyValue{ + registry.CtxKeyInstrumentConfiguration: {AVContractId: new(types.CONTRACT_ID(instrumentConfigCID))}, + registry.CtxKeyIssuerCredentials: {AVList: &emptyList}, + } + if enableResultContracts { + nestedValues[registry.CtxKeyEnableResultContracts] = splice_api_token_metadata_v1.AnyValue{ + AVBool: new(types.BOOL(true)), + } + } + + return splice_api_token_metadata_v1.ChoiceContext{ + Values: map[string]splice_api_token_metadata_v1.AnyValue{ + string(ccipcore.RateLimiterKey): { + AVContractId: new(types.CONTRACT_ID(rateLimiterCID)), + }, + string(burnminttokenpool.BurnMintFactoryContextKey): { + AVContractId: new(types.CONTRACT_ID(allocationFactoryCID)), + }, + string(burnminttokenpool.BurnMintFactoryExtraArgsContextValuesContextKey): { + AVMap: &nestedValues, + }, + }, + } +} diff --git a/registry-kit/ccip/register.go b/registry-kit/ccip/register.go new file mode 100644 index 000000000..2e3279a8c --- /dev/null +++ b/registry-kit/ccip/register.go @@ -0,0 +1,174 @@ +package ccip + +import ( + "context" + "encoding/hex" + "fmt" + "strings" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/deployment/sequences" + "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" + cld_ops "github.com/smartcontractkit/chainlink-deployments-framework/operations" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// RegisterTokenPoolInput is the input for registering a token pool with the TokenAdminRegistry. +type RegisterTokenPoolInput struct { + TokenAdminRegistryInstanceAddress contracts.InstanceAddress + TokenAdminRegistryRawInstanceAddress contracts.RawInstanceAddress + InstrumentId splice_api_token_holding_v1.InstrumentId + PoolInstanceID string + CcipParty string + PoolOwnerParty string +} + +// RegisterTokenPool runs ProposeAdministrator → AcceptAdminRole → SetPool on the TAR. +func RegisterTokenPool(bundle cld_ops.Bundle, chain canton.Chain, input RegisterTokenPoolInput) error { + _, err := cld_ops.ExecuteSequence(bundle, sequences.RegisterTokenPool, chain, sequences.RegisterTokenPoolInput{ + TokenAdminRegistryInstanceAddress: input.TokenAdminRegistryInstanceAddress, + TokenAdminRegistryRawInstanceAddress: input.TokenAdminRegistryRawInstanceAddress, + InstrumentId: input.InstrumentId, + PoolInstanceID: input.PoolInstanceID, + CcipParty: input.CcipParty, + PoolOwnerParty: input.PoolOwnerParty, + }) + if err != nil { + return fmt.Errorf("register token pool: %w", err) + } + + return nil +} + +// RegisterTokenPoolClientInput is the input for TAR registration via ledger client with per-step actAs parties. +type RegisterTokenPoolClientInput struct { + TokenAdminRegistryCID string + InstrumentId splice_api_token_holding_v1.InstrumentId + PoolInstanceID string + CcipParty string + PoolOwnerParty string + // PoolOwnerClient optionally supplies the ledger client for pool-owner steps when the + // pool owner is hosted on a different CTF participant than the CCIP party. + PoolOwnerClient ledger.Client +} + +// RegisterTokenPoolViaClient runs ProposeAdministrator → AcceptAdminRole → SetPool using explicit actAs parties. +// Use when PoolOwnerParty differs from the CTF participant party (CLDF deploy ops always act as participant.PartyID). +func RegisterTokenPoolViaClient(ctx context.Context, client ledger.Client, input RegisterTokenPoolClientInput) (tokenConfigCID string, tarCID string, err error) { + poolOwnerClient := input.PoolOwnerClient + if poolOwnerClient == nil { + poolOwnerClient = client + } + + tokenConfigAddr := contracts.InstanceID(hex.EncodeToString(contracts.EncodeInstrumentID(input.InstrumentId).Bytes())). + RawInstanceAddress(types.PARTY(input.CcipParty)). + InstanceAddress() + + tarCID = input.TokenAdminRegistryCID + tokenConfigCID, found, err := findTokenConfigCID(ctx, client, input.CcipParty, tokenConfigAddr) + if err != nil { + return "", tarCID, fmt.Errorf("lookup token config: %w", err) + } + var tokenConfigCIDArg *types.CONTRACT_ID + if found { + cid := types.CONTRACT_ID(tokenConfigCID) + tokenConfigCIDArg = &cid + } + + skipAccept := false + proposeRes, err := client.SubmitExercise(ctx, input.CcipParty, ccipcore.TokenAdminRegistry{}, tarCID, "ProposeAdministrator", + ccipcore.ProposeAdministrator{ + TokenConfigCid: tokenConfigCIDArg, + InstrumentId: input.InstrumentId, + NewAdmin: types.PARTY(input.PoolOwnerParty), + Caller: types.PARTY(input.CcipParty), + }) + if err != nil { + if strings.Contains(err.Error(), "admin already set") { + skipAccept = true + } else { + return "", tarCID, fmt.Errorf("propose administrator: %w", err) + } + } else { + if newTarCID, ok := ledger.CreatedContractID(proposeRes.GetTransaction(), "TokenAdminRegistry"); ok { + tarCID = newTarCID + } + cid, ok := ledger.CreatedContractID(proposeRes.GetTransaction(), "TokenConfig") + if !ok { + return "", tarCID, fmt.Errorf("TokenConfig not created after ProposeAdministrator") + } + tokenConfigCID = cid + } + + if !skipAccept { + tarDisclosed, err := registry.DiscloseByID(ctx, client, input.CcipParty, tarCID) + if err != nil { + return "", tarCID, fmt.Errorf("disclose TAR for AcceptAdminRole: %w", err) + } + + acceptRes, err := poolOwnerClient.SubmitExerciseMulti(ctx, []string{input.PoolOwnerParty}, ccipcore.TokenAdminRegistry{}, tarCID, "AcceptAdminRole", + ccipcore.AcceptAdminRole{ + TokenConfigCid: types.CONTRACT_ID(tokenConfigCID), + InstrumentId: input.InstrumentId, + Caller: types.PARTY(input.PoolOwnerParty), + }, []*apiv2.DisclosedContract{tarDisclosed}) + if err != nil { + return "", tarCID, fmt.Errorf("accept admin role: %w", err) + } + cid, ok := ledger.CreatedContractID(acceptRes.GetTransaction(), "TokenConfig") + if !ok { + return "", tarCID, fmt.Errorf("TokenConfig not created after AcceptAdminRole") + } + tokenConfigCID = cid + } + + tarDisclosed, err := registry.DiscloseByID(ctx, client, input.CcipParty, tarCID) + if err != nil { + return "", tarCID, fmt.Errorf("disclose TAR for SetPool: %w", err) + } + + setPoolRes, err := poolOwnerClient.SubmitExerciseMulti(ctx, []string{input.PoolOwnerParty}, ccipcore.TokenAdminRegistry{}, tarCID, "SetPool", + ccipcore.SetPool{ + TokenConfigCid: types.CONTRACT_ID(tokenConfigCID), + InstrumentId: input.InstrumentId, + TokenPool: &ccipcore.PoolRegistration{ + PoolOwner: types.PARTY(input.PoolOwnerParty), + PoolInstanceId: types.TEXT(input.PoolInstanceID), + }, + Caller: types.PARTY(input.PoolOwnerParty), + }, []*apiv2.DisclosedContract{tarDisclosed}) + if err != nil { + return "", tarCID, fmt.Errorf("set pool: %w", err) + } + cid, ok := ledger.CreatedContractID(setPoolRes.GetTransaction(), "TokenConfig") + if !ok { + return "", tarCID, fmt.Errorf("TokenConfig not created after SetPool") + } + + return cid, tarCID, nil +} + +func findTokenConfigCID(ctx context.Context, client ledger.Client, ccipParty string, addr contracts.InstanceAddress) (string, bool, error) { + participant := client.Participant() + cid, err := contract.FindActiveContractIDByInstanceAddress( + ctx, + participant.LedgerServices.State, + []string{ccipParty}, + ccipcore.TokenConfig{}.GetTemplateID(), + addr, + ) + if err != nil { + if strings.Contains(err.Error(), "no active contract found") { + return "", false, nil + } + return "", false, err + } + + return string(cid), true, nil +} diff --git a/registry-kit/ccip/release.go b/registry-kit/ccip/release.go new file mode 100644 index 000000000..6f5e22112 --- /dev/null +++ b/registry-kit/ccip/release.go @@ -0,0 +1,53 @@ +package ccip + +import ( + "context" + "fmt" + + burnminttokenpool "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// ReleaseFromTicketInput identifies contracts for a pool release exercise. +type ReleaseFromTicketInput struct { + PoolCID string + TokenAdminRegistryCID string + TokenConfigCID string + RMNRemoteCID string + TokenReceiveTicketCID string + Receiver string + PoolOwner string + ExtraContext splice_api_token_metadata_v1.ChoiceContext + Disclosures PoolReleaseDisclosures +} + +// ReleaseFromTicket exercises BurnMintTokenPool.ReleaseFromTicket and returns the created Holding CID. +func ReleaseFromTicket(ctx context.Context, client ledger.Client, input ReleaseFromTicketInput) (string, error) { + args := burnminttokenpool.ReleaseFromTicket{ + TokenAdminRegistryCid: types.CONTRACT_ID(input.TokenAdminRegistryCID), + TokenConfigCid: types.CONTRACT_ID(input.TokenConfigCID), + RmnRemoteCid: types.CONTRACT_ID(input.RMNRemoteCID), + ExtraContext: input.ExtraContext, + TokenReceiveTicketCid: types.CONTRACT_ID(input.TokenReceiveTicketCID), + Caller: types.PARTY(input.Receiver), + } + + actAs := []string{input.Receiver} + if input.PoolOwner != "" && input.PoolOwner != input.Receiver { + actAs = append(actAs, input.PoolOwner) + } + + res, err := client.SubmitExerciseMulti(ctx, actAs, burnminttokenpool.BurnMintTokenPool{}, input.PoolCID, "ReleaseFromTicket", args, input.Disclosures.All()) + if err != nil { + return "", fmt.Errorf("release from ticket: %w", err) + } + + holdingCID, ok := ledger.CreatedHoldingForOwner(res.GetTransaction(), input.Receiver) + if !ok { + return "", fmt.Errorf("Registry Holding for receiver not created") + } + + return holdingCID, nil +} diff --git a/registry-kit/ccip/send.go b/registry-kit/ccip/send.go new file mode 100644 index 000000000..7e5252946 --- /dev/null +++ b/registry-kit/ccip/send.go @@ -0,0 +1,285 @@ +package ccip + +import ( + "context" + "fmt" + "math/big" + "strings" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + burnminttokenpool "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/burnminttokenpool" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + chainlinkapi "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/chainlink/chainlinkapi" + "github.com/smartcontractkit/chainlink-canton/bindings" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// LockOrBurnInput identifies contracts for a pool LockOrBurn exercise. +type LockOrBurnInput struct { + PoolCID string + TokenAdminRegistryCID string + TokenConfigCID string + RMNRemoteCID string + SendingMessageCID string + SenderInputCids []string + Amount string + Sender string + PoolOwner string + ExtraContext splice_api_token_metadata_v1.ChoiceContext + Disclosures PoolSendDisclosures +} + +// LockOrBurnResult is the parsed LockOrBurn exercise output. +type LockOrBurnResult struct { + SenderChangeCids []string + PoolChangeCids []string + SendingMessageCid string +} + +// LockOrBurn exercises BurnMintTokenPool.LockOrBurn and returns change holdings plus the updated SendingMessage CID. +func LockOrBurn(ctx context.Context, client ledger.Client, input LockOrBurnInput) (LockOrBurnResult, error) { + senderInputs := make([]types.CONTRACT_ID, 0, len(input.SenderInputCids)) + for _, cid := range input.SenderInputCids { + senderInputs = append(senderInputs, types.CONTRACT_ID(cid)) + } + + args := burnminttokenpool.LockOrBurn{ + TokenAdminRegistryCid: types.CONTRACT_ID(input.TokenAdminRegistryCID), + TokenConfigCid: types.CONTRACT_ID(input.TokenConfigCID), + RmnRemoteCid: types.CONTRACT_ID(input.RMNRemoteCID), + ExtraContext: input.ExtraContext, + SendingMessageCid: types.CONTRACT_ID(input.SendingMessageCID), + SenderInputCids: senderInputs, + Amount: types.NUMERIC(input.Amount), + Caller: types.PARTY(input.Sender), + } + + actAs := []string{input.Sender} + if input.PoolOwner != "" && input.PoolOwner != input.Sender { + actAs = append(actAs, input.PoolOwner) + } + + res, err := client.SubmitExerciseMulti(ctx, actAs, burnminttokenpool.BurnMintTokenPool{}, input.PoolCID, "LockOrBurn", args, input.Disclosures.All()) + if err != nil { + return LockOrBurnResult{}, fmt.Errorf("lock or burn: %w", err) + } + + if parsed, err := ledger.ParseLockOrBurnResult(res.GetTransaction()); err == nil { + result := LockOrBurnResult{SendingMessageCid: string(parsed.SendingMessageCid)} + for _, cid := range parsed.SenderChangeCids { + result.SenderChangeCids = append(result.SenderChangeCids, string(cid)) + } + for _, cid := range parsed.PoolChangeCids { + result.PoolChangeCids = append(result.PoolChangeCids, string(cid)) + } + return result, nil + } + + return lockOrBurnResultFromCreatedHoldings(res.GetTransaction(), input) +} + +func lockOrBurnResultFromCreatedHoldings(tx *apiv2.Transaction, input LockOrBurnInput) (LockOrBurnResult, error) { + senderChanges := ledger.CreatedHoldingsForOwner(tx, input.Sender) + poolChanges := ledger.CreatedHoldingsForOwner(tx, input.PoolOwner) + if len(senderChanges) == 0 { + return LockOrBurnResult{}, fmt.Errorf("sender change Holding not created") + } + + sendingMessageCID := input.SendingMessageCID + if cid, ok := ledger.CreatedContractID(tx, "SendingMessageV1"); ok { + sendingMessageCID = cid + } + + return LockOrBurnResult{ + SenderChangeCids: senderChanges, + PoolChangeCids: poolChanges, + SendingMessageCid: sendingMessageCID, + }, nil +} + +// CreateSendingMessageInput identifies fields for a FeeFinalized SendingMessageV1 used in LockOrBurn tests. +type CreateSendingMessageInput struct { + CcipParty string + Sender string + InstrumentId splice_api_token_holding_v1.InstrumentId + DestChainSelector string + SourceChainSelector string + PoolInstanceID string + PoolOwner string + RmnRemote contracts.RawInstanceAddress + TokenAdminRegistry contracts.RawInstanceAddress + FeeQuoter contracts.RawInstanceAddress +} + +// CreateSendingMessage creates a FeeFinalized SendingMessageV1 on the CCIP party for outbound pool tests. +func CreateSendingMessage(ctx context.Context, client ledger.Client, input CreateSendingMessageInput) (string, error) { + sourceChainSelector := input.SourceChainSelector + if sourceChainSelector == "" { + sourceChainSelector = "123" + } + + executionMode := ccipcore.ExecutionModeExecutionMode_NoExecutor + expectedInstrument := input.InstrumentId + emptyOutboundCCVs := []chainlinkapi.RawInstanceAddress{} + tokenSendFee := ccipcore.TokenSendFee{ + PoolInstanceId: types.TEXT(input.PoolInstanceID), + PoolOwner: types.PARTY(input.PoolOwner), + FeeUSDCents: types.NUMERIC("0"), + DestGasOverhead: types.INT64(0), + DestBytesOverhead: types.INT64(64), + } + + msg := ccipcore.SendingMessageV1{ + CcipOwner: types.PARTY(input.CcipParty), + Sender: types.PARTY(input.Sender), + Deps: ccipcore.SendingMessageDeps{ + Router: rawInstanceAddressBinding("test-router", input.Sender), + OnRamp: rawInstanceAddressBinding("test-onramp", input.CcipParty), + GlobalConfig: rawInstanceAddressBinding("test-globalconfig", input.CcipParty), + RmnRemote: bindRawInstanceAddress(input.RmnRemote), + TokenAdminRegistry: bindRawInstanceAddress(input.TokenAdminRegistry), + FeeQuoter: bindRawInstanceAddress(input.FeeQuoter), + }, + DestChainSelector: types.NUMERIC(input.DestChainSelector), + SequenceNumber: types.NUMERIC("1"), + DestDefaultCCVs: nil, + RequiredCCVs: nil, + ExecutorAddress: types.TEXT(instanceAddressHex("default-executor", input.CcipParty)), + ExecutionMode: &executionMode, + SourceChainSelector: types.NUMERIC(sourceChainSelector), + SenderAddress: types.TEXT("0000000000000000000000000000000000000001"), + Receiver: types.TEXT("0000000000000000000000000000000000000001"), + Payload: types.TEXT(""), + ExecutionGasLimit: types.INT64(0), + CcipReceiveGasLimit: types.INT64(100000), + CcvAndExecutorHash: types.TEXT(""), + OnRampAddress: types.TEXT("0000000000000000000000000000000000000001"), + OffRampAddress: types.TEXT("0000000000000000000000000000000000000002"), + TokenReceiver: types.TEXT("0000000000000000000000000000000000000003"), + TokenArgs: types.TEXT(""), + FeeToken: input.InstrumentId, + NetworkFeeUSDCents: types.NUMERIC("0"), + ExpectedTokenInstrumentId: &expectedInstrument, + OutboundPoolCCVs: &emptyOutboundCCVs, + ExecutorArgs: types.TEXT(""), + ExecutorDestGasLimit: types.INT64(0), + ExecutorDestBytesOverhead: types.INT64(0), + ExecutorFeeTokenAmount: types.NUMERIC("0"), + ObservingParties: []types.PARTY{types.PARTY(input.Sender)}, + TokenSendFee: &tokenSendFee, + TokenSendFeeTokenAmount: types.NUMERIC("0"), + NetworkFeeTokenAmount: types.NUMERIC("0"), + EncodedMessage: types.TEXT(""), + MessageId: types.TEXT(""), + State: ccipcore.SendingMessageStateSendingMessageState_FeeFinalized, + } + + res, err := client.SubmitCreate(ctx, input.CcipParty, msg) + if err != nil { + return "", fmt.Errorf("create SendingMessageV1: %w", err) + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "SendingMessageV1") + if !ok { + return "", fmt.Errorf("SendingMessageV1 not created") + } + + return cid, nil +} + +// FetchSendingMessage loads an active SendingMessageV1 by contract ID. +func FetchSendingMessage(ctx context.Context, client ledger.Client, ccipParty, contractID string) (ccipcore.SendingMessageV1, error) { + tpl := contracts.IdentifierFromBinding(ccipcore.SendingMessageV1{}) + active, err := testhelpers.ListActiveContractsByTemplateId(ctx, client.ForParty(ccipParty), tpl) + if err != nil { + return ccipcore.SendingMessageV1{}, fmt.Errorf("list SendingMessageV1: %w", err) + } + for _, ac := range active { + if ac.GetCreatedEvent().GetContractId() != contractID { + continue + } + msg, err := bindings.UnmarshalCreatedEvent[ccipcore.SendingMessageV1](ac.GetCreatedEvent()) + if err != nil { + return ccipcore.SendingMessageV1{}, fmt.Errorf("unmarshal SendingMessageV1: %w", err) + } + return *msg, nil + } + + return ccipcore.SendingMessageV1{}, fmt.Errorf("SendingMessageV1 %s not in ACS", contractID) +} + +// SetBurnMintFactoryInput identifies contracts for pointing TokenConfig at a burn-mint factory. +type SetBurnMintFactoryInput struct { + TokenAdminRegistryCID string + TokenConfigCID string + InstrumentId splice_api_token_holding_v1.InstrumentId + BurnMintFactoryCID string + CcipParty string + PoolOwnerParty string + CcipClient ledger.Client + PoolOwnerClient ledger.Client +} + +// SetBurnMintFactory exercises TokenAdminRegistry.SetBurnMintFactory and returns the updated TokenConfig CID. +func SetBurnMintFactory(ctx context.Context, client ledger.Client, input SetBurnMintFactoryInput) (string, error) { + ccipClient := input.CcipClient + if ccipClient == nil { + ccipClient = client + } + poolOwnerClient := input.PoolOwnerClient + if poolOwnerClient == nil { + poolOwnerClient = client + } + + tarDisclosed, err := registry.DiscloseByID(ctx, ccipClient, input.CcipParty, input.TokenAdminRegistryCID) + if err != nil { + return "", err + } + + factoryCID := types.CONTRACT_ID(input.BurnMintFactoryCID) + res, err := poolOwnerClient.SubmitExerciseMulti(ctx, []string{input.PoolOwnerParty}, ccipcore.TokenAdminRegistry{}, input.TokenAdminRegistryCID, "SetBurnMintFactory", + ccipcore.SetBurnMintFactory{ + TokenConfigCid: types.CONTRACT_ID(input.TokenConfigCID), + InstrumentId: input.InstrumentId, + BurnMintFactory: &factoryCID, + Caller: types.PARTY(input.PoolOwnerParty), + }, []*apiv2.DisclosedContract{tarDisclosed}) + if err != nil { + return "", fmt.Errorf("set burn mint factory: %w", err) + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "TokenConfig") + if !ok { + return "", fmt.Errorf("TokenConfig not created after SetBurnMintFactory") + } + + return cid, nil +} + +// EncodeUint256Hex encodes a base-10 integer string as a 32-byte hex string (CCIP MessageCodec style). +func EncodeUint256Hex(decimalValue string) string { + n := new(big.Int) + _, ok := n.SetString(decimalValue, 10) + if !ok { + panic("invalid decimal: " + decimalValue) + } + hexStr := n.Text(16) + return strings.Repeat("0", 64-len(hexStr)) + hexStr +} + +func rawInstanceAddressBinding(instanceID, owner string) chainlinkapi.RawInstanceAddress { + return bindRawInstanceAddress(contracts.NewRawInstanceAddress(contracts.InstanceID(instanceID), types.PARTY(owner))) +} + +func bindRawInstanceAddress(raw contracts.RawInstanceAddress) chainlinkapi.RawInstanceAddress { + return chainlinkapi.RawInstanceAddress{Unpack: types.TEXT(raw.String())} +} + +func instanceAddressHex(instanceID, owner string) string { + raw := contracts.NewRawInstanceAddress(contracts.InstanceID(instanceID), types.PARTY(owner)) + return strings.TrimPrefix(raw.InstanceAddress().Hex(), "0x") +} diff --git a/registry-kit/ccip/validate.go b/registry-kit/ccip/validate.go new file mode 100644 index 000000000..432e3f571 --- /dev/null +++ b/registry-kit/ccip/validate.go @@ -0,0 +1,65 @@ +package ccip + +import ( + "context" + "encoding/hex" + "fmt" + "strings" + + "github.com/smartcontractkit/chainlink-canton/bindings" + ccipcore "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/core" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// Validate performs read-only checks that TAR maps the instrument to the expected pool. +func Validate( + ctx context.Context, + client ledger.Client, + instrumentID splice_api_token_holding_v1.InstrumentId, + ccipParty, poolInstanceID string, +) error { + tokenConfigAddr := contracts.InstanceID(hex.EncodeToString(contracts.EncodeInstrumentID(instrumentID).Bytes())). + RawInstanceAddress(types.PARTY(ccipParty)). + InstanceAddress() + + participant := client.Participant() + active, err := contract.FindActiveContractByInstanceAddress( + ctx, + participant.LedgerServices.State, + contract.LedgerQueryParties(participant), + ccipcore.TokenConfig{}.GetTemplateID(), + tokenConfigAddr, + ) + if err != nil { + if strings.Contains(err.Error(), "no active contract found") { + return fmt.Errorf("token config not found for instrument %s/%s", instrumentID.Admin, instrumentID.Id) + } + return fmt.Errorf("fetch token config: %w", err) + } + cfg, err := bindings.UnmarshalCreatedEvent[ccipcore.TokenConfig](active.GetCreatedEvent()) + if err != nil { + return fmt.Errorf("unmarshal token config: %w", err) + } + if cfg.Admin == nil || string(*cfg.Admin) == "" { + return fmt.Errorf("token admin not set for instrument %s/%s", instrumentID.Admin, instrumentID.Id) + } + if cfg.TokenPool == nil { + return fmt.Errorf("token pool not registered for instrument %s/%s", instrumentID.Admin, instrumentID.Id) + } + if string(cfg.TokenPool.PoolInstanceId) != poolInstanceID { + return fmt.Errorf("pool instance: expected %s got %s", poolInstanceID, cfg.TokenPool.PoolInstanceId) + } + + // Holdings visibility: query succeeds (may be zero balance). + _, err = testhelpers.ListHoldingsForInstrument(ctx, client.ForParty(string(instrumentID.Admin)), &instrumentID) + if err != nil { + return fmt.Errorf("holdings not visible for instrument: %w", err) + } + + return nil +} diff --git a/registry-kit/cmd/issuer.go b/registry-kit/cmd/issuer.go new file mode 100644 index 000000000..8f2728a7c --- /dev/null +++ b/registry-kit/cmd/issuer.go @@ -0,0 +1,180 @@ +package cmd + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" +) + +var issuerCmd = &cobra.Command{ + Use: "issuer", + Short: "Registry token lifecycle commands", +} + +var ( + mintAmount string + mintHolder string +) + +func init() { + issuerCmd.AddCommand(createInstrumentCmd) + issuerCmd.AddCommand(mintCmd) + issuerCmd.AddCommand(acceptMintCmd) + issuerCmd.AddCommand(querySupplyCmd) + issuerCmd.AddCommand(issueCredentialCmd) + + mintCmd.Flags().StringVar(&mintAmount, "amount", "", "Amount to mint (required)") + mintCmd.Flags().StringVar(&mintHolder, "holder", "", "Holder party (default: registrar)") + _ = mintCmd.MarkFlagRequired("amount") +} + +var createInstrumentCmd = &cobra.Command{ + Use: "create-instrument [instrument-id]", + Short: "Create InstrumentConfiguration with empty credential requirements", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + instrumentID := args[0] + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + registrarSvcCID := rt.State.RegistrarServiceCID + if registrarSvcCID == "" { + return fmt.Errorf("registrar_service_cid missing in state — run onboarding onboard-registrar first") + } + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + instCfgCID, err := registry.CreateInstrumentConfiguration(cmd.Context(), client, rt.Config.Parties.Registrar, registrarSvcCID, instrumentID) + if err != nil { + return err + } + rt.State.InstrumentID = instrumentID + rt.State.InstrumentConfigurationCID = instCfgCID + if err := rt.saveState(); err != nil { + return err + } + fmt.Println("InstrumentConfiguration CID:", instCfgCID) + fmt.Printf("Next: issuer mint --amount (instrument %s)\n", instrumentID) + return nil + }, +} + +var mintCmd = &cobra.Command{ + Use: "mint", + Short: "Request mint via AllocationFactory (DA operator backend context)", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + if rt.State.InstrumentID == "" { + return fmt.Errorf("instrument_id missing in state — run create-instrument first") + } + allocCID := rt.State.AllocationFactoryCID + if allocCID == "" { + return fmt.Errorf("allocation_factory_cid missing in state — run onboarding onboard-registrar or discover-registry-factories") + } + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + holder := mintHolder + if holder == "" { + holder = rt.Config.Parties.Registrar + } + mintReqCID, err := registry.RequestMintViaOperatorBackend(cmd.Context(), client, rt.operatorClient(), registry.MintDevnetInput{ + RegistrarParty: rt.Config.Parties.Registrar, + InstrumentID: rt.State.InstrumentID, + AllocationFactoryCID: allocCID, + Holder: holder, + Amount: mintAmount, + }) + if err != nil { + return err + } + rt.State.LastMintRequestCID = mintReqCID + if err := rt.saveState(); err != nil { + return err + } + fmt.Println("MintRequest CID:", mintReqCID) + fmt.Println("Next: issuer accept-mint") + return nil + }, +} + +var acceptMintCmd = &cobra.Command{ + Use: "accept-mint", + Short: "Accept pending mint request (DA operator backend context)", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + mintReqCID := rt.State.LastMintRequestCID + if mintReqCID == "" { + client, _, cerr := rt.connect(cmd.Context(), "registrar") + if cerr != nil { + return cerr + } + mintReqCID, err = registry.FindMintRequestForInstrument(cmd.Context(), client, rt.Config.Parties.Registrar, rt.State.InstrumentID) + if err != nil { + return err + } + if mintReqCID == "" { + return fmt.Errorf("no MintRequest CID in state or ACS — run issuer mint first") + } + } + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + holdingCID, err := registry.AcceptMintViaOperatorBackend(cmd.Context(), client, rt.operatorClient(), rt.Config.Parties.Registrar, mintReqCID) + if err != nil { + return err + } + fmt.Println("Registry Holding CID:", holdingCID) + return nil + }, +} + +var querySupplyCmd = &cobra.Command{ + Use: "query-supply", + Short: "Aggregate Registry Holding balances for the configured instrument", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + if rt.State.InstrumentID == "" { + return fmt.Errorf("instrument_id missing in state — run create-instrument first") + } + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + total, rows, err := registry.QuerySupply(cmd.Context(), client, rt.Config.Parties.Registrar, rt.State.InstrumentID) + if err != nil { + return err + } + fmt.Printf("Instrument %s total supply: %s\n", rt.State.InstrumentID, total.String()) + for _, row := range rows { + fmt.Printf(" owner=%s amount=%s cid=%s\n", row.Owner, row.Amount.String(), row.ContractID) + } + if total.IsZero() && len(rows) == 0 { + fmt.Println("(no holdings found)") + } + return nil + }, +} + +var issueCredentialCmd = &cobra.Command{ + Use: "issue-credential", + Short: "Issue registrar credential (only when instrument requires credentials)", + RunE: func(_ *cobra.Command, _ []string) error { + return fmt.Errorf("issue-credential not implemented — use empty credential requirements or DA credential utility docs") + }, +} diff --git a/registry-kit/cmd/onboarding.go b/registry-kit/cmd/onboarding.go new file mode 100644 index 000000000..7455179de --- /dev/null +++ b/registry-kit/cmd/onboarding.go @@ -0,0 +1,202 @@ +package cmd + +import ( + "fmt" + "os" + "time" + + "github.com/spf13/cobra" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/registry" +) + +var onboardingCmd = &cobra.Command{ + Use: "onboarding", + Short: "Registry utility onboarding commands", +} + +var ( + waitProviderTimeout string +) + +func init() { + onboardingCmd.AddCommand(checkPackagesCmd) + onboardingCmd.AddCommand(requestProviderServiceCmd) + onboardingCmd.AddCommand(waitProviderServiceCmd) + onboardingCmd.AddCommand(onboardRegistrarCmd) + onboardingCmd.AddCommand(discoverRegistryFactoriesCmd) + onboardingCmd.AddCommand(requestCredentialServiceCmd) + + waitProviderServiceCmd.Flags().StringVar(&waitProviderTimeout, "timeout", "15m", "Maximum wait for DA operator acceptance") +} + +var checkPackagesCmd = &cobra.Command{ + Use: "check-packages", + Short: "Verify required Registry utility DARs are on the participant", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + _, participant, err := rt.connect(cmd.Context(), "provider") + if err != nil { + return err + } + results, err := registry.CheckPackages(cmd.Context(), participant) + for _, r := range results { + status := "missing" + if r.Found { + status = "ok" + } + fmt.Printf("%s %s %s\n", status, r.Name, r.Expected) + } + if err != nil { + return err + } + fmt.Println("all required Registry packages present") + return nil + }, +} + +var requestProviderServiceCmd = &cobra.Command{ + Use: "request-provider-service", + Short: "Submit ProviderServiceRequest (DA operator must accept)", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + client, _, err := rt.connect(cmd.Context(), "provider") + if err != nil { + return err + } + cid, err := registry.RequestProviderService(cmd.Context(), client, registry.OnboardingParties{ + Operator: rt.Config.Parties.Operator, + Provider: rt.Config.Parties.Provider, + }) + if err != nil { + return err + } + rt.State.ProviderServiceRequestCID = cid + if err := rt.saveState(); err != nil { + return err + } + fmt.Println("ProviderServiceRequest CID:", cid) + fmt.Println("Next: onboarding wait-provider-service") + return nil + }, +} + +var waitProviderServiceCmd = &cobra.Command{ + Use: "wait-provider-service", + Short: "Poll until ProviderService exists after DA acceptance", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + timeout, err := time.ParseDuration(waitProviderTimeout) + if err != nil { + return fmt.Errorf("invalid --timeout: %w", err) + } + client, _, err := rt.connect(cmd.Context(), "provider") + if err != nil { + return err + } + cid, err := registry.WaitForProviderService(cmd.Context(), client, rt.Config.Parties.Provider, timeout) + if err != nil { + return err + } + rt.State.ProviderServiceCID = cid + if err := rt.saveState(); err != nil { + return err + } + fmt.Println("ProviderService CID:", cid) + fmt.Println("Next: onboarding onboard-registrar") + return nil + }, +} + +var onboardRegistrarCmd = &cobra.Command{ + Use: "onboard-registrar", + Short: "Provider accepts registrar service request (creates AllocationFactory + TransferRule)", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + providerSvcCID := rt.State.ProviderServiceCID + if providerSvcCID == "" { + return fmt.Errorf("provider_service_cid missing in state — run wait-provider-service first") + } + client, _, err := rt.connect(cmd.Context(), "provider") + if err != nil { + return err + } + result, err := registry.OnboardRegistrar(cmd.Context(), client, registry.OnboardingParties{ + Operator: rt.Config.Parties.Operator, + Provider: rt.Config.Parties.Provider, + Registrar: rt.Config.Parties.Registrar, + }, providerSvcCID) + if err != nil { + return err + } + rt.State.ProviderConfigurationCID = result.ProviderConfigurationCID + rt.State.RegistrarServiceRequestCID = result.RegistrarServiceRequestCID + rt.State.RegistrarServiceCID = result.RegistrarServiceCID + rt.State.AllocationFactoryCID = result.AllocationFactoryCID + rt.State.TransferRuleCID = result.TransferRuleCID + if err := rt.saveState(); err != nil { + return err + } + fmt.Println("RegistrarService CID:", result.RegistrarServiceCID) + fmt.Println("AllocationFactory CID:", result.AllocationFactoryCID) + if result.TransferRuleCID != "" { + fmt.Println("TransferRule CID:", result.TransferRuleCID) + } + fmt.Println("Next: issuer create-instrument ") + return nil + }, +} + +var discoverRegistryFactoriesCmd = &cobra.Command{ + Use: "discover-registry-factories", + Short: "List Registry service contracts visible to the registrar party", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + disc, err := registry.DiscoverFactories(cmd.Context(), client, rt.Config.Parties.Registrar) + if err != nil { + return err + } + printDiscovery("ProviderService", disc.ProviderService) + printDiscovery("RegistrarService", disc.RegistrarService) + printDiscovery("AllocationFactory", disc.AllocationFactory) + printDiscovery("TransferRule", disc.TransferRule) + printDiscovery("InstrumentConfiguration", disc.InstrumentConfiguration) + return nil + }, +} + +var requestCredentialServiceCmd = &cobra.Command{ + Use: "request-credential-service", + Short: "Request Credential User Service (not required when using empty credential requirements)", + RunE: func(_ *cobra.Command, _ []string) error { + fmt.Fprintln(os.Stderr, "Credential User Service onboarding is not automated in this release.") + fmt.Fprintln(os.Stderr, "Use empty holderRequirements/issuerRequirements on instruments, or follow DA credential utility docs.") + return fmt.Errorf("request-credential-service not implemented") + }, +} + +func printDiscovery(label string, refs []registry.ContractRef) { + fmt.Printf("\n%s (%d):\n", label, len(refs)) + for _, ref := range refs { + fmt.Printf(" %s %s\n", ref.ContractID, ref.TemplateID) + } +} diff --git a/registry-kit/cmd/operator.go b/registry-kit/cmd/operator.go new file mode 100644 index 000000000..0d70182f6 --- /dev/null +++ b/registry-kit/cmd/operator.go @@ -0,0 +1,126 @@ +package cmd + +import ( + "fmt" + + "github.com/spf13/cobra" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/ccip" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +var operatorCmd = &cobra.Command{ + Use: "operator", + Short: "CCIP TokenAdminRegistry linking and validation", +} + +func init() { + operatorCmd.AddCommand(linkTokenToPoolCmd) + operatorCmd.AddCommand(validateCmd) + operatorCmd.AddCommand(acceptAdminRoleCmd) +} + +var linkTokenToPoolCmd = &cobra.Command{ + Use: "link-token-to-pool", + Short: "Propose administrator, accept admin role, and set BurnMint pool on TAR", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + if rt.State.InstrumentID == "" { + return fmt.Errorf("instrument_id missing in state — run issuer create-instrument first") + } + if rt.Config.CCIP.TokenAdminRegistryCID == "" { + return fmt.Errorf("ccip.token_admin_registry_cid is required in config") + } + if rt.Config.CCIP.CCIPParty == "" { + return fmt.Errorf("ccip.ccip_party is required in config") + } + if rt.Config.CCIP.BurnMintPoolInstanceID == "" { + return fmt.Errorf("ccip.burn_mint_pool_instance_id is required in config") + } + + instrumentID := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(rt.Config.Parties.Registrar), + Id: types.TEXT(rt.State.InstrumentID), + } + + // Connect as CCIP party for TAR lookups and ProposeAdministrator disclosures. + client, _, err := ledger.ConnectDevnet(cmd.Context(), rt.Config, rt.Config.CCIP.CCIPParty) + if err != nil { + return fmt.Errorf("connect as ccip party: %w", err) + } + + tokenConfigCID, tarCID, err := ccip.RegisterTokenPoolViaClient(cmd.Context(), client, ccip.RegisterTokenPoolClientInput{ + TokenAdminRegistryCID: rt.Config.CCIP.TokenAdminRegistryCID, + InstrumentId: instrumentID, + PoolInstanceID: rt.Config.CCIP.BurnMintPoolInstanceID, + CcipParty: rt.Config.CCIP.CCIPParty, + PoolOwnerParty: rt.Config.Parties.Registrar, + }) + if err != nil { + return err + } + + rt.State.TokenConfigCID = tokenConfigCID + rt.State.TokenAdminRegistryCID = tarCID + if err := rt.saveState(); err != nil { + return err + } + + fmt.Println("TokenConfig CID:", tokenConfigCID) + fmt.Println("TokenAdminRegistry CID:", tarCID) + fmt.Println("Next: operator validate") + return nil + }, +} + +var acceptAdminRoleCmd = &cobra.Command{ + Use: "accept-admin-role", + Short: "Accept TAR admin role only (when ProposeAdministrator already ran)", + RunE: func(_ *cobra.Command, _ []string) error { + return fmt.Errorf("accept-admin-role is included in link-token-to-pool — run that command instead") + }, +} + +var validateCmd = &cobra.Command{ + Use: "validate", + Short: "Read-only checks: TAR maps instrument to pool and holdings are visible", + RunE: func(cmd *cobra.Command, _ []string) error { + rt, err := loadRuntime(configPath, statePath) + if err != nil { + return err + } + if rt.State.InstrumentID == "" { + return fmt.Errorf("instrument_id missing in state") + } + if rt.Config.CCIP.BurnMintPoolInstanceID == "" { + return fmt.Errorf("ccip.burn_mint_pool_instance_id is required in config") + } + if rt.Config.CCIP.CCIPParty == "" { + return fmt.Errorf("ccip.ccip_party is required in config") + } + + instrumentID := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(rt.Config.Parties.Registrar), + Id: types.TEXT(rt.State.InstrumentID), + } + + client, _, err := rt.connect(cmd.Context(), "registrar") + if err != nil { + return err + } + + if err := ccip.Validate(cmd.Context(), client, instrumentID, rt.Config.CCIP.CCIPParty, rt.Config.CCIP.BurnMintPoolInstanceID); err != nil { + return err + } + + fmt.Println("validate: ok") + fmt.Printf(" instrument admin=%s id=%s\n", instrumentID.Admin, instrumentID.Id) + fmt.Printf(" pool instance=%s\n", rt.Config.CCIP.BurnMintPoolInstanceID) + return nil + }, +} diff --git a/registry-kit/cmd/root.go b/registry-kit/cmd/root.go new file mode 100644 index 000000000..b43802d08 --- /dev/null +++ b/registry-kit/cmd/root.go @@ -0,0 +1,41 @@ +package cmd + +import ( + "fmt" + "os" + + "github.com/spf13/cobra" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/config" +) + +var ( + configPath string + statePath string +) + +var rootCmd = &cobra.Command{ + Use: "canton-registry-kit", + Short: "DevNet CLI for Canton Registry token onboarding and CCIP pool linking", + Long: `canton-registry-kit automates Registry utility onboarding, token lifecycle, +and CCIP TokenAdminRegistry linking on devnet.cv1. + +Configuration: registry-kit.toml (stable inputs) + registry-kit.state.json (progress).`, +} + +func Execute() error { + return rootCmd.Execute() +} + +func init() { + rootCmd.PersistentFlags().StringVar(&configPath, "config", config.DefaultConfigPath, "Path to registry-kit.toml") + rootCmd.PersistentFlags().StringVar(&statePath, "state", "", "Path to registry-kit.state.json (default: beside --config)") + + rootCmd.AddCommand(onboardingCmd) + rootCmd.AddCommand(issuerCmd) + rootCmd.AddCommand(operatorCmd) +} + +func printErr(err error) { + fmt.Fprintln(os.Stderr, "error:", err) +} diff --git a/registry-kit/cmd/runtime.go b/registry-kit/cmd/runtime.go new file mode 100644 index 000000000..5eaad17f8 --- /dev/null +++ b/registry-kit/cmd/runtime.go @@ -0,0 +1,64 @@ +package cmd + +import ( + "context" + "fmt" + "time" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/config" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/operator" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" +) + +// Runtime holds loaded config, state, and live ledger connections for one command. +type Runtime struct { + ConfigPath string + StatePath string + Config config.Config + State config.State +} + +func loadRuntime(configPath, statePath string) (Runtime, error) { + cfg, err := config.Load(configPath) + if err != nil { + return Runtime{}, err + } + if statePath == "" { + statePath = config.StatePathNextTo(configPath) + } + st, err := config.LoadState(statePath) + if err != nil { + return Runtime{}, err + } + return Runtime{ + ConfigPath: configPath, + StatePath: statePath, + Config: cfg, + State: st, + }, nil +} + +func (rt *Runtime) saveState() error { + return rt.State.Save(rt.StatePath) +} + +func (rt *Runtime) connect(ctx context.Context, partyRole string) (ledger.Client, canton.Participant, error) { + party, err := rt.Config.ActingParty(partyRole) + if err != nil { + return nil, canton.Participant{}, err + } + client, participant, err := ledger.ConnectDevnet(ctx, rt.Config, party) + if err != nil { + return nil, canton.Participant{}, fmt.Errorf("connect devnet as %s: %w", party, err) + } + return client, participant, nil +} + +func (rt *Runtime) operatorClient() *operator.Client { + return operator.NewClient(rt.Config.Operator.BaseURL) +} + +func (rt *Runtime) waitTimeout() time.Duration { + return 15 * time.Minute +} diff --git a/registry-kit/config/config.go b/registry-kit/config/config.go new file mode 100644 index 000000000..5d54c9224 --- /dev/null +++ b/registry-kit/config/config.go @@ -0,0 +1,128 @@ +package config + +import ( + "fmt" + "os" + + "github.com/BurntSushi/toml" + + "github.com/smartcontractkit/chainlink-canton/commonconfig" +) + +const DefaultConfigPath = "registry-kit.toml" + +// Config is stable operator input for canton-registry-kit (devnet.cv1). +type Config struct { + Network string `toml:"network"` + ChainSelector uint64 `toml:"chain_selector"` + Ledger LedgerConfig `toml:"ledger"` + Parties PartiesConfig `toml:"parties"` + CCIP CCIPConfig `toml:"ccip"` + Operator OperatorConfig `toml:"operator_backend"` +} + +// LedgerConfig holds Canton participant API endpoints and auth. +type LedgerConfig struct { + JSONAPIURL string `toml:"json_api_url"` + GRPCLedgerAPIURL string `toml:"grpc_ledger_api_url"` + AdminAPIURL string `toml:"admin_api_url"` + ValidatorAPIURL string `toml:"validator_api_url"` + UserID string `toml:"user_id"` + SynchronizerID string `toml:"synchronizer_id"` + Auth commonconfig.AuthConfig `toml:"auth"` +} + +// PartiesConfig lists Registry role parties on devnet. +type PartiesConfig struct { + Operator string `toml:"operator"` + Provider string `toml:"provider"` + Registrar string `toml:"registrar"` + Holder string `toml:"holder"` +} + +// CCIPConfig references pre-deployed CCIP contracts on the participant. +type CCIPConfig struct { + TokenAdminRegistryCID string `toml:"token_admin_registry_cid"` + CCIPParty string `toml:"ccip_party"` + BurnMintPoolInstanceID string `toml:"burn_mint_pool_instance_id"` +} + +// OperatorConfig is DA's hosted Utilities operator backend (mint/burn choice context). +type OperatorConfig struct { + BaseURL string `toml:"base_url"` +} + +// Load reads registry-kit.toml from path. +func Load(path string) (Config, error) { + data, err := os.ReadFile(path) + if err != nil { + return Config{}, fmt.Errorf("read config %q: %w", path, err) + } + + var cfg Config + if err := toml.Unmarshal(data, &cfg); err != nil { + return Config{}, fmt.Errorf("parse config %q: %w", path, err) + } + + if err := cfg.Validate(); err != nil { + return Config{}, err + } + cfg.applyDefaults() + + return cfg, nil +} + +func (c *Config) applyDefaults() { + if c.Operator.BaseURL == "" { + c.Operator.BaseURL = "https://api.utilities.digitalasset-dev.com/api/utilities" + } +} + +// Validate checks required fields for devnet CLI usage. +func (c Config) Validate() error { + if c.Ledger.JSONAPIURL == "" { + return fmt.Errorf("ledger.json_api_url is required") + } + if c.Ledger.GRPCLedgerAPIURL == "" { + return fmt.Errorf("ledger.grpc_ledger_api_url is required") + } + if c.Ledger.UserID == "" { + return fmt.Errorf("ledger.user_id is required") + } + if c.Ledger.SynchronizerID == "" { + return fmt.Errorf("ledger.synchronizer_id is required") + } + if err := c.Ledger.Auth.Validate(); err != nil { + return fmt.Errorf("ledger.auth: %w", err) + } + if c.Parties.Operator == "" { + return fmt.Errorf("parties.operator is required") + } + if c.Parties.Provider == "" { + return fmt.Errorf("parties.provider is required") + } + if c.Parties.Registrar == "" { + return fmt.Errorf("parties.registrar is required") + } + + return nil +} + +// ActingParty returns the party used for ledger commands when a role flag is omitted. +func (c Config) ActingParty(role string) (string, error) { + switch role { + case "", "registrar": + return c.Parties.Registrar, nil + case "provider": + return c.Parties.Provider, nil + case "operator": + return c.Parties.Operator, nil + case "holder": + if c.Parties.Holder != "" { + return c.Parties.Holder, nil + } + return c.Parties.Registrar, nil + default: + return "", fmt.Errorf("unknown party role %q", role) + } +} diff --git a/registry-kit/config/config_test.go b/registry-kit/config/config_test.go new file mode 100644 index 000000000..96dda5ba7 --- /dev/null +++ b/registry-kit/config/config_test.go @@ -0,0 +1,80 @@ +package config + +import ( + "os" + "path/filepath" + "testing" + + "github.com/smartcontractkit/chainlink-canton/commonconfig" + "github.com/stretchr/testify/require" +) + +func TestLoadAndStateRoundTrip(t *testing.T) { + dir := t.TempDir() + cfgPath := filepath.Join(dir, "registry-kit.toml") + require.NoError(t, os.WriteFile(cfgPath, []byte(` +network = "devnet-cv1" + +[ledger] +json_api_url = "https://example.test/api/json" +grpc_ledger_api_url = "example.test:443" +admin_api_url = "example.test:443" +user_id = "user-1" +synchronizer_id = "global-domain::abc" + +[ledger.auth] +type = "insecureStatic" +jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.KMUFsIDTnFmyG3nMiGM6H9FNFUROf3wh7SmqJp-QV30" + +[parties] +operator = "op::1" +provider = "prov::1" +registrar = "reg::1" + +[ccip] +token_admin_registry_cid = "tar-cid" +ccip_party = "ccip::1" +burn_mint_pool_instance_id = "pool-1" +`), 0o644)) + + cfg, err := Load(cfgPath) + require.NoError(t, err) + require.Equal(t, "devnet-cv1", cfg.Network) + require.Equal(t, commonconfig.AuthTypeInsecureStatic, cfg.Ledger.Auth.Type) + + statePath := StatePathNextTo(cfgPath) + st := State{InstrumentID: "TEST-USD", RegistrarServiceCID: "reg-svc"} + require.NoError(t, st.Save(statePath)) + + loaded, err := LoadState(statePath) + require.NoError(t, err) + require.Equal(t, "TEST-USD", loaded.InstrumentID) +} + +func TestLoadAppliesOperatorBackendDefault(t *testing.T) { + dir := t.TempDir() + cfgPath := filepath.Join(dir, "registry-kit.toml") + require.NoError(t, os.WriteFile(cfgPath, []byte(` +network = "devnet-cv1" + +[ledger] +json_api_url = "https://example.test/api/json" +grpc_ledger_api_url = "example.test:443" +admin_api_url = "example.test:443" +user_id = "user-1" +synchronizer_id = "global-domain::abc" + +[ledger.auth] +type = "insecureStatic" +jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.KMUFsIDTnFmyG3nMiGM6H9FNFUROf3wh7SmqJp-QV30" + +[parties] +operator = "op::1" +provider = "prov::1" +registrar = "reg::1" +`), 0o644)) + + cfg, err := Load(cfgPath) + require.NoError(t, err) + require.Equal(t, "https://api.utilities.digitalasset-dev.com/api/utilities", cfg.Operator.BaseURL) +} diff --git a/registry-kit/config/state.go b/registry-kit/config/state.go new file mode 100644 index 000000000..e6ad8ac81 --- /dev/null +++ b/registry-kit/config/state.go @@ -0,0 +1,76 @@ +package config + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" +) + +const DefaultStatePath = "registry-kit.state.json" + +// State tracks contract IDs produced by CLI steps (machine-written progress). +type State struct { + ProviderServiceRequestCID string `json:"provider_service_request_cid,omitempty"` + ProviderServiceCID string `json:"provider_service_cid,omitempty"` + ProviderConfigurationCID string `json:"provider_configuration_cid,omitempty"` + RegistrarServiceRequestCID string `json:"registrar_service_request_cid,omitempty"` + RegistrarServiceCID string `json:"registrar_service_cid,omitempty"` + AllocationFactoryCID string `json:"allocation_factory_cid,omitempty"` + TransferRuleCID string `json:"transfer_rule_cid,omitempty"` + InstrumentID string `json:"instrument_id,omitempty"` + InstrumentConfigurationCID string `json:"instrument_configuration_cid,omitempty"` + LastMintRequestCID string `json:"last_mint_request_cid,omitempty"` + TokenConfigCID string `json:"token_config_cid,omitempty"` + TokenAdminRegistryCID string `json:"token_admin_registry_cid,omitempty"` +} + +// LoadState reads registry-kit.state.json. Missing file yields an empty state. +func LoadState(path string) (State, error) { + data, err := os.ReadFile(path) + if err != nil { + if os.IsNotExist(err) { + return State{}, nil + } + return State{}, fmt.Errorf("read state %q: %w", path, err) + } + + var st State + if err := json.Unmarshal(data, &st); err != nil { + return State{}, fmt.Errorf("parse state %q: %w", path, err) + } + + return st, nil +} + +// Save writes state atomically next to the config directory when path is relative. +func (s State) Save(path string) error { + if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil && filepath.Dir(path) != "." { + return fmt.Errorf("create state dir: %w", err) + } + + data, err := json.MarshalIndent(s, "", " ") + if err != nil { + return fmt.Errorf("marshal state: %w", err) + } + data = append(data, '\n') + + tmp := path + ".tmp" + if err := os.WriteFile(tmp, data, 0o644); err != nil { + return fmt.Errorf("write state temp: %w", err) + } + if err := os.Rename(tmp, path); err != nil { + return fmt.Errorf("rename state: %w", err) + } + + return nil +} + +// StatePathNextTo returns registry-kit.state.json beside the config file. +func StatePathNextTo(configPath string) string { + dir := filepath.Dir(configPath) + if dir == "" { + dir = "." + } + return filepath.Join(dir, DefaultStatePath) +} diff --git a/registry-kit/go.mod b/registry-kit/go.mod new file mode 100644 index 000000000..5dec0fe7d --- /dev/null +++ b/registry-kit/go.mod @@ -0,0 +1,286 @@ +module github.com/smartcontractkit/chainlink-canton/registry-kit + +go 1.26.2 + +replace github.com/fbsobreira/gotron-sdk => github.com/smartcontractkit/chainlink-tron/relayer/gotron-sdk v0.0.5-0.20251014124537-af6b1684fe15 + +replace github.com/smartcontractkit/chainlink-canton => ../ + +replace ( + github.com/smartcontractkit/chainlink-ccip => github.com/smartcontractkit/chainlink-ccip v0.0.0-20260416055149-75c017f534ca + github.com/ugorji/go/codec => github.com/ugorji/go/codec v1.2.12 +) + +require ( + github.com/BurntSushi/toml v1.6.0 + github.com/digital-asset/dazl-client/v8 v8.9.0 + github.com/google/uuid v1.6.0 + github.com/shopspring/decimal v1.4.0 + github.com/smartcontractkit/chainlink-canton v0.0.0 + github.com/smartcontractkit/chainlink-common v0.11.2-0.20260506120607-7f10be016c89 + github.com/smartcontractkit/chainlink-deployments-framework v0.109.0 + github.com/smartcontractkit/go-daml v0.0.0-20260610225315-f38fea9a45b0 + github.com/spf13/cobra v1.10.2 + github.com/stretchr/testify v1.11.1 +) + +require ( + cloud.google.com/go/compute/metadata v0.9.0 // indirect + dario.cat/mergo v1.0.2 // indirect + filippo.io/edwards25519 v1.1.1 // indirect + github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect + github.com/Masterminds/semver/v3 v3.5.0 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/ProjectZKM/Ziren/crates/go-runtime/zkvm_runtime v0.0.0-20251001021608-1fe7b43fc4d6 // indirect + github.com/XSAM/otelsql v0.37.0 // indirect + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect + github.com/aptos-labs/aptos-go-sdk v1.13.0 // indirect + github.com/avast/retry-go/v4 v4.7.0 // indirect + github.com/aws/smithy-go v1.27.1 // indirect + github.com/bahlo/generic-list-go v0.2.0 // indirect + github.com/benbjohnson/clock v1.3.5 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/bits-and-blooms/bitset v1.24.0 // indirect + github.com/blendle/zapdriver v1.3.1 // indirect + github.com/block-vision/sui-go-sdk v1.2.1 // indirect + github.com/btcsuite/btcd v0.24.2 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect + github.com/btcsuite/btcd/btcutil v1.1.6 // indirect + github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect + github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce // indirect + github.com/buger/jsonparser v1.1.2 // indirect + github.com/bytedance/gopkg v0.1.3 // indirect + github.com/bytedance/sonic v1.15.0 // indirect + github.com/bytedance/sonic/loader v0.5.0 // indirect + github.com/cenkalti/backoff/v4 v4.3.0 // indirect + github.com/cenkalti/backoff/v5 v5.0.3 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cloudevents/sdk-go/binding/format/protobuf/v2 v2.16.2 // indirect + github.com/cloudevents/sdk-go/v2 v2.16.2 // indirect + github.com/cloudwego/base64x v0.1.6 // indirect + github.com/coder/websocket v1.8.14 // indirect + github.com/consensys/gnark-crypto v0.19.2 // indirect + github.com/containerd/errdefs v1.0.0 // indirect + github.com/containerd/errdefs/pkg v0.3.0 // indirect + github.com/containerd/log v0.1.0 // indirect + github.com/containerd/platforms v1.0.0-rc.2 // indirect + github.com/cosmos/go-bip39 v1.0.0 // indirect + github.com/cpuguy83/dockercfg v0.3.2 // indirect + github.com/crate-crypto/go-eth-kzg v1.5.0 // indirect + github.com/creachadair/jrpc2 v1.2.0 // indirect + github.com/creachadair/mds v0.13.4 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/deckarep/golang-set/v2 v2.8.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect + github.com/distribution/reference v0.6.0 // indirect + github.com/docker/go-connections v0.7.0 // indirect + github.com/docker/go-units v0.5.0 // indirect + github.com/ebitengine/purego v0.10.0 // indirect + github.com/emicklei/go-restful/v3 v3.12.1 // indirect + github.com/ethereum/c-kzg-4844/v2 v2.1.6 // indirect + github.com/ethereum/go-ethereum v1.17.3 // indirect + github.com/fatih/color v1.19.0 // indirect + github.com/fbsobreira/gotron-sdk v0.0.0-20250403083053-2943ce8c759b // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/fxamacker/cbor/v2 v2.9.0 // indirect + github.com/gabriel-vasile/mimetype v1.4.13 // indirect + github.com/gagliardetto/binary v0.8.0 // indirect + github.com/gagliardetto/solana-go v1.13.0 // indirect + github.com/gagliardetto/treeout v0.1.4 // indirect + github.com/gin-contrib/sse v1.1.0 // indirect + github.com/gin-gonic/gin v1.12.0 // indirect + github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874 // indirect + github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/go-openapi/jsonpointer v0.21.0 // indirect + github.com/go-openapi/jsonreference v0.21.0 // indirect + github.com/go-openapi/swag v0.23.0 // indirect + github.com/go-playground/locales v0.14.1 // indirect + github.com/go-playground/universal-translator v0.18.1 // indirect + github.com/go-playground/validator/v10 v10.30.3 // indirect + github.com/go-resty/resty/v2 v2.17.2 // indirect + github.com/go-viper/mapstructure/v2 v2.5.0 // indirect + github.com/goccy/go-json v0.10.5 // indirect + github.com/goccy/go-yaml v1.19.2 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang-jwt/jwt/v5 v5.3.1 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/gnostic-models v0.6.9 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/gorilla/websocket v1.5.3 // indirect + github.com/grafana/otel-profiling-go v0.5.1 // indirect + github.com/grafana/pyroscope-go v1.2.8 // indirect + github.com/grafana/pyroscope-go/godeltaprof v0.1.9 // indirect + github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc // indirect + github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1 // indirect + github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.2 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect + github.com/hashicorp/go-hclog v1.6.3 // indirect + github.com/hashicorp/go-plugin v1.8.0 // indirect + github.com/hashicorp/yamux v0.1.2 // indirect + github.com/hasura/go-graphql-client v0.15.1 // indirect + github.com/hdevalence/ed25519consensus v0.2.0 // indirect + github.com/holiman/uint256 v1.3.2 // indirect + github.com/icza/gox v0.2.9 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/invopop/jsonschema v0.13.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/pgx/v5 v5.9.2 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/jinzhu/copier v0.4.0 // indirect + github.com/jmoiron/sqlx v1.4.0 // indirect + github.com/josharian/intern v1.0.0 // indirect + github.com/jpillora/backoff v1.0.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/karalabe/hid v1.0.1-0.20260315100226-f5d04adeffeb // indirect + github.com/klauspost/compress v1.18.5 // indirect + github.com/klauspost/cpuid/v2 v2.3.0 // indirect + github.com/leodido/go-urn v1.4.0 // indirect + github.com/lib/pq v1.12.3 // indirect + github.com/logrusorgru/aurora v2.0.3+incompatible // indirect + github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88 // indirect + github.com/magiconair/properties v1.8.10 // indirect + github.com/mailru/easyjson v0.9.0 // indirect + github.com/mattn/go-colorable v0.1.14 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mitchellh/go-testing-interface v1.14.1 // indirect + github.com/moby/docker-image-spec v1.3.1 // indirect + github.com/moby/go-archive v0.2.0 // indirect + github.com/moby/moby/api v1.54.2 // indirect + github.com/moby/moby/client v0.4.0 // indirect + github.com/moby/patternmatcher v0.6.1 // indirect + github.com/moby/spdystream v0.5.1 // indirect + github.com/moby/sys/sequential v0.6.0 // indirect + github.com/moby/sys/user v0.4.0 // indirect + github.com/moby/sys/userns v0.1.0 // indirect + github.com/moby/term v0.5.2 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/mostynb/zstdpool-freelist v0.0.0-20201229113212-927304c0c3b1 // indirect + github.com/mr-tron/base58 v1.2.0 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect + github.com/oapi-codegen/runtime v1.4.1 // indirect + github.com/oklog/run v1.2.0 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/opencontainers/image-spec v1.1.1 // indirect + github.com/pelletier/go-toml v1.9.5 // indirect + github.com/pelletier/go-toml/v2 v2.3.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v1.20.99 // indirect + github.com/prometheus/procfs v0.16.1 // indirect + github.com/quic-go/qpack v0.6.0 // indirect + github.com/quic-go/quic-go v0.59.1 // indirect + github.com/rs/zerolog v1.35.1 // indirect + github.com/samber/lo v1.53.0 // indirect + github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect + github.com/scylladb/go-reflectx v1.0.1 // indirect + github.com/shirou/gopsutil v3.21.11+incompatible // indirect + github.com/shirou/gopsutil/v4 v4.26.3 // indirect + github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 // indirect + github.com/sirupsen/logrus v1.9.4 // indirect + github.com/smartcontractkit/chain-selectors v1.0.101 // indirect + github.com/smartcontractkit/chainlink-aptos v0.0.0-20260428085939-5c70de12dbfc // indirect + github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260129103204-4c8453dd8139 // indirect + github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260129103204-4c8453dd8139 // indirect + github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260608180601-efa81bfdfda9 // indirect + github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.10 // indirect + github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260505131349-78e491b80735 // indirect + github.com/smartcontractkit/chainlink-protos/job-distributor v0.18.0 // indirect + github.com/smartcontractkit/chainlink-protos/linking-service/go v0.0.0-20251002192024-d2ad9222409b // indirect + github.com/smartcontractkit/chainlink-protos/node-platform v0.0.0-20260211172625-dff40e83b3c9 // indirect + github.com/smartcontractkit/chainlink-sui v0.0.0-20260527160341-aa3adc0abf67 // indirect + github.com/smartcontractkit/chainlink-testing-framework/framework v0.16.5 // indirect + github.com/smartcontractkit/chainlink-ton v1.0.5-0.20260514223130-48bc90aca745 // indirect + github.com/smartcontractkit/chainlink-tron/relayer v0.0.11-0.20251014143056-a0c6328c91e9 // indirect + github.com/smartcontractkit/freeport v0.1.3-0.20250828155247-add56fa28aad // indirect + github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 // indirect + github.com/smartcontractkit/libocr v0.0.0-20260304194147-a03701e2c02e // indirect + github.com/smartcontractkit/mcms v0.45.2-0.20260605010100-d1e8d620ac8a // indirect + github.com/spf13/cast v1.10.0 // indirect + github.com/spf13/pflag v1.0.10 // indirect + github.com/stellar/go-stellar-sdk v0.5.0 // indirect + github.com/stellar/go-xdr v0.0.0-20260312225820-cc2b0611aabf // indirect + github.com/stephenlacy/go-ethereum-hdwallet v0.0.0-20230913225845-a4fa94429863 // indirect + github.com/streamingfast/logging v0.0.0-20230608130331-f22c91403091 // indirect + github.com/stretchr/objx v0.5.3 // indirect + github.com/supranational/blst v0.3.16 // indirect + github.com/testcontainers/testcontainers-go v0.42.0 // indirect + github.com/tidwall/gjson v1.18.0 // indirect + github.com/tidwall/match v1.2.0 // indirect + github.com/tidwall/pretty v1.2.1 // indirect + github.com/tklauser/go-sysconf v0.3.16 // indirect + github.com/tklauser/numcpus v0.11.0 // indirect + github.com/twitchyliquid64/golang-asm v0.15.1 // indirect + github.com/tyler-smith/go-bip39 v1.1.0 // indirect + github.com/ugorji/go/codec v1.3.1 // indirect + github.com/valyala/fastjson v1.6.10 // indirect + github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect + github.com/x448/float16 v0.8.4 // indirect + github.com/xssnick/tonutils-go v1.14.1 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + github.com/zksync-sdk/zksync2-go v1.1.1-0.20250620124214-2c742ee399c6 // indirect + go.mongodb.org/mongo-driver v1.17.2 // indirect + go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect + go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0 // indirect + go.opentelemetry.io/otel v1.44.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.19.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.20.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.19.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.43.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.43.0 // indirect + go.opentelemetry.io/otel/log v0.20.0 // indirect + go.opentelemetry.io/otel/metric v1.44.0 // indirect + go.opentelemetry.io/otel/sdk v1.44.0 // indirect + go.opentelemetry.io/otel/sdk/log v0.20.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect + go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/proto/otlp v1.10.0 // indirect + go.uber.org/goleak v1.3.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/ratelimit v0.3.1 // indirect + go.uber.org/zap v1.28.0 // indirect + golang.org/x/arch v0.22.0 // indirect + golang.org/x/crypto v0.52.0 // indirect + golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa // indirect + golang.org/x/net v0.55.0 // indirect + golang.org/x/oauth2 v0.36.0 // indirect + golang.org/x/sync v0.20.0 // indirect + golang.org/x/sys v0.45.0 // indirect + golang.org/x/term v0.43.0 // indirect + golang.org/x/text v0.37.0 // indirect + golang.org/x/time v0.15.0 // indirect + golang.org/x/tools v0.45.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa // indirect + google.golang.org/grpc v1.81.1 // indirect + google.golang.org/protobuf v1.36.11 // indirect + gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + k8s.io/api v0.32.3 // indirect + k8s.io/apimachinery v0.33.2 // indirect + k8s.io/client-go v0.32.3 // indirect + k8s.io/klog/v2 v2.130.1 // indirect + k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff // indirect + k8s.io/utils v0.0.0-20241210054802-24370beab758 // indirect + sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirect + sigs.k8s.io/randfill v1.0.0 // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirect + sigs.k8s.io/yaml v1.4.0 // indirect +) diff --git a/registry-kit/go.sum b/registry-kit/go.sum new file mode 100644 index 000000000..8176977cf --- /dev/null +++ b/registry-kit/go.sum @@ -0,0 +1,1069 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= +cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= +dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8= +dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +filippo.io/edwards25519 v1.1.1 h1:YpjwWWlNmGIDyXOn8zLzqiD+9TyIlPhGFG96P39uBpw= +filippo.io/edwards25519 v1.1.1/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk= +github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= +github.com/AlekSi/pointer v1.1.0 h1:SSDMPcXD9jSl8FPy9cRzoRaMJtm9g9ggGTxecRUbQoI= +github.com/AlekSi/pointer v1.1.0/go.mod h1:y7BvfRI3wXPWKXEBhU71nbnIEEZX0QTSB2Bj48UJIZE= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= +github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= +github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/DataDog/zstd v1.5.6 h1:LbEglqepa/ipmmQJUDnSsfvA8e8IStVcGaFWDuxvGOY= +github.com/DataDog/zstd v1.5.6/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE= +github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/ProjectZKM/Ziren/crates/go-runtime/zkvm_runtime v0.0.0-20251001021608-1fe7b43fc4d6 h1:1zYrtlhrZ6/b6SAjLSfKzWtdgqK0U+HtH/VcBWh1BaU= +github.com/ProjectZKM/Ziren/crates/go-runtime/zkvm_runtime v0.0.0-20251001021608-1fe7b43fc4d6/go.mod h1:ioLG6R+5bUSO1oeGSDxOV3FADARuMoytZCSX6MEMQkI= +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/VictoriaMetrics/fastcache v1.13.0 h1:AW4mheMR5Vd9FkAPUv+NH6Nhw+fmbTMGMsNAoA/+4G0= +github.com/VictoriaMetrics/fastcache v1.13.0/go.mod h1:hHXhl4DA2fTL2HTZDJFXWgW0LNjo6B+4aj2Wmng3TjU= +github.com/XSAM/otelsql v0.37.0 h1:ya5RNw028JW0eJW8Ma4AmoKxAYsJSGuNVbC7F1J457A= +github.com/XSAM/otelsql v0.37.0/go.mod h1:LHbCu49iU8p255nCn1oi04oX2UjSoRcUMiKEHo2a5qM= +github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= +github.com/apache/arrow-go/v18 v18.3.1 h1:oYZT8FqONiK74JhlH3WKVv+2NKYoyZ7C2ioD4Dj3ixk= +github.com/apache/arrow-go/v18 v18.3.1/go.mod h1:12QBya5JZT6PnBihi5NJTzbACrDGXYkrgjujz3MRQXU= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= +github.com/aptos-labs/aptos-go-sdk v1.13.0 h1:epv7K/tIbAEO2RfogwGacICBig8rrigJj24fDsy6KTg= +github.com/aptos-labs/aptos-go-sdk v1.13.0/go.mod h1:FTgKp0RLfEefllCdkCj0jPU14xWk11yA7SFVfCDLUj8= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/avast/retry-go v3.0.0+incompatible h1:4SOWQ7Qs+oroOTQOYnAHqelpCO0biHSxpiH9JdtuBj0= +github.com/avast/retry-go v3.0.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY= +github.com/avast/retry-go/v4 v4.7.0 h1:yjDs35SlGvKwRNSykujfjdMxMhMQQM0TnIjJaHB+Zio= +github.com/avast/retry-go/v4 v4.7.0/go.mod h1:ZMPDa3sY2bKgpLtap9JRUgk2yTAba7cgiFhqxY2Sg6Q= +github.com/awalterschulze/gographviz v2.0.3+incompatible h1:9sVEXJBJLwGX7EQVhLm2elIKCm7P2YHFC8v6096G09E= +github.com/awalterschulze/gographviz v2.0.3+incompatible/go.mod h1:GEV5wmg4YquNw7v1kkyoX9etIk8yVmXj+AkDHuuETHs= +github.com/aws/aws-sdk-go v1.55.8 h1:JRmEUbU52aJQZ2AjX4q4Wu7t4uZjOu71uyNmaWlUkJQ= +github.com/aws/aws-sdk-go v1.55.8/go.mod h1:ZkViS9AqA6otK+JBBNH2++sx1sgxrPKcSzPPvQkUtXk= +github.com/aws/aws-sdk-go-v2 v1.41.7 h1:DWpAJt66FmnnaRIOT/8ASTucrvuDPZASqhhLey6tLY8= +github.com/aws/aws-sdk-go-v2 v1.41.7/go.mod h1:4LAfZOPHNVNQEckOACQx60Y8pSRjIkNZQz1w92xpMJc= +github.com/aws/aws-sdk-go-v2/config v1.32.12 h1:O3csC7HUGn2895eNrLytOJQdoL2xyJy0iYXhoZ1OmP0= +github.com/aws/aws-sdk-go-v2/config v1.32.12/go.mod h1:96zTvoOFR4FURjI+/5wY1vc1ABceROO4lWgWJuxgy0g= +github.com/aws/aws-sdk-go-v2/credentials v1.19.12 h1:oqtA6v+y5fZg//tcTWahyN9PEn5eDU/Wpvc2+kJ4aY8= +github.com/aws/aws-sdk-go-v2/credentials v1.19.12/go.mod h1:U3R1RtSHx6NB0DvEQFGyf/0sbrpJrluENHdPy1j/3TE= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 h1:zOgq3uezl5nznfoK3ODuqbhVg1JzAGDUhXOsU0IDCAo= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20/go.mod h1:z/MVwUARehy6GAg/yQ1GO2IMl0k++cu1ohP9zo887wE= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20 h1:CNXO7mvgThFGqOFgbNAP2nol2qAWBOGfqR/7tQlvLmc= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20/go.mod h1:oydPDJKcfMhgfcgBUZaG+toBbwy8yPWubJXBVERtI4o= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20 h1:tN6W/hg+pkM+tf9XDkWUbDEjGLb+raoBMFsTodcoYKw= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20/go.mod h1:YJ898MhD067hSHA6xYCx5ts/jEd8BSOLtQDL3iZsvbc= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 h1:qYQ4pzQ2Oz6WpQ8T3HvGHnZydA72MnLuFK9tJwmrbHw= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 h1:5EniKhLZe4xzL7a+fU3C2tfUN4nWIqlLesfrjkuPFTY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20 h1:2HvVAIq+YqgGotK6EkMf+KIEqTISmTYh5zLpYyeTo1Y= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20/go.mod h1:V4X406Y666khGa8ghKmphma/7C0DAtEQYhkq9z4vpbk= +github.com/aws/aws-sdk-go-v2/service/kms v1.50.1 h1:wb/PYYm3wlcqGzw7Ls4GD3X5+seDDoNdVYIB6I/V87E= +github.com/aws/aws-sdk-go-v2/service/kms v1.50.1/go.mod h1:xvHowJ6J9CuaFE04S8fitWQXytf4sHz3DTPGhw9FtmU= +github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 h1:0GFOLzEbOyZABS3PhYfBIx2rNBACYcKty+XGkTgw1ow= +github.com/aws/aws-sdk-go-v2/service/signin v1.0.8/go.mod h1:LXypKvk85AROkKhOG6/YEcHFPoX+prKTowKnVdcaIxE= +github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 h1:kiIDLZ005EcKomYYITtfsjn7dtOwHDOFy7IbPXKek2o= +github.com/aws/aws-sdk-go-v2/service/sso v1.30.13/go.mod h1:2h/xGEowcW/g38g06g3KpRWDlT+OTfxxI0o1KqayAB8= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 h1:jzKAXIlhZhJbnYwHbvUQZEB8KfgAEuG0dc08Bkda7NU= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17/go.mod h1:Al9fFsXjv4KfbzQHGe6V4NZSZQXecFcvaIF4e70FoRA= +github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 h1:Cng+OOwCHmFljXIxpEVXAGMnBia8MSU6Ch5i9PgBkcU= +github.com/aws/aws-sdk-go-v2/service/sts v1.41.9/go.mod h1:LrlIndBDdjA/EeXeyNBle+gyCwTlizzW5ycgWnvIxkk= +github.com/aws/smithy-go v1.27.1 h1:4T340VFndXtADGF52gYa1POyL7s9E4Z1OeZ1hCscIw8= +github.com/aws/smithy-go v1.27.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk= +github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o= +github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.24.0 h1:H4x4TuulnokZKvHLfzVRTHJfFfnHEeSYJizujEZvmAM= +github.com/bits-and-blooms/bitset v1.24.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/blendle/zapdriver v1.3.1 h1:C3dydBOWYRiOk+B8X9IVZ5IOe+7cl+tGOexN4QqHfpE= +github.com/blendle/zapdriver v1.3.1/go.mod h1:mdXfREi6u5MArG4j9fewC+FGnXaBR+T4Ox4J2u4eHCc= +github.com/block-vision/sui-go-sdk v1.2.1 h1:uwvGbzfcrS4SsIaakclYxy0qgEF1XWIUtTYWXB4PoAw= +github.com/block-vision/sui-go-sdk v1.2.1/go.mod h1:t8mWASwfyv+EyqHGO9ZrcDiCJWGOFEXqq50TMJ8GQco= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= +github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= +github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A= +github.com/btcsuite/btcd v0.24.2 h1:aLmxPguqxza+4ag8R1I2nnJjSu2iFn/kqtHTIImswcY= +github.com/btcsuite/btcd v0.24.2/go.mod h1:5C8ChTkl5ejr3WHj8tkQSCmydiMEPB0ZhQhehpq7Dgg= +github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA= +github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= +github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= +github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A= +github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE= +github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00= +github.com/btcsuite/btcd/btcutil v1.1.6 h1:zFL2+c3Lb9gEgqKNzowKUPQNb8jV7v5Oaodi/AYFd6c= +github.com/btcsuite/btcd/btcutil v1.1.6/go.mod h1:9dFymx8HpuLqBnsPELrImQeTQfKBQqzqGbbV3jK55aE= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce h1:YtWJF7RHm2pYCvA5t0RPmAaLUhREsKuKd+SLhxFbFeQ= +github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce/go.mod h1:0DVlHczLPewLcPGEIeUEzfOJhqGPQ0mJJRDBtD307+o= +github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= +github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= +github.com/btcsuite/goleveldb v1.0.0/go.mod h1:QiK9vBlgftBg6rWQIj6wFzbPfRjiykIEhBH4obrXJ/I= +github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= +github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= +github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw= +github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c= +github.com/buger/jsonparser v1.1.2 h1:frqHqw7otoVbk5M8LlE/L7HTnIq2v9RX6EJ48i9AxJk= +github.com/buger/jsonparser v1.1.2/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= +github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M= +github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM= +github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE= +github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k= +github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE= +github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= +github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/cp v1.1.1 h1:nCb6ZLdB7NRaqsm91JtQTAme2SKJzXVsdPIPkyJr1MU= +github.com/cespare/cp v1.1.1/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudevents/sdk-go/binding/format/protobuf/v2 v2.16.2 h1:ydUjnKn4RoCeN8rge3F/deT52w2WJMmIC5mHNUq+Ut8= +github.com/cloudevents/sdk-go/binding/format/protobuf/v2 v2.16.2/go.mod h1:Bny999RuVUtNjzTGa9HCHpXjrLGMipJVq5kqVpudBl0= +github.com/cloudevents/sdk-go/v2 v2.16.2 h1:ZYDFrYke4FD+jM8TZTJJO6JhKHzOQl2oqpFK1D+NnQM= +github.com/cloudevents/sdk-go/v2 v2.16.2/go.mod h1:laOcGImm4nVJEU+PHnUrKL56CKmRL65RlQF0kRmW/kg= +github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= +github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= +github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= +github.com/cockroachdb/fifo v0.0.0-20240816210425-c5d0cb0b6fc0 h1:pU88SPhIFid6/k0egdR5V6eALQYq2qbSmukrkgIh/0A= +github.com/cockroachdb/fifo v0.0.0-20240816210425-c5d0cb0b6fc0/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v1.1.5 h1:5AAWCBWbat0uE0blr8qzufZP5tBjkRyy/jWe1QWLnvw= +github.com/cockroachdb/pebble v1.1.5/go.mod h1:17wO9el1YEigxkP/YtV8NtCivQDgoCyBg5c4VR/eOWo= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g= +github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg= +github.com/consensys/gnark-crypto v0.19.2 h1:qrEAIXq3T4egxqiliFFoNrepkIWVEeIYwt3UL0fvS80= +github.com/consensys/gnark-crypto v0.19.2/go.mod h1:rT23F0XSZqE0mUA0+pRtnL56IbPxs6gp4CeRsBk4XS0= +github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI= +github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= +github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE= +github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containerd/platforms v1.0.0-rc.2 h1:0SPgaNZPVWGEi4grZdV8VRYQn78y+nm6acgLGv/QzE4= +github.com/containerd/platforms v1.0.0-rc.2/go.mod h1:J71L7B+aiM5SdIEqmd9wp6THLVRzJGXfNuWCZCllLA4= +github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= +github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= +github.com/cpuguy83/dockercfg v0.3.2 h1:DlJTyZGBDlXqUZ2Dk2Q3xHs/FtnooJJVaad2S9GKorA= +github.com/cpuguy83/dockercfg v0.3.2/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo= +github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/crate-crypto/go-eth-kzg v1.5.0 h1:FYRiJMJG2iv+2Dy3fi14SVGjcPteZ5HAAUe4YWlJygc= +github.com/crate-crypto/go-eth-kzg v1.5.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= +github.com/creachadair/jrpc2 v1.2.0 h1:SXr0OgnwM0X18P+HccJP0uT3KGSDk/BCSRlJBvE2bMY= +github.com/creachadair/jrpc2 v1.2.0/go.mod h1:66uKSdr6tR5ZeNvkIjDSbbVUtOv0UhjS/vcd8ECP7Iw= +github.com/creachadair/mds v0.13.4 h1:RgU0MhiVqkzp6/xtNWhK6Pw7tDeaVuGFtA0UA2RBYvY= +github.com/creachadair/mds v0.13.4/go.mod h1:4vrFYUzTXMJpMBU+OA292I6IUxKWCCfZkgXg+/kBZMo= +github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s= +github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= +github.com/cucumber/gherkin/go/v26 v26.2.0 h1:EgIjePLWiPeslwIWmNQ3XHcypPsWAHoMCz/YEBKP4GI= +github.com/cucumber/gherkin/go/v26 v26.2.0/go.mod h1:t2GAPnB8maCT4lkHL99BDCVNzCh1d7dBhCLt150Nr/0= +github.com/cucumber/godog v0.15.1 h1:rb/6oHDdvVZKS66hrhpjFQFHjthFSrQBCOI1LwshNTI= +github.com/cucumber/godog v0.15.1/go.mod h1:qju+SQDewOljHuq9NSM66s0xEhogx0q30flfxL4WUk8= +github.com/cucumber/messages/go/v21 v21.0.1 h1:wzA0LxwjlWQYZd32VTlAVDTkW6inOFmSM+RuOwHZiMI= +github.com/cucumber/messages/go/v21 v21.0.1/go.mod h1:zheH/2HS9JLVFukdrsPWoPdmUtmYQAQPLk7w5vWsk5s= +github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA= +github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc= +github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+ZlfuyaAdFlQ= +github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U0x++OzVrdms8= +github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= +github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= +github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU= +github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw= +github.com/digital-asset/dazl-client/v8 v8.9.0 h1:F2qTUWtHAjhGyRGV+xTim+VAFwM99FpcOx4+wowvPnY= +github.com/digital-asset/dazl-client/v8 v8.9.0/go.mod h1:q1KevCJ8FpH8je2MnnjN8/QUfhstB4fKpyKyqDtqFh0= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/go-connections v0.7.0 h1:6SsRfJddP22WMrCkj19x9WKjEDTB+ahsdiGYf0mN39c= +github.com/docker/go-connections v0.7.0/go.mod h1:no1qkHdjq7kLMGUXYAduOhYPSJxxvgWBh7ogVvptn3Q= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU= +github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= +github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= +github.com/emicklei/go-restful/v3 v3.12.1 h1:PJMDIM/ak7btuL8Ex0iYET9hxM3CI2sjZtzpL63nKAU= +github.com/emicklei/go-restful/v3 v3.12.1/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/ethereum/c-kzg-4844/v2 v2.1.6 h1:xQymkKCT5E2Jiaoqf3v4wsNgjZLY0lRSkZn27fRjSls= +github.com/ethereum/c-kzg-4844/v2 v2.1.6/go.mod h1:8HMkUZ5JRv4hpw/XUrYWSQNAUzhHMg2UDb/U+5m+XNw= +github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab h1:rvv6MJhy07IMfEKuARQ9TKojGqLVNxQajaXEp/BoqSk= +github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab/go.mod h1:IuLm4IsPipXKF7CW5Lzf68PIbZ5yl7FFd74l/E0o9A8= +github.com/ethereum/go-ethereum v1.17.3 h1:Ev/sQHH+UdKZHWjuVzhu2pxhi/sXaPZl23Q+Q5LDd4Q= +github.com/ethereum/go-ethereum v1.17.3/go.mod h1:f2EhRwqewIZkGoQekywI2Y2RZAMTSavLNkD9qItFy1A= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w= +github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ferranbt/fastssz v0.1.4 h1:OCDB+dYDEQDvAgtAGnTSidK1Pe2tW3nFV40XyMkTeDY= +github.com/ferranbt/fastssz v0.1.4/go.mod h1:Ea3+oeoRGGLGm5shYAeDgu6PGUlcvQhE2fILyD9+tGg= +github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= +github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM= +github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= +github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM= +github.com/gabriel-vasile/mimetype v1.4.13/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= +github.com/gagliardetto/binary v0.8.0 h1:U9ahc45v9HW0d15LoN++vIXSJyqR/pWw8DDlhd7zvxg= +github.com/gagliardetto/binary v0.8.0/go.mod h1:2tfj51g5o9dnvsc+fL3Jxr22MuWzYXwx9wEoN0XQ7/c= +github.com/gagliardetto/gofuzz v1.2.2 h1:XL/8qDMzcgvR4+CyRQW9UGdwPRPMHVJfqQ/uMvSUuQw= +github.com/gagliardetto/gofuzz v1.2.2/go.mod h1:bkH/3hYLZrMLbfYWA0pWzXmi5TTRZnu4pMGZBkqMKvY= +github.com/gagliardetto/solana-go v1.13.0 h1:uNzhjwdAdbq9xMaX2DF0MwXNMw6f8zdZ7JPBtkJG7Ig= +github.com/gagliardetto/solana-go v1.13.0/go.mod h1:l/qqqIN6qJJPtxW/G1PF4JtcE3Zg2vD2EliZrr9Gn5k= +github.com/gagliardetto/treeout v0.1.4 h1:ozeYerrLCmCubo1TcIjFiOWTTGteOOHND1twdFpgwaw= +github.com/gagliardetto/treeout v0.1.4/go.mod h1:loUefvXTrlRG5rYmJmExNryyBRh8f89VZhmMOyCyqok= +github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 h1:f6D9Hr8xV8uYKlyuj8XIruxlh9WjVjdh1gIicAS7ays= +github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w= +github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM= +github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8= +github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc= +github.com/gkampitakis/ciinfo v0.3.2 h1:JcuOPk8ZU7nZQjdUhctuhQofk7BGHuIy0c9Ez8BNhXs= +github.com/gkampitakis/ciinfo v0.3.2/go.mod h1:1NIwaOcFChN4fa/B0hEBdAb6npDlFL8Bwx4dfRLRqAo= +github.com/gkampitakis/go-snaps v0.5.19 h1:hUJlCQOpTt1M+kSisMwioDWZDWpDtdAvUhvWCx1YGW0= +github.com/gkampitakis/go-snaps v0.5.19/go.mod h1:gC3YqxQTPyIXvQrw/Vpt3a8VqR1MO8sVpZFWN4DGwNs= +github.com/go-chi/chi v4.1.2+incompatible h1:fGFk2Gmi/YKXk0OmGfBh0WgmN3XB8lVnEyNz34tQRec= +github.com/go-chi/chi v4.1.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ= +github.com/go-errors/errors v1.5.1 h1:ZwEMSLRCapFLflTpT7NKaAc7ukJ8ZPEjzlxt8rPN8bk= +github.com/go-errors/errors v1.5.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874 h1:F8d1AJ6M9UQCavhwmO6ZsrYLfG8zVFWfEfMS2MXPkSY= +github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= +github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= +github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ= +github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4= +github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= +github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= +github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= +github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= +github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= +github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= +github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= +github.com/go-playground/validator/v10 v10.30.3 h1:4MU6YkEwx7GbcPJOZxrtbu+QfF3pJLJuaYTeAH0DYy8= +github.com/go-playground/validator/v10 v10.30.3/go.mod h1:4Axh7oCNGcoGkqLoE4YWt6n20mcEIsPRlB7vPk3lpyc= +github.com/go-resty/resty/v2 v2.17.2 h1:FQW5oHYcIlkCNrMD2lloGScxcHJ0gkjshV3qcQAyHQk= +github.com/go-resty/resty/v2 v2.17.2/go.mod h1:kCKZ3wWmwJaNc7S29BRtUhJwy7iqmn+2mLtQrOyQlVA= +github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= +github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= +github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= +github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro= +github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM= +github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= +github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E= +github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0= +github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= +github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= +github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= +github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs= +github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q= +github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw= +github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/schema v1.4.1 h1:jUg5hUjCSDZpNGLuXQOgIWGdlgrIdYvgQ0wZtdK1M3E= +github.com/gorilla/schema v1.4.1/go.mod h1:Dg5SSm5PV60mhF2NFaTV1xuYYj8tV8NOPRo4FggUMnM= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/grafana/otel-profiling-go v0.5.1 h1:stVPKAFZSa7eGiqbYuG25VcqYksR6iWvF3YH66t4qL8= +github.com/grafana/otel-profiling-go v0.5.1/go.mod h1:ftN/t5A/4gQI19/8MoWurBEtC6gFw8Dns1sJZ9W4Tls= +github.com/grafana/pyroscope-go v1.2.8 h1:UvCwIhlx9DeV7F6TW/z8q1Mi4PIm3vuUJ2ZlCEvmA4M= +github.com/grafana/pyroscope-go v1.2.8/go.mod h1:SSi59eQ1/zmKoY/BKwa5rSFsJaq+242Bcrr4wPix1g8= +github.com/grafana/pyroscope-go/godeltaprof v0.1.9 h1:c1Us8i6eSmkW+Ez05d3co8kasnuOY813tbMN8i/a3Og= +github.com/grafana/pyroscope-go/godeltaprof v0.1.9/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= +github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc h1:GN2Lv3MGO7AS6PrRoT6yV5+wkrOpcszoIsO4+4ds248= +github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc/go.mod h1:+JKpmjMGhpgPL+rXZ5nsZieVzvarn86asRlBg4uNGnk= +github.com/graph-gophers/graphql-go v1.5.0 h1:fDqblo50TEpD0LY7RXk/LFVYEVqo3+tXMNMPSVXA1yc= +github.com/graph-gophers/graphql-go v1.5.0/go.mod h1:YtmJZDLbF1YYNrlNAuiO5zAStUWc3XZT07iGsVqe1Os= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1 h1:qnpSQwGEnkcRpTqNOIR6bJbR0gAorgP9CSALpRcKoAA= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1/go.mod h1:lXGCsh6c22WGtjr+qGHj1otzZpV/1kwTMAqkwZsnWRU= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.2 h1:sGm2vDRFUrQJO/Veii4h4zG2vvqG6uWNkBHSTqXOZk0= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.2/go.mod h1:wd1YpapPLivG6nQgbf7ZkG1hhSOXDhhn4MLTknx2aAc= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 h1:5VipnvEpbqr2gA2VbM+nYVbkIF28c5ZQfqCBQ5g2xfk= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0/go.mod h1:Hyl3n6Twe1hvtd9XUXDec4pTvgMSEixRuQKPTMH2bNs= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= +github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= +github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc= +github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-memdb v1.3.5 h1:b3taDMxCBCBVgyRrS1AZVHO14ubMYZB++QpNhBg+Nyo= +github.com/hashicorp/go-memdb v1.3.5/go.mod h1:8IVKKBkVe+fxFgdFOYxzQQNjz+sWCyHCdIC/+5+Vy1Y= +github.com/hashicorp/go-plugin v1.8.0 h1:ie8S6RRY8RvB2usYZv+AAZ/wBvx2AU5p5QeP5j/FORs= +github.com/hashicorp/go-plugin v1.8.0/go.mod h1:BExt6KEaIYx804z8k4gRzRLEvxKVb+kn0NMcihqOqb8= +github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= +github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/yamux v0.1.2 h1:XtB8kyFOyHXYVFnwT5C3+Bdo8gArse7j2AQ0DA0Uey8= +github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns= +github.com/hasura/go-graphql-client v0.15.1 h1:mCb5I+8Bk3FU3GKWvf/zDXkTh7FbGlqJmP3oisBdnN8= +github.com/hasura/go-graphql-client v0.15.1/go.mod h1:jfSZtBER3or+88Q9vFhWHiFMPppfYILRyl+0zsgPIIw= +github.com/hdevalence/ed25519consensus v0.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU= +github.com/hdevalence/ed25519consensus v0.2.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo= +github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db h1:IZUYC/xb3giYwBLMnr8d0TGTzPKFGNTCGgGLoyeX330= +github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db/go.mod h1:xTEYN9KCHxuYHs+NmrmzFcnvHMzLLNiGFafCb1n3Mfg= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= +github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/icza/gox v0.2.9 h1:SAeM3n6l9qR1IOa3V16Q+FomKDSbX1RwqH4pEwNtLDs= +github.com/icza/gox v0.2.9/go.mod h1:d62IGCt4ajK4/U7k/ldEF1Fi5jtP8C4hoGZiHQYfAi0= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k= +github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM= +github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= +github.com/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E= +github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw= +github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jhump/protoreflect v1.17.0 h1:qOEr613fac2lOuTgWN4tPAtLL7fUSbuJL5X5XumQh94= +github.com/jhump/protoreflect v1.17.0/go.mod h1:h9+vUUL38jiBzck8ck+6G/aeMX8Z4QUY/NiJPwPNi+8= +github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8= +github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o= +github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA= +github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= +github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= +github.com/karalabe/hid v1.0.1-0.20260315100226-f5d04adeffeb h1:Ag83At00qa4FLkcdMgrwHVSakqky/eZczOlxd4q336E= +github.com/karalabe/hid v1.0.1-0.20260315100226-f5d04adeffeb/go.mod h1:qk1sX/IBgppQNcGCRoj90u6EGC056EBoIc1oEjCWla8= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= +github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= +github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE= +github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= +github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4= +github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c= +github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= +github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= +github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= +github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8= +github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= +github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88 h1:PTw+yKnXcOFCR6+8hHTyWBeQ/P4Nb7dd4/0ohEcWQuM= +github.com/lufia/plan9stats v0.0.0-20260216142805-b3301c5f2a88/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg= +github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE= +github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4= +github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU= +github.com/manucorporat/sse v0.0.0-20160126180136-ee05b128a739 h1:ykXz+pRRTibcSjG1yRhpdSHInF8yZY/mfn+Rz2Nd1rE= +github.com/manucorporat/sse v0.0.0-20160126180136-ee05b128a739/go.mod h1:zUx1mhth20V3VKgL5jbd1BSQcW4Fy6Qs4PZvQwRFwzM= +github.com/marcboeker/go-duckdb v1.8.5 h1:tkYp+TANippy0DaIOP5OEfBEwbUINqiFqgwMQ44jME0= +github.com/marcboeker/go-duckdb v1.8.5/go.mod h1:6mK7+WQE4P4u5AFLvVBmhFxY5fvhymFptghgJX6B+/8= +github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo= +github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= +github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= +github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= +github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= +github.com/mitchellh/go-testing-interface v1.14.1 h1:jrgshOhYAUVNMAJiKbEu7EqAwgJJ2JqpQmpLJOu07cU= +github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8= +github.com/mitchellh/mapstructure v1.5.1-0.20220423185008-bf980b35cac4 h1:BpfhmLKZf+SjVanKKhCgf3bg+511DmU9eDQTen7LLbY= +github.com/mitchellh/mapstructure v1.5.1-0.20220423185008-bf980b35cac4/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/go-archive v0.2.0 h1:zg5QDUM2mi0JIM9fdQZWC7U8+2ZfixfTYoHL7rWUcP8= +github.com/moby/go-archive v0.2.0/go.mod h1:mNeivT14o8xU+5q1YnNrkQVpK+dnNe/K6fHqnTg4qPU= +github.com/moby/moby/api v1.54.2 h1:wiat9QAhnDQjA7wk1kh/TqHz2I1uUA7M7t9SAl/JNXg= +github.com/moby/moby/api v1.54.2/go.mod h1:+RQ6wluLwtYaTd1WnPLykIDPekkuyD/ROWQClE83pzs= +github.com/moby/moby/client v0.4.0 h1:S+2XegzHQrrvTCvF6s5HFzcrywWQmuVnhOXe2kiWjIw= +github.com/moby/moby/client v0.4.0/go.mod h1:QWPbvWchQbxBNdaLSpoKpCdf5E+WxFAgNHogCWDoa7g= +github.com/moby/patternmatcher v0.6.1 h1:qlhtafmr6kgMIJjKJMDmMWq7WLkKIo23hsrpR3x084U= +github.com/moby/patternmatcher v0.6.1/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= +github.com/moby/spdystream v0.5.1 h1:9sNYeYZUcci9R6/w7KDaFWEWeV4LStVG78Mpyq/Zm/Y= +github.com/moby/spdystream v0.5.1/go.mod h1:xBAYlnt/ay+11ShkdFKNAG7LsyK/tmNBVvVOwrfMgdI= +github.com/moby/sys/sequential v0.6.0 h1:qrx7XFUd/5DxtqcoH1h438hF5TmOvzC/lspjy7zgvCU= +github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko= +github.com/moby/sys/user v0.4.0 h1:jhcMKit7SA80hivmFJcbB1vqmw//wU61Zdui2eQXuMs= +github.com/moby/sys/user v0.4.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85uoHjs= +github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g= +github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28= +github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ= +github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE= +github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= +github.com/mostynb/zstdpool-freelist v0.0.0-20201229113212-927304c0c3b1 h1:mPMvm6X6tf4w8y7j9YIt6V9jfWhL6QlbEc7CCmeQlWk= +github.com/mostynb/zstdpool-freelist v0.0.0-20201229113212-927304c0c3b1/go.mod h1:ye2e/VUEtE2BHE+G/QcKkcLQVAEJoYRFj5VUOQatCRE= +github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= +github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= +github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/oapi-codegen/nullable v1.1.0 h1:eAh8JVc5430VtYVnq00Hrbpag9PFRGWLjxR1/3KntMs= +github.com/oapi-codegen/nullable v1.1.0/go.mod h1:KUZ3vUzkmEKY90ksAmit2+5juDIhIZhfDl+0PwOQlFY= +github.com/oapi-codegen/runtime v1.4.1 h1:9nwLoI+KrWxzbBcp0jO/R8uXqbik/HUyCvPeU68Y/qo= +github.com/oapi-codegen/runtime v1.4.1/go.mod h1:GwV7hC2hviaMzj+ITfHVRESK5J2W/GefVwIND/bMGvU= +github.com/oklog/run v1.2.0 h1:O8x3yXwah4A73hJdlrwo/2X6J62gE5qTMusH0dvz60E= +github.com/oklog/run v1.2.0/go.mod h1:mgDbKRSwPhJfesJ4PntqFUbKQRZ50NgmZTSPlFA0YFk= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/ginkgo/v2 v2.22.1 h1:QW7tbJAUDyVDVOM5dFa7qaybo+CRfR7bemlQUN6Z8aM= +github.com/onsi/ginkgo/v2 v2.22.1/go.mod h1:S6aTpoRsSq2cZOd+pssHAlKW/Q/jZt6cPrPlnj4a1xM= +github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/onsi/gomega v1.36.2 h1:koNYke6TVk6ZmnyHrCXba/T/MoLBXFjeC1PtvYgw0A8= +github.com/onsi/gomega v1.36.2/go.mod h1:DdwyADRjrc825LhMEkD76cHR5+pUnjhUN8GlHlRPHzY= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= +github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M= +github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= +github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.3.0 h1:k59bC/lIZREW0/iVaQR8nDHxVq8OVlIzYCOJf421CaM= +github.com/pelletier/go-toml/v2 v2.3.0/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM= +github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= +github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU= +github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pion/dtls/v2 v2.2.12 h1:KP7H5/c1EiVAAKUmXyCzPiQe5+bCJrpOeKg/L05dunk= +github.com/pion/dtls/v2 v2.2.12/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE= +github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= +github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= +github.com/pion/stun/v2 v2.0.0 h1:A5+wXKLAypxQri59+tmQKVs7+l6mMM+3d+eER9ifRU0= +github.com/pion/stun/v2 v2.0.0/go.mod h1:22qRSh08fSEttYUmJZGlriq9+03jtVmXNODgLccj8GQ= +github.com/pion/transport/v2 v2.2.10 h1:ucLBLE8nuxiHfvkFKnkDQRYWYfp8ejf4YBOPfaQpw6Q= +github.com/pion/transport/v2 v2.2.10/go.mod h1:sq1kSLWs+cHW9E+2fJP95QudkzbK7wscs8yYgQToO5E= +github.com/pion/transport/v3 v3.0.1 h1:gDTlPJwROfSfz6QfSi0ZmeCSkFcnWWiiR9ES0ouANiM= +github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v1.20.99 h1:vZEybF3CT0t6L0UjsOtHRML7vuIglHocmvJMMH/se4M= +github.com/prometheus/common v1.20.99/go.mod h1:VX44Tebe4qpuTK+MQWg25h4fJGKBqzObSdxuB7y8K/Y= +github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= +github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= +github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= +github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= +github.com/quic-go/quic-go v0.59.1 h1:0Gmua0HW1Tv7ANR7hUYwRyD0MG5OJfgvYSZasGZzBic= +github.com/quic-go/quic-go v0.59.1/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= +github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= +github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI= +github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw= +github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/samber/lo v1.53.0 h1:t975lj2py4kJPQ6haz1QMgtId2gtmfktACxIXArw3HM= +github.com/samber/lo v1.53.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4= +github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY= +github.com/scylladb/go-reflectx v1.0.1 h1:b917wZM7189pZdlND9PbIJ6NQxfDPfBvUaQ7cjj1iZQ= +github.com/scylladb/go-reflectx v1.0.1/go.mod h1:rWnOfDIRWBGN0miMLIcoPt/Dhi2doCMZqwMCJ3KupFc= +github.com/segmentio/go-loggly v0.5.1-0.20171222203950-eb91657e62b2 h1:S4OC0+OBKz6mJnzuHioeEat74PuQ4Sgvbf8eus695sc= +github.com/segmentio/go-loggly v0.5.1-0.20171222203950-eb91657e62b2/go.mod h1:8zLRYR5npGjaOXgPSKat5+oOh+UHd8OdbS18iqX9F6Y= +github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw= +github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= +github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shirou/gopsutil/v4 v4.26.3 h1:2ESdQt90yU3oXF/CdOlRCJxrP+Am1aBYubTMTfxJ1qc= +github.com/shirou/gopsutil/v4 v4.26.3/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ= +github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 h1:aQKxg3+2p+IFXXg97McgDGT5zcMrQoi0EICZs8Pgchs= +github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA= +github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w= +github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g= +github.com/smartcontractkit/ccip-owner-contracts v0.1.0 h1:GiBDtlx7539o7AKlDV+9LsA7vTMPv+0n7ClhSFnZFAk= +github.com/smartcontractkit/ccip-owner-contracts v0.1.0/go.mod h1:NnT6w4Kj42OFFXhSx99LvJZWPpMjmo4+CpDEWfw61xY= +github.com/smartcontractkit/chain-selectors v1.0.101 h1:TF4ma9h3QeyIZ8XoEmgI5lrUvZfzHAz8tfR0pV0+GCA= +github.com/smartcontractkit/chain-selectors v1.0.101/go.mod h1:qy7whtgG5g+7z0jt0nRyii9bLND9m15NZTzuQPkMZ5w= +github.com/smartcontractkit/chainlink-aptos v0.0.0-20260428085939-5c70de12dbfc h1:Um9FBcf0JNSFuGbxgccDG1vM3cNrMGy0SdJ7r6VbX0o= +github.com/smartcontractkit/chainlink-aptos v0.0.0-20260428085939-5c70de12dbfc/go.mod h1:zfE2R7887kiwXkGTHKPe5NBgwhFwIC3pnA2uAxrbvig= +github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260129103204-4c8453dd8139 h1:jkChf04hhdiMBApbb+lLDxHMY62Md6UeM7v++GSw3K8= +github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20260129103204-4c8453dd8139/go.mod h1:wuhagkM/lU0GbV2YcrROOH0GlsfXJYwm6qmpa4CK70w= +github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260129103204-4c8453dd8139 h1:tw3K4UkH5XfW5SoyYkvAlbzrccoGSLdz/XkxD6nyGC8= +github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings v0.0.0-20260129103204-4c8453dd8139/go.mod h1:1WcontO9PeuKdUf5HXfs3nuICtzUvFNnyCmrHkTCF9Y= +github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260608180601-efa81bfdfda9 h1:MH8jQt6Dpt8LoBwrEkDvT/aIrkbZ/7HGcHVzsa5ufho= +github.com/smartcontractkit/chainlink-ccip/deployment v0.0.0-20260608180601-efa81bfdfda9/go.mod h1:xDXlDsou69NYOolOAj+KITRn9luER6Bg52NXelrLl+A= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260506120607-7f10be016c89 h1:5z3LQ27MJmhiaeqp9S2TzbF5Wm4GGvUKAYOtE9AauR8= +github.com/smartcontractkit/chainlink-common v0.11.2-0.20260506120607-7f10be016c89/go.mod h1:G2AII0QmWzXx8Ag9IKnGN3h/gwwNnhHUOCviJievdvo= +github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.10 h1:FJAFgXS9oqASnkS03RE1HQwYQQxrO4l46O5JSzxqLgg= +github.com/smartcontractkit/chainlink-common/pkg/chipingress v0.0.10/go.mod h1:oiDa54M0FwxevWwyAX773lwdWvFYYlYHHQV1LQ5HpWY= +github.com/smartcontractkit/chainlink-deployments-framework v0.109.0 h1:sURmdL2OnO55SETWIFzIEqQH7RCiHJyW7on8HvfnLY8= +github.com/smartcontractkit/chainlink-deployments-framework v0.109.0/go.mod h1:ubpvoLoRdru8IQHw3TFr7KthbjYpAwmiRmvvNCf2daA= +github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260505131349-78e491b80735 h1:5bxDnwI0wuPoC0H5H3H2n9CnQPb5iakR6UmAY4j8KUg= +github.com/smartcontractkit/chainlink-protos/cre/go v0.0.0-20260505131349-78e491b80735/go.mod h1:Jqt53s27Tr0jDl8mdBXg1xhu6F8Fci8JOuq43tgHOM8= +github.com/smartcontractkit/chainlink-protos/job-distributor v0.18.0 h1:q+VDPcxWrj5k9QizSYfUOSMnDH3Sd5HvbPguZOgfXTY= +github.com/smartcontractkit/chainlink-protos/job-distributor v0.18.0/go.mod h1:/dVVLXrsp+V0AbcYGJo3XMzKg3CkELsweA/TTopCsKE= +github.com/smartcontractkit/chainlink-protos/linking-service/go v0.0.0-20251002192024-d2ad9222409b h1:QuI6SmQFK/zyUlVWEf0GMkiUYBPY4lssn26nKSd/bOM= +github.com/smartcontractkit/chainlink-protos/linking-service/go v0.0.0-20251002192024-d2ad9222409b/go.mod h1:qSTSwX3cBP3FKQwQacdjArqv0g6QnukjV4XuzO6UyoY= +github.com/smartcontractkit/chainlink-protos/node-platform v0.0.0-20260211172625-dff40e83b3c9 h1:hhevsu8k7tlDRrYZmgAh7V4avGQDMvus1bwIlial3Ps= +github.com/smartcontractkit/chainlink-protos/node-platform v0.0.0-20260211172625-dff40e83b3c9/go.mod h1:dkR2uYg9XYJuT1JASkPzWE51jjFkVb86P7a/yXe5/GM= +github.com/smartcontractkit/chainlink-protos/op-catalog v0.1.0 h1:hGEJFD2X3oNIPXQbtIPxCJyg5CcKglRCYBmESS+gmeQ= +github.com/smartcontractkit/chainlink-protos/op-catalog v0.1.0/go.mod h1:PjZD54vr6rIKEKQj6HNA4hllvYI/QpT+Zefj3tqkFAs= +github.com/smartcontractkit/chainlink-sui v0.0.0-20260527160341-aa3adc0abf67 h1:NNvPOgvf5vbOYVLxLST+5E88iPOAnpmzZGPihEx8DFc= +github.com/smartcontractkit/chainlink-sui v0.0.0-20260527160341-aa3adc0abf67/go.mod h1:k1HSbHyPaQWPOj6lXDIAe04EuwbC5ge1nK+cpG2E8hE= +github.com/smartcontractkit/chainlink-testing-framework/framework v0.16.5 h1:EiQx0LCPzxlfO9piSPeMCVSZAnp/BxAsPIGh/jBal18= +github.com/smartcontractkit/chainlink-testing-framework/framework v0.16.5/go.mod h1:nyOjn4ADJGqRMe3+4ZXSV+J/7nWb1H2Vx8Qk57eLRYA= +github.com/smartcontractkit/chainlink-testing-framework/seth v1.51.5 h1:RwZXxdIAOyjp6cwc9Quxgr38k8r7ACz+Lxh9o/A6oH0= +github.com/smartcontractkit/chainlink-testing-framework/seth v1.51.5/go.mod h1:kHYJnZUqiPF7/xN5273prV+srrLJkS77GbBXHLKQpx0= +github.com/smartcontractkit/chainlink-ton v1.0.5-0.20260514223130-48bc90aca745 h1:eieKLvYuzwBPh/FdbUS1gnIanI86zgWby1L10o90g4o= +github.com/smartcontractkit/chainlink-ton v1.0.5-0.20260514223130-48bc90aca745/go.mod h1:8vXLeG//BxDF86GWRytzGIy6jc70htD1r/KtPfjrsK0= +github.com/smartcontractkit/chainlink-tron/relayer v0.0.11-0.20251014143056-a0c6328c91e9 h1:7Ut0g+Pdm+gcu2J/Xv8OpQOVf7uLGErMX8yhC4b4tIA= +github.com/smartcontractkit/chainlink-tron/relayer v0.0.11-0.20251014143056-a0c6328c91e9/go.mod h1:h9hMs6K4hT1+mjYnJD3/SW1o7yC/sKjNi0Qh8hLfiCE= +github.com/smartcontractkit/chainlink-tron/relayer/gotron-sdk v0.0.5-0.20251014124537-af6b1684fe15 h1:idp/RjsFznR48JWGfZICsrpcl9JTrnMzoUNVz8MhQMI= +github.com/smartcontractkit/chainlink-tron/relayer/gotron-sdk v0.0.5-0.20251014124537-af6b1684fe15/go.mod h1:ea1LESxlSSOgc2zZBqf1RTkXTMthHaspdqUHd7W4lF0= +github.com/smartcontractkit/freeport v0.1.3-0.20250828155247-add56fa28aad h1:lgHxTHuzJIF3Vj6LSMOnjhqKgRqYW+0MV2SExtCYL1Q= +github.com/smartcontractkit/freeport v0.1.3-0.20250828155247-add56fa28aad/go.mod h1:T4zH9R8R8lVWKfU7tUvYz2o2jMv1OpGCdpY2j2QZXzU= +github.com/smartcontractkit/go-daml v0.0.0-20260610225315-f38fea9a45b0 h1:7BFrFhmw4R8vPBQRvQ8eQ87Zs9M5Ij+6WBHMFb8Obmo= +github.com/smartcontractkit/go-daml v0.0.0-20260610225315-f38fea9a45b0/go.mod h1:SqWfl3Bp9NleC9jhzFUaOGzOZeKfldpY4QOW6A6NSNM= +github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 h1:12ijqMM9tvYVEm+nR826WsrNi6zCKpwBhuApq127wHs= +github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7/go.mod h1:FX7/bVdoep147QQhsOPkYsPEXhGZjeYx6lBSaSXtZOA= +github.com/smartcontractkit/libocr v0.0.0-20260304194147-a03701e2c02e h1:poXTj5cFVM6XfC4HICIDYkDVc/A6OYB0eeID0wU2JQE= +github.com/smartcontractkit/libocr v0.0.0-20260304194147-a03701e2c02e/go.mod h1:PLdNK6GlqfxIWXzziPkU7dCAVlVFeYkyyW7AQY0R+4Q= +github.com/smartcontractkit/mcms v0.45.2-0.20260605010100-d1e8d620ac8a h1:GUiQxhDmIh4cErgent6S6I12atTdSvpjv8uyjc6BjWc= +github.com/smartcontractkit/mcms v0.45.2-0.20260605010100-d1e8d620ac8a/go.mod h1:PBWZPScZKC87jDMxcd5WvKDdlvTgA7k8qHkCeNkGBN8= +github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= +github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo= +github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU= +github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4= +github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= +github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= +github.com/stellar/go-stellar-sdk v0.5.0 h1:xpOO+ZTyvGz54wTm7pwl2Gf1e6lZl0ExrJ/tKb+Roj4= +github.com/stellar/go-stellar-sdk v0.5.0/go.mod h1:tLKAQPxa2I5UvGMabBbUXcY3fmgYnfDudrMeK7CDX4w= +github.com/stellar/go-xdr v0.0.0-20260312225820-cc2b0611aabf h1:GY1RVbX3Hg7poPXEf6yojjP0hyypvgUgZmCqQU9D0xg= +github.com/stellar/go-xdr v0.0.0-20260312225820-cc2b0611aabf/go.mod h1:If+U9Z1W5xU97VrOgJandQT+2dN7/iOpkCrxBJEyF80= +github.com/stephenlacy/go-ethereum-hdwallet v0.0.0-20230913225845-a4fa94429863 h1:ba4VRWSkRzgdP5hB5OxexIzBXZbSwgcw8bEu06ivGQI= +github.com/stephenlacy/go-ethereum-hdwallet v0.0.0-20230913225845-a4fa94429863/go.mod h1:oPTjPNrRucLv9mU27iNPj6n0CWWcNFhoXFOLVGJwHCA= +github.com/streamingfast/logging v0.0.0-20230608130331-f22c91403091 h1:RN5mrigyirb8anBEtdjtHFIufXdacyTi6i4KBfeNXeo= +github.com/streamingfast/logging v0.0.0-20230608130331-f22c91403091/go.mod h1:VlduQ80JcGJSargkRU4Sg9Xo63wZD/l8A5NC/Uo1/uU= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/supranational/blst v0.3.16 h1:bTDadT+3fK497EvLdWRQEjiGnUtzJ7jjIUMF0jqwYhE= +github.com/supranational/blst v0.3.16/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs= +github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= +github.com/test-go/testify v1.1.4 h1:Tf9lntrKUMHiXQ07qBScBTSA0dhYQlu83hswqelv1iE= +github.com/test-go/testify v1.1.4/go.mod h1:rH7cfJo/47vWGdi4GPj16x3/t1xGOj2YxzmNQzk2ghU= +github.com/testcontainers/testcontainers-go v0.42.0 h1:He3IhTzTZOygSXLJPMX7n44XtK+qhjat1nI9cneBbUY= +github.com/testcontainers/testcontainers-go v0.42.0/go.mod h1:vZjdY1YmUA1qEForxOIOazfsrdyORJAbhi0bp8plN30= +github.com/testcontainers/testcontainers-go/modules/postgres v0.41.0 h1:AOtFXssrDlLm84A2sTTR/AhvJiYbrIuCO59d+Ro9Tb0= +github.com/testcontainers/testcontainers-go/modules/postgres v0.41.0/go.mod h1:k2a09UKhgSp6vNpliIY0QSgm4Hi7GXVTzWvWgUemu/8= +github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY= +github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/match v1.2.0 h1:0pt8FlkOwjN2fPt4bIl4BoNxb98gGHN2ObFEDkrfZnM= +github.com/tidwall/match v1.2.0/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= +github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= +github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA= +github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI= +github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw= +github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ= +github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= +github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= +github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +github.com/urfave/cli v1.22.16 h1:MH0k6uJxdwdeWQTwhSO42Pwr4YLrNLwBtg1MRgTqPdQ= +github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU= +github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fastjson v1.6.10 h1:/yjJg8jaVQdYR3arGxPE2X5z89xrlhS0eGXdv+ADTh4= +github.com/valyala/fastjson v1.6.10/go.mod h1:e6FubmQouUNP73jtMLmcbxS6ydWIpOfhz34TSfO3JaE= +github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc= +github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +github.com/xdrpp/goxdr v0.1.1 h1:E1B2c6E8eYhOVyd7yEpOyopzTPirUeF6mVOfXfGyJyc= +github.com/xdrpp/goxdr v0.1.1/go.mod h1:dXo1scL/l6s7iME1gxHWo2XCppbHEKZS7m/KyYWkNzA= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= +github.com/xssnick/tonutils-go v1.14.1 h1:zV/iVYl/h3hArS+tPsd9XrSFfGert3r21caMltPSeHg= +github.com/xssnick/tonutils-go v1.14.1/go.mod h1:68xwWjpoGGqiTbLJ0gT63sKu1Z1moCnDLLzA+DKanIg= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= +github.com/zksync-sdk/zksync2-go v1.1.1-0.20250620124214-2c742ee399c6 h1:VRdX3Gn/I7ITbzUY4ZNfgn65tdQM9Zhf2b7KP0HZllk= +github.com/zksync-sdk/zksync2-go v1.1.1-0.20250620124214-2c742ee399c6/go.mod h1:NWNlQS21isOsSsn+hLRAPpiuv+3P+LcdaZNuRt2T5Yo= +go.mongodb.org/mongo-driver v1.17.2 h1:gvZyk8352qSfzyZ2UMWcpDpMSGEr1eqE4T793SqyhzM= +go.mongodb.org/mongo-driver v1.17.2/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ= +go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= +go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 h1:YH4g8lQroajqUwWbq/tr2QX1JFmEXaDLgG+ew9bLMWo= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0/go.mod h1:fvPi2qXDqFs8M4B4fmJhE92TyQs9Ydjlg3RvfUp+NbQ= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0 h1:7iP2uCb7sGddAr30RRS6xjKy7AZ2JtTOPA3oolgVSw8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.65.0/go.mod h1:c7hN3ddxs/z6q9xwvfLPk+UHlWRQyaeR1LdgfL/66l0= +go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo= +go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= +go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.19.0 h1:Dn8rkudDzY6KV9dr/D/bTUuWgqDf9xe0rr4G2elrn0Y= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.19.0/go.mod h1:gMk9F0xDgyN9M/3Ed5Y1wKcx/9mlU91NXY2SNq7RQuU= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.20.0 h1:owlhcJ3QO3X0YTDTCcDZ4V+6aVDkWbNmBoQ5NUp7Oww= +go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.20.0/go.mod h1:MP4eemTiI9zC8fgg+DYynhYDYf3ba72S376TvP+Ye0Q= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0 h1:8UQVDcZxOJLtX6gxtDt3vY2WTgvZqMQRzjsqiIHQdkc= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0/go.mod h1:2lmweYCiHYpEjQ/lSJBYhj9jP1zvCvQW4BqL9dnT7FQ= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0 h1:w1K+pCJoPpQifuVpsKamUdn9U0zM3xUziVOqsGksUrY= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.43.0/go.mod h1:HBy4BjzgVE8139ieRI75oXm3EcDN+6GhD88JT1Kjvxg= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 h1:88Y4s2C8oTui1LGM6bTWkw0ICGcOLCAI5l6zsD1j20k= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0/go.mod h1:Vl1/iaggsuRlrHf/hfPJPvVag77kKyvrLeD10kpMl+A= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0 h1:RAE+JPfvEmvy+0LzyUA25/SGawPwIUbZ6u0Wug54sLc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0/go.mod h1:AGmbycVGEsRx9mXMZ75CsOyhSP6MFIcj/6dnG+vhVjk= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 h1:3iZJKlCZufyRzPzlQhUIWVmfltrXuGyfjREgGP3UUjc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0/go.mod h1:/G+nUPfhq2e+qiXMGxMwumDrP5jtzU+mWN7/sjT2rak= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.19.0 h1:GJkybS+crDMdExT/BUNCEgfrmfboztcS6PhvSo88HKM= +go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.19.0/go.mod h1:NuAyxRYIG2lKX3YQkB+83StTxM7s52PUUkRRiC0wnYI= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.43.0 h1:TC+BewnDpeiAmcscXbGMfxkO+mwYUwE/VySwvw88PfA= +go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.43.0/go.mod h1:J/ZyF4vfPwsSr9xJSPyQ4LqtcTPULFR64KwTikGLe+A= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.43.0 h1:mS47AX77OtFfKG4vtp+84kuGSFZHTyxtXIN269vChY0= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.43.0/go.mod h1:PJnsC41lAGncJlPUniSwM81gc80GkgWJWr3cu2nKEtU= +go.opentelemetry.io/otel/log v0.20.0 h1:/5i0vuHxCLWUfChWG41K9wkM0jafruPw9NU1/RCJirs= +go.opentelemetry.io/otel/log v0.20.0/go.mod h1:wOcMcjsZpG8x7Bak7IhSi/lg8wscV2C1VdrKCLPlt0E= +go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM= +go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= +go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= +go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= +go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= +go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E= +go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= +go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= +go.opentelemetry.io/otel/sdk/log v0.20.0 h1:vM3xI7TQgKPiSghe6urZtAkyFY7SodrSpC83CffDFuY= +go.opentelemetry.io/otel/sdk/log v0.20.0/go.mod h1:Knej2nmsTUzN79T2eeXdRsjjPcoxoq2pUyUHz9TFyyU= +go.opentelemetry.io/otel/sdk/log/logtest v0.20.0 h1:OqdRZ1guyzamK3M6LlRsmGqRrjkHWw6WZOKKli5ELpg= +go.opentelemetry.io/otel/sdk/log/logtest v0.20.0/go.mod h1:PuMIlm7zAt7c3z8zfOI5ox4iT1Z87We+PF6YoINux/M= +go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= +go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= +go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ= +go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= +go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= +go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= +go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/ratelimit v0.3.1 h1:K4qVE+byfv/B3tC+4nYWP7v/6SimcO7HzHekoMNBma0= +go.uber.org/ratelimit v0.3.1/go.mod h1:6euWsTB6U/Nb3X++xEUXA8ciPJvr19Q/0h1+oDcJhRk= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= +go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= +go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI= +golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= +golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= +golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0= +golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= +golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210331212208-0fccb6fa2b5c/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= +golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= +golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= +golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210331175145-43e1dd70ce54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= +golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/telemetry v0.0.0-20260508192327-42602be52be6 h1:HjU6IWBiAgRIdAJ9/y1rwCn+UELEmwV+VsTLzj/W4sE= +golang.org/x/telemetry v0.0.0-20260508192327-42602be52be6/go.mod h1:Eqhaxk/wZsWEH8CRxLwj6xzEJbz7k1EFGqx7nyCoabE= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4= +golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= +golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= +golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= +golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= +golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da h1:noIWHXmPHxILtqtCOPIhSt0ABwskkZKjD3bXGnZGpNY= +golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= +gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20210401141331-865547bb08e2/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa h1:Kjn0N0tCrDgiAFW+lGO4JZ3ck44CehvJQMAwj9QF0G8= +google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa h1:mZHHdPZl0dbGHCflZgAq/Q468DWVFcU2whhB2KAo8fk= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.81.1 h1:VnnIIZ88UzOOKLukQi+ImGz8O1Wdp8nAGGnvOfEIWQQ= +google.golang.org/grpc v1.81.1/go.mod h1:xGH9GfzOyMTGIOXBJmXt+BX/V0kcdQbdcuwQ/zNw42I= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/evanphx/json-patch.v4 v4.12.0 h1:n6jtcsulIzXPJaxegRbvFNNrZDjbij7ny3gmSPG+6V4= +gopkg.in/evanphx/json-patch.v4 v4.12.0/go.mod h1:p8EYWUEYMpynmqDbY58zCKCFZw8pRWMG4EsWvDvM72M= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/guregu/null.v4 v4.0.0 h1:1Wm3S1WEA2I26Kq+6vcW+w0gcDo44YKYD7YIEJNHDjg= +gopkg.in/guregu/null.v4 v4.0.0/go.mod h1:YoQhUrADuG3i9WqesrCmpNRwm1ypAgSHYqoOcTu/JrI= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q= +gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= +k8s.io/api v0.32.3 h1:Hw7KqxRusq+6QSplE3NYG4MBxZw1BZnq4aP4cJVINls= +k8s.io/api v0.32.3/go.mod h1:2wEDTXADtm/HA7CCMD8D8bK4yuBUptzaRhYcYEEYA3k= +k8s.io/apimachinery v0.33.2 h1:IHFVhqg59mb8PJWTLi8m1mAoepkUNYmptHsV+Z1m5jY= +k8s.io/apimachinery v0.33.2/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM= +k8s.io/client-go v0.32.3 h1:RKPVltzopkSgHS7aS98QdscAgtgah/+zmpAogooIqVU= +k8s.io/client-go v0.32.3/go.mod h1:3v0+3k4IcT9bXTc4V2rt+d2ZPPG700Xy6Oi0Gdl2PaY= +k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= +k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4= +k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8= +k8s.io/utils v0.0.0-20241210054802-24370beab758 h1:sdbE21q2nlQtFh65saZY+rRM6x6aJJI8IUa1AmH/qa0= +k8s.io/utils v0.0.0-20241210054802-24370beab758/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +pgregory.net/rapid v1.2.0 h1:keKAYRcjm+e1F0oAuU5F5+YPAWcyxNNRK2wud503Gnk= +pgregory.net/rapid v1.2.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8= +sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo= +sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/randfill v1.0.0 h1:JfjMILfT8A6RbawdsK2JXGBR5AQVfd+9TbzrlneTyrU= +sigs.k8s.io/randfill v1.0.0/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc= +sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps= +sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= diff --git a/registry-kit/ledger/client.go b/registry-kit/ledger/client.go new file mode 100644 index 000000000..2da941d7e --- /dev/null +++ b/registry-kit/ledger/client.go @@ -0,0 +1,18 @@ +package ledger + +import ( + "context" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" +) + +// Client submits ledger commands for a Canton participant. +type Client interface { + Participant() canton.Participant + ForParty(party string) canton.Participant + SubmitCreate(ctx context.Context, actAs string, payload any) (*apiv2.SubmitAndWaitForTransactionResponse, error) + SubmitExercise(ctx context.Context, actAs string, template interface{ GetTemplateID() string }, contractID, choice string, choiceArg any) (*apiv2.SubmitAndWaitForTransactionResponse, error) + SubmitExerciseDisclosed(ctx context.Context, actAs string, template interface{ GetTemplateID() string }, contractID, choice string, choiceArg any, disclosed *apiv2.DisclosedContract) (*apiv2.SubmitAndWaitForTransactionResponse, error) + SubmitExerciseMulti(ctx context.Context, actAs []string, template interface{ GetTemplateID() string }, contractID, choice string, choiceArg any, disclosed []*apiv2.DisclosedContract) (*apiv2.SubmitAndWaitForTransactionResponse, error) +} diff --git a/registry-kit/ledger/ctf_client.go b/registry-kit/ledger/ctf_client.go new file mode 100644 index 000000000..d9a78c1c6 --- /dev/null +++ b/registry-kit/ledger/ctf_client.go @@ -0,0 +1,124 @@ +package ledger + +import ( + "context" + "fmt" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/google/uuid" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" + "github.com/smartcontractkit/go-daml/pkg/model" + "github.com/smartcontractkit/go-daml/pkg/service/ledger" +) + +// CTFClient wraps a CLDF LocalNet participant. +type CTFClient struct { + participant canton.Participant +} + +func NewCTFClient(participant canton.Participant) *CTFClient { + return &CTFClient{participant: participant} +} + +func (c *CTFClient) Participant() canton.Participant { + return c.participant +} + +func (c *CTFClient) ForParty(party string) canton.Participant { + p := c.participant + p.PartyID = party + return p +} + +func (c *CTFClient) SubmitCreate(ctx context.Context, actAs string, payload any) (*apiv2.SubmitAndWaitForTransactionResponse, error) { + tmpl, ok := payload.(interface{ GetTemplateID() string }) + if !ok { + return nil, fmt.Errorf("payload %T must implement GetTemplateID", payload) + } + + var createArgs *apiv2.Record + if creatable, ok := payload.(interface{ CreateCommand() *model.CreateCommand }); ok { + createArgs = ledger.MapToRecord(creatable.CreateCommand().Arguments) + } else { + createArgs = ledger.ConvertToRecord(payload) + } + + return c.participant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Create{ + Create: &apiv2.CreateCommand{ + TemplateId: contracts.IdentifierFromBinding(tmpl), + CreateArguments: createArgs, + }, + }, + }}, + ActAs: []string{actAs}, + }, + }) +} + +func (c *CTFClient) SubmitExercise(ctx context.Context, actAs string, template interface{ GetTemplateID() string }, contractID, choice string, choiceArg any) (*apiv2.SubmitAndWaitForTransactionResponse, error) { + return c.SubmitExerciseDisclosed(ctx, actAs, template, contractID, choice, choiceArg, nil) +} + +func (c *CTFClient) SubmitExerciseDisclosed( + ctx context.Context, + actAs string, + template interface{ GetTemplateID() string }, + contractID, choice string, + choiceArg any, + disclosed *apiv2.DisclosedContract, +) (*apiv2.SubmitAndWaitForTransactionResponse, error) { + var disclosedContracts []*apiv2.DisclosedContract + if disclosed != nil { + disclosedContracts = []*apiv2.DisclosedContract{disclosed} + } + + return c.participant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{ + Exercise: &apiv2.ExerciseCommand{ + TemplateId: contracts.IdentifierFromBinding(template), + ContractId: contractID, + Choice: choice, + ChoiceArgument: ledger.MapToValue(choiceArg), + }, + }, + }}, + ActAs: []string{actAs}, + DisclosedContracts: disclosedContracts, + }, + }) +} + +func (c *CTFClient) SubmitExerciseMulti( + ctx context.Context, + actAs []string, + template interface{ GetTemplateID() string }, + contractID, choice string, + choiceArg any, + disclosed []*apiv2.DisclosedContract, +) (*apiv2.SubmitAndWaitForTransactionResponse, error) { + return c.participant.LedgerServices.Command.SubmitAndWaitForTransaction(ctx, &apiv2.SubmitAndWaitForTransactionRequest{ + Commands: &apiv2.Commands{ + CommandId: uuid.NewString(), + Commands: []*apiv2.Command{{ + Command: &apiv2.Command_Exercise{ + Exercise: &apiv2.ExerciseCommand{ + TemplateId: contracts.IdentifierFromBinding(template), + ContractId: contractID, + Choice: choice, + ChoiceArgument: ledger.MapToValue(choiceArg), + }, + }, + }}, + ActAs: actAs, + DisclosedContracts: disclosed, + }, + }) +} diff --git a/registry-kit/ledger/devnet_client.go b/registry-kit/ledger/devnet_client.go new file mode 100644 index 000000000..7564bfafe --- /dev/null +++ b/registry-kit/ledger/devnet_client.go @@ -0,0 +1,67 @@ +package ledger + +import ( + "context" + "fmt" + + "github.com/smartcontractkit/chainlink-canton/commonconfig" + "github.com/smartcontractkit/chainlink-canton/registry-kit/config" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" + cantonProvider "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton/provider" +) + +// DevnetClient is a ledger.Client backed by a devnet/RPC Canton participant (JWT auth). +type DevnetClient = CTFClient + +// NewDevnetClient wraps a CLDF RPC participant. +func NewDevnetClient(participant canton.Participant) *DevnetClient { + return NewCTFClient(participant) +} + +// ConnectDevnet builds a ledger client from registry-kit config. +func ConnectDevnet(ctx context.Context, cfg config.Config, actAsParty string) (*DevnetClient, canton.Participant, error) { + authProvider, err := cfg.Ledger.Auth.NewProvider(ctx) + if err != nil { + return nil, canton.Participant{}, fmt.Errorf("auth provider: %w", err) + } + + providerCfg := cantonProvider.RPCChainProviderConfig{ + Participants: []cantonProvider.ParticipantConfig{{ + Endpoints: cantonProvider.Endpoints{ + JSONLedgerAPIURL: cfg.Ledger.JSONAPIURL, + GRPCLedgerAPIURL: cfg.Ledger.GRPCLedgerAPIURL, + AdminAPIURL: cfg.Ledger.AdminAPIURL, + ValidatorAPIURL: cfg.Ledger.ValidatorAPIURL, + }, + UserID: cfg.Ledger.UserID, + PartyID: actAsParty, + AuthProvider: authProvider, + }}, + } + + chainProvider := cantonProvider.NewRPCChainProvider(cfg.ChainSelector, providerCfg) + bc, err := chainProvider.Initialize(ctx) + if err != nil { + return nil, canton.Participant{}, fmt.Errorf("initialize RPC chain: %w", err) + } + + chain, ok := bc.(*canton.Chain) + if !ok || len(chain.Participants) == 0 { + return nil, canton.Participant{}, fmt.Errorf("RPC chain has no participants") + } + + participant := chain.Participants[0] + participant.PartyID = actAsParty + + return NewDevnetClient(participant), participant, nil +} + +// ConnectDevnetWithStaticJWT is a test/helper entry when auth is a pre-set JWT env var. +func ConnectDevnetWithStaticJWT(ctx context.Context, cfg config.Config, actAsParty, jwt string) (*DevnetClient, canton.Participant, error) { + cfgCopy := cfg + cfgCopy.Ledger.Auth = commonconfig.AuthConfig{ + Type: commonconfig.AuthTypeInsecureStatic, + JWT: jwt, + } + return ConnectDevnet(ctx, cfgCopy, actAsParty) +} diff --git a/registry-kit/ledger/parse.go b/registry-kit/ledger/parse.go new file mode 100644 index 000000000..dcbf0e6c3 --- /dev/null +++ b/registry-kit/ledger/parse.go @@ -0,0 +1,110 @@ +package ledger + +import ( + "fmt" + "strings" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + extensionapi "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/extensionapi" + "github.com/smartcontractkit/go-daml/pkg/service/ledger" +) + +// CreatedContractID returns the contract ID of the first created event matching entityName. +func CreatedContractID(tx *apiv2.Transaction, entityName string) (string, bool) { + if tx == nil { + return "", false + } + for _, event := range tx.GetEvents() { + if c := event.GetCreated(); c != nil && c.GetTemplateId().GetEntityName() == entityName { + return c.GetContractId(), true + } + } + + return "", false +} + +// CreatedHoldingForOwner returns a created Holding contract ID for the given owner party. +func CreatedHoldingForOwner(tx *apiv2.Transaction, owner string) (string, bool) { + if tx == nil { + return "", false + } + for _, event := range tx.GetEvents() { + c := event.GetCreated() + if c == nil || c.GetTemplateId().GetEntityName() != "Holding" { + continue + } + for _, field := range c.GetCreateArguments().GetFields() { + if field.GetLabel() != "owner" { + continue + } + if field.GetValue().GetParty() == owner { + return c.GetContractId(), true + } + } + } + + return "", false +} + +// ParseReleaseOrMintResult extracts ReleaseFromTicket exercise output when present. +func ParseReleaseOrMintResult(tx *apiv2.Transaction) (extensionapi.ReleaseOrMintResultOutput, error) { + if tx == nil { + return extensionapi.ReleaseOrMintResultOutput{}, fmt.Errorf("transaction is nil") + } + for _, event := range tx.GetEvents() { + ex := event.GetExercised() + if ex == nil || !strings.Contains(ex.GetChoice(), "ReleaseFromTicket") { + continue + } + var result extensionapi.ReleaseOrMintResult + if err := ledger.RecordToStruct(ex.GetExerciseResult(), &result); err != nil { + return extensionapi.ReleaseOrMintResultOutput{}, fmt.Errorf("parse ReleaseFromTicket result: %w", err) + } + + return result.Output, nil + } + + return extensionapi.ReleaseOrMintResultOutput{}, fmt.Errorf("ReleaseFromTicket not found in transaction") +} + +// ParseLockOrBurnResult extracts LockOrBurn exercise output when present. +func ParseLockOrBurnResult(tx *apiv2.Transaction) (extensionapi.LockOrBurnResult, error) { + if tx == nil { + return extensionapi.LockOrBurnResult{}, fmt.Errorf("transaction is nil") + } + for _, event := range tx.GetEvents() { + ex := event.GetExercised() + if ex == nil || !strings.Contains(ex.GetChoice(), "LockOrBurn") { + continue + } + var result extensionapi.LockOrBurnResult + if err := ledger.RecordToStruct(ex.GetExerciseResult(), &result); err != nil { + return extensionapi.LockOrBurnResult{}, fmt.Errorf("parse LockOrBurn result: %w", err) + } + + return result, nil + } + + return extensionapi.LockOrBurnResult{}, fmt.Errorf("LockOrBurn not found in transaction") +} + +// CreatedHoldingsForOwner returns all Holding contract IDs created for owner in the transaction. +func CreatedHoldingsForOwner(tx *apiv2.Transaction, owner string) []string { + if tx == nil { + return nil + } + var cids []string + for _, event := range tx.GetEvents() { + c := event.GetCreated() + if c == nil || c.GetTemplateId().GetEntityName() != "Holding" { + continue + } + for _, field := range c.GetCreateArguments().GetFields() { + if field.GetLabel() == "owner" && field.GetValue().GetParty() == owner { + cids = append(cids, c.GetContractId()) + break + } + } + } + return cids +} diff --git a/registry-kit/main.go b/registry-kit/main.go new file mode 100644 index 000000000..0454689bb --- /dev/null +++ b/registry-kit/main.go @@ -0,0 +1,13 @@ +package main + +import ( + "os" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/cmd" +) + +func main() { + if err := cmd.Execute(); err != nil { + os.Exit(1) + } +} diff --git a/registry-kit/operator/backend.go b/registry-kit/operator/backend.go new file mode 100644 index 000000000..a132cea3b --- /dev/null +++ b/registry-kit/operator/backend.go @@ -0,0 +1,211 @@ +package operator + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "time" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" +) + +// Client calls DA's hosted Utilities operator backend for Registry choice context. +type Client struct { + BaseURL string + HTTPClient *http.Client +} + +func NewClient(baseURL string) *Client { + return &Client{ + BaseURL: baseURL, + HTTPClient: &http.Client{ + Timeout: 60 * time.Second, + }, + } +} + +// ChoiceContext bundles extraArgs.context and disclosed contracts from the operator backend. +type ChoiceContext struct { + Context splice_api_token_metadata_v1.ChoiceContext + DisclosedContracts []*apiv2.DisclosedContract +} + +type instrumentIDJSON struct { + Admin string `json:"admin"` + ID string `json:"id"` +} + +type mintRequestBody struct { + Holder string `json:"holder"` + InstrumentID instrumentIDJSON `json:"instrumentId"` +} + +type mintContextResponse struct { + ChoiceContext *struct { + ChoiceContextData splice_api_token_metadata_v1.ChoiceContext `json:"choiceContextData"` + DisclosedContracts json.RawMessage `json:"disclosedContracts"` + } `json:"choiceContext"` + ChoiceContextData splice_api_token_metadata_v1.ChoiceContext `json:"choiceContextData"` + DisclosedContracts json.RawMessage `json:"disclosedContracts"` +} + +type acceptContextBody struct { + Meta map[string]any `json:"meta"` + ExcludeDebugFields bool `json:"excludeDebugFields"` +} + +// MintRequestContext fetches choice context for AllocationFactory_RequestMint. +func (c *Client) MintRequestContext(ctx context.Context, holder string, instrumentID splice_api_token_holding_v1.InstrumentId) (ChoiceContext, error) { + body, err := json.Marshal(mintRequestBody{ + Holder: holder, + InstrumentID: instrumentIDJSON{ + Admin: string(instrumentID.Admin), + ID: string(instrumentID.Id), + }, + }) + if err != nil { + return ChoiceContext{}, err + } + + var resp mintContextResponse + if err := c.postJSON(ctx, "/v0/registry/mint/v0/request", body, &resp); err != nil { + return ChoiceContext{}, err + } + + return resp.toChoiceContext() +} + +// MintAcceptContext fetches choice context for MintRequest_Accept. +func (c *Client) MintAcceptContext(ctx context.Context, mintRequestCID string) (ChoiceContext, error) { + body, err := json.Marshal(acceptContextBody{Meta: map[string]any{}, ExcludeDebugFields: true}) + if err != nil { + return ChoiceContext{}, err + } + + var resp mintContextResponse + path := fmt.Sprintf("/v0/registry/mint/v0/request/%s/choice-contexts/accept", mintRequestCID) + if err := c.postJSON(ctx, path, body, &resp); err != nil { + return ChoiceContext{}, err + } + + return resp.toChoiceContext() +} + +func (r mintContextResponse) toChoiceContext() (ChoiceContext, error) { + ctx := r.ChoiceContextData + if r.ChoiceContext != nil { + ctx = r.ChoiceContext.ChoiceContextData + } + + raw := r.DisclosedContracts + if r.ChoiceContext != nil && len(r.ChoiceContext.DisclosedContracts) > 0 { + raw = r.ChoiceContext.DisclosedContracts + } + + disclosed, err := parseDisclosedContracts(raw) + if err != nil { + return ChoiceContext{}, err + } + + return ChoiceContext{Context: ctx, DisclosedContracts: disclosed}, nil +} + +func (c *Client) postJSON(ctx context.Context, path string, body []byte, out any) error { + req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+path, bytes.NewReader(body)) + if err != nil { + return err + } + req.Header.Set("Content-Type", "application/json") + + resp, err := c.HTTPClient.Do(req) + if err != nil { + return fmt.Errorf("operator backend %s: %w", path, err) + } + defer resp.Body.Close() + + respBody, err := io.ReadAll(resp.Body) + if err != nil { + return err + } + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + return fmt.Errorf("operator backend %s: status %d: %s", path, resp.StatusCode, string(respBody)) + } + if err := json.Unmarshal(respBody, out); err != nil { + return fmt.Errorf("decode operator backend response: %w", err) + } + + return nil +} + +// disclosedContractJSON matches Canton JSON API disclosed contract shape. +type disclosedContractJSON struct { + TemplateID string `json:"templateId"` + ContractID string `json:"contractId"` + CreatedEventBlob string `json:"createdEventBlob"` + SynchronizerID string `json:"synchronizerId"` +} + +func parseDisclosedContracts(raw json.RawMessage) ([]*apiv2.DisclosedContract, error) { + if len(raw) == 0 || string(raw) == "null" { + return nil, nil + } + + var items []disclosedContractJSON + if err := json.Unmarshal(raw, &items); err != nil { + return nil, fmt.Errorf("parse disclosed contracts: %w", err) + } + + out := make([]*apiv2.DisclosedContract, 0, len(items)) + for _, item := range items { + blob, err := base64.StdEncoding.DecodeString(item.CreatedEventBlob) + if err != nil { + return nil, fmt.Errorf("decode createdEventBlob for %s: %w", item.ContractID, err) + } + dc := &apiv2.DisclosedContract{ + ContractId: item.ContractID, + CreatedEventBlob: blob, + SynchronizerId: item.SynchronizerID, + } + if item.TemplateID != "" { + dc.TemplateId = parseTemplateID(item.TemplateID) + } + out = append(out, dc) + } + + return out, nil +} + +func parseTemplateID(raw string) *apiv2.Identifier { + // Accept packageId:module:entity or #packageName:module:entity — entity name only needed for submission. + parts := splitTemplateID(raw) + if len(parts) < 3 { + return &apiv2.Identifier{EntityName: raw} + } + id := &apiv2.Identifier{ + ModuleName: parts[1], + EntityName: parts[2], + } + if parts[0] != "" && parts[0][0] != '#' { + id.PackageId = parts[0] + } + return id +} + +func splitTemplateID(raw string) []string { + out := make([]string, 0, 3) + start := 0 + for i := 0; i < len(raw); i++ { + if raw[i] == ':' { + out = append(out, raw[start:i]) + start = i + 1 + } + } + out = append(out, raw[start:]) + return out +} diff --git a/registry-kit/registry-kit.toml.example b/registry-kit/registry-kit.toml.example new file mode 100644 index 000000000..c0fdeb567 --- /dev/null +++ b/registry-kit/registry-kit.toml.example @@ -0,0 +1,34 @@ +# Canton registry-kit configuration (devnet.cv1) +# Copy to registry-kit.toml and fill in party IDs from your token deployer. + +network = "devnet-cv1" +chain_selector = 0 # optional; RPC metadata only + +[ledger] +json_api_url = "https://devnet.cv1.bcy-v.metalhosts.com/api/json" +grpc_ledger_api_url = "devnet.cv1.bcy-v.metalhosts.com:443" +admin_api_url = "devnet.cv1.bcy-v.metalhosts.com:443" +validator_api_url = "" +user_id = "your-ledger-user-id" +synchronizer_id = "global-domain::1220..." + +[ledger.auth] +type = "authorizationCode" # or clientCredentials / static / insecureStatic +auth_url = "https://your-okta-tenant/oauth2/default" +client_id = "your-oauth-client-id" +# client_secret = "..." # required for clientCredentials +# jwt = "..." # required for static / insecureStatic + +[parties] +operator = "operator-party::1220..." +provider = "provider-party::1220..." +registrar = "registrar-party::1220..." +# holder = "holder-party::1220..." # optional; defaults to registrar + +[ccip] +token_admin_registry_cid = "00..." +ccip_party = "ccip-owner-party::1220..." +burn_mint_pool_instance_id = "existing-pool-instance-id" + +[operator_backend] +base_url = "https://api.utilities.digitalasset-dev.com/api/utilities" diff --git a/registry-kit/registry/acs.go b/registry-kit/registry/acs.go new file mode 100644 index 000000000..d70142f68 --- /dev/null +++ b/registry-kit/registry/acs.go @@ -0,0 +1,58 @@ +package registry + +import ( + "context" + "fmt" + + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/testhelpers" +) + +// ContractRef is a template instance visible to a party. +type ContractRef struct { + ContractID string + TemplateID string +} + +// FindContractsByEntity lists active contract IDs for a template entity name. +func FindContractsByEntity(ctx context.Context, client ledger.Client, party string, template any, entityName string) ([]ContractRef, error) { + tplID := contracts.IdentifierFromBinding(template.(interface{ GetTemplateID() string })) + active, err := testhelpers.ListActiveContractsByTemplateId(ctx, client.ForParty(party), tplID) + if err != nil { + return nil, fmt.Errorf("list %s contracts: %w", entityName, err) + } + + refs := make([]ContractRef, 0, len(active)) + for _, ac := range active { + ce := ac.GetCreatedEvent() + if ce == nil { + continue + } + if entityName != "" && ce.GetTemplateId().GetEntityName() != entityName { + continue + } + refs = append(refs, ContractRef{ + ContractID: ce.GetContractId(), + TemplateID: fmt.Sprintf("%s:%s:%s", + ce.GetTemplateId().GetPackageId(), + ce.GetTemplateId().GetModuleName(), + ce.GetTemplateId().GetEntityName(), + ), + }) + } + + return refs, nil +} + +// FindFirstContractByEntity returns the first ACS match or empty string. +func FindFirstContractByEntity(ctx context.Context, client ledger.Client, party string, template any, entityName string) (string, error) { + refs, err := FindContractsByEntity(ctx, client, party, template, entityName) + if err != nil { + return "", err + } + if len(refs) == 0 { + return "", nil + } + return refs[0].ContractID, nil +} diff --git a/registry-kit/registry/bootstrap.go b/registry-kit/registry/bootstrap.go new file mode 100644 index 000000000..74b4d025d --- /dev/null +++ b/registry-kit/registry/bootstrap.go @@ -0,0 +1,200 @@ +package registry + +import ( + "context" + "fmt" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + registryapp "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_app_v0" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// BootstrapResult holds CIDs produced by the LocalNet Registry bootstrap (operator=provider=registrar). +type BootstrapResult struct { + Party string + InstrumentID string + OperatorConfiguration string + ProviderService string + ProviderConfiguration string + RegistrarService string + AllocationFactory string + InstrumentConfiguration string +} + +// BootstrapServices bootstraps Registry utility services without the DA operator backend. +func BootstrapServices(ctx context.Context, client ledger.Client, party, instrumentID string) (BootstrapResult, error) { + opCfgCID, err := createOperatorConfiguration(ctx, client, party) + if err != nil { + return BootstrapResult{}, fmt.Errorf("create operator configuration: %w", err) + } + providerReqCID, err := createProviderServiceRequest(ctx, client, party) + if err != nil { + return BootstrapResult{}, fmt.Errorf("create provider service request: %w", err) + } + providerSvcCID, err := acceptProviderServiceRequest(ctx, client, party, providerReqCID, opCfgCID) + if err != nil { + return BootstrapResult{}, fmt.Errorf("accept provider service request: %w", err) + } + providerCfgCID, err := createProviderConfiguration(ctx, client, party, providerSvcCID) + if err != nil { + return BootstrapResult{}, fmt.Errorf("create provider configuration: %w", err) + } + registrarReqCID, err := createRegistrarServiceRequest(ctx, client, party) + if err != nil { + return BootstrapResult{}, fmt.Errorf("create registrar service request: %w", err) + } + regSvcCID, allocFactoryCID, err := acceptRegistrarServiceRequest(ctx, client, party, providerSvcCID, registrarReqCID, providerCfgCID) + if err != nil { + return BootstrapResult{}, fmt.Errorf("accept registrar service request: %w", err) + } + instCfgCID, err := createInstrumentConfiguration(ctx, client, party, regSvcCID, instrumentID) + if err != nil { + return BootstrapResult{}, fmt.Errorf("create instrument configuration: %w", err) + } + + return BootstrapResult{ + Party: party, + InstrumentID: instrumentID, + OperatorConfiguration: opCfgCID, + ProviderService: providerSvcCID, + ProviderConfiguration: providerCfgCID, + RegistrarService: regSvcCID, + AllocationFactory: allocFactoryCID, + InstrumentConfiguration: instCfgCID, + }, nil +} + +func createOperatorConfiguration(ctx context.Context, client ledger.Client, party string) (string, error) { + opCfg := registryapp.OperatorConfiguration{ + Operator: types.PARTY(party), + ProviderRequirements: nil, + } + res, err := client.SubmitCreate(ctx, party, opCfg) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "OperatorConfiguration") + if !ok { + return "", fmt.Errorf("OperatorConfiguration not created") + } + + return cid, nil +} + +func createProviderServiceRequest(ctx context.Context, client ledger.Client, party string) (string, error) { + req := registryapp.ProviderServiceRequest{ + Operator: types.PARTY(party), + Provider: types.PARTY(party), + } + res, err := client.SubmitCreate(ctx, party, req) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "ProviderServiceRequest") + if !ok { + return "", fmt.Errorf("ProviderServiceRequest not created") + } + + return cid, nil +} + +func acceptProviderServiceRequest(ctx context.Context, client ledger.Client, party, reqCID, opCfgCID string) (string, error) { + args := registryapp.ProviderServiceRequestAccept{ + OperatorConfigurationCid: types.CONTRACT_ID(opCfgCID), + CredentialCids: nil, + AppRewardConfigurationDetails: nil, + } + res, err := client.SubmitExercise(ctx, party, registryapp.ProviderServiceRequest{}, reqCID, "ProviderServiceRequest_Accept", args) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "ProviderService") + if !ok { + return "", fmt.Errorf("ProviderService not created") + } + + return cid, nil +} + +func createProviderConfiguration(ctx context.Context, client ledger.Client, party, providerSvcCID string) (string, error) { + args := registryapp.ProviderServiceCreateProviderConfiguration{ + RegistrarRequirements: nil, + HolderRequirements: nil, + } + res, err := client.SubmitExercise(ctx, party, registryapp.ProviderService{}, providerSvcCID, "ProviderService_CreateProviderConfiguration", args) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "ProviderConfiguration") + if !ok { + return "", fmt.Errorf("ProviderConfiguration not created") + } + + return cid, nil +} + +func createRegistrarServiceRequest(ctx context.Context, client ledger.Client, party string) (string, error) { + createTransferRule := types.BOOL(true) + createAllocationFactory := types.BOOL(true) + req := registryapp.RegistrarServiceRequest{ + Operator: types.PARTY(party), + Provider: types.PARTY(party), + Registrar: types.PARTY(party), + CreateTransferRule: &createTransferRule, + CreateAllocationFactory: &createAllocationFactory, + } + res, err := client.SubmitCreate(ctx, party, req) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "RegistrarServiceRequest") + if !ok { + return "", fmt.Errorf("RegistrarServiceRequest not created") + } + + return cid, nil +} + +func acceptRegistrarServiceRequest(ctx context.Context, client ledger.Client, party, providerSvcCID, registrarReqCID, providerCfgCID string) (string, string, error) { + args := registryapp.ProviderServiceAcceptRegistrarServiceRequest{ + Cid: types.CONTRACT_ID(registrarReqCID), + Payload: registryapp.RegistrarServiceRequestAccept{ + ProviderConfigurationCid: types.CONTRACT_ID(providerCfgCID), + CredentialCids: nil, + }, + } + res, err := client.SubmitExercise(ctx, party, registryapp.ProviderService{}, providerSvcCID, "ProviderService_AcceptRegistrarServiceRequest", args) + if err != nil { + return "", "", err + } + + registrarSvcCID, ok := ledger.CreatedContractID(res.GetTransaction(), "RegistrarService") + if !ok { + return "", "", fmt.Errorf("RegistrarService not created") + } + allocFactoryCID, ok := ledger.CreatedContractID(res.GetTransaction(), "AllocationFactory") + if !ok { + return "", "", fmt.Errorf("AllocationFactory not created") + } + + return registrarSvcCID, allocFactoryCID, nil +} + +func createInstrumentConfiguration(ctx context.Context, client ledger.Client, party, registrarSvcCID, instrumentID string) (string, error) { + args := registryapp.RegistrarServiceCreateInstrumentConfiguration{ + InstrumentId: types.TEXT(instrumentID), + AdditionalIdentifiers: nil, + HolderRequirements: nil, + IssuerRequirements: nil, + } + res, err := client.SubmitExercise(ctx, party, registryapp.RegistrarService{}, registrarSvcCID, "RegistrarService_CreateInstrumentConfiguration", args) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "InstrumentConfiguration") + if !ok { + return "", fmt.Errorf("InstrumentConfiguration not created") + } + + return cid, nil +} diff --git a/registry-kit/registry/context.go b/registry-kit/registry/context.go new file mode 100644 index 000000000..3a1b67943 --- /dev/null +++ b/registry-kit/registry/context.go @@ -0,0 +1,30 @@ +package registry + +import ( + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +const ( + CtxKeyInstrumentConfiguration = "utility.digitalasset.com/instrument-configuration" + CtxKeyIssuerCredentials = "utility.digitalasset.com/issuer-credentials" + CtxKeyEnableResultContracts = "utility.digitalasset.com/enable-result-contracts" +) + +func emptyMetadata() splice_api_token_metadata_v1.Metadata { + return splice_api_token_metadata_v1.Metadata{Values: map[string]types.TEXT{}} +} + +// MintChoiceContext builds Registry mint choice context for AllocationFactory exercises. +func MintChoiceContext(instrumentConfigCID string, enableResultContracts bool) splice_api_token_metadata_v1.ChoiceContext { + emptyList := []splice_api_token_metadata_v1.AnyValue{} + values := map[string]splice_api_token_metadata_v1.AnyValue{ + CtxKeyInstrumentConfiguration: {AVContractId: new(types.CONTRACT_ID(instrumentConfigCID))}, + CtxKeyIssuerCredentials: {AVList: &emptyList}, + } + if enableResultContracts { + values[CtxKeyEnableResultContracts] = splice_api_token_metadata_v1.AnyValue{AVBool: new(types.BOOL(true))} + } + + return splice_api_token_metadata_v1.ChoiceContext{Values: values} +} diff --git a/registry-kit/registry/decimal.go b/registry-kit/registry/decimal.go new file mode 100644 index 000000000..ead5876d0 --- /dev/null +++ b/registry-kit/registry/decimal.go @@ -0,0 +1,15 @@ +package registry + +import ( + "fmt" + + "github.com/shopspring/decimal" +) + +func parseDecimal(label, s string) (decimal.Decimal, error) { + d, err := decimal.NewFromString(s) + if err != nil { + return decimal.Zero, fmt.Errorf("%s: parse %q: %w", label, s, err) + } + return d, nil +} diff --git a/registry-kit/registry/discover.go b/registry-kit/registry/discover.go new file mode 100644 index 000000000..5bd02217f --- /dev/null +++ b/registry-kit/registry/discover.go @@ -0,0 +1,43 @@ +package registry + +import ( + "context" + "fmt" + + registryapp "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_app_v0" + registryv0 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_v0" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" +) + +// FactoryDiscovery lists Registry service contracts visible to a party. +type FactoryDiscovery struct { + ProviderService []ContractRef + RegistrarService []ContractRef + AllocationFactory []ContractRef + TransferRule []ContractRef + InstrumentConfiguration []ContractRef +} + +// DiscoverFactories queries ACS for Registry utility templates. +func DiscoverFactories(ctx context.Context, client ledger.Client, party string) (FactoryDiscovery, error) { + var out FactoryDiscovery + var err error + + if out.ProviderService, err = FindContractsByEntity(ctx, client, party, registryapp.ProviderService{}, "ProviderService"); err != nil { + return FactoryDiscovery{}, fmt.Errorf("provider service: %w", err) + } + if out.RegistrarService, err = FindContractsByEntity(ctx, client, party, registryapp.RegistrarService{}, "RegistrarService"); err != nil { + return FactoryDiscovery{}, fmt.Errorf("registrar service: %w", err) + } + if out.AllocationFactory, err = FindContractsByEntity(ctx, client, party, registryapp.AllocationFactory{}, "AllocationFactory"); err != nil { + return FactoryDiscovery{}, fmt.Errorf("allocation factory: %w", err) + } + if out.TransferRule, err = FindContractsByEntity(ctx, client, party, registryv0.TransferRule{}, "TransferRule"); err != nil { + return FactoryDiscovery{}, fmt.Errorf("transfer rule: %w", err) + } + if out.InstrumentConfiguration, err = FindContractsByEntity(ctx, client, party, registryv0.InstrumentConfiguration{}, "InstrumentConfiguration"); err != nil { + return FactoryDiscovery{}, fmt.Errorf("instrument configuration: %w", err) + } + + return out, nil +} diff --git a/registry-kit/registry/mint.go b/registry-kit/registry/mint.go new file mode 100644 index 000000000..50f57deb9 --- /dev/null +++ b/registry-kit/registry/mint.go @@ -0,0 +1,112 @@ +package registry + +import ( + "context" + "fmt" + "time" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/google/uuid" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + registryapp "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_app_v0" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// MintViaAllocationFactory runs AllocationFactory_RequestMint + MintRequest_Accept +// with self-assembled choice context (no DA operator backend). +func MintViaAllocationFactory(ctx context.Context, client ledger.Client, bootstrap BootstrapResult, owner, amount string) (string, error) { + instDisclosed, err := DiscloseByID(ctx, client, bootstrap.Party, bootstrap.InstrumentConfiguration) + if err != nil { + return "", fmt.Errorf("disclose instrument configuration: %w", err) + } + + mintCtx := MintChoiceContext(bootstrap.InstrumentConfiguration, false) + mintReqCID, err := requestMint(ctx, client, bootstrap, owner, amount, mintCtx, instDisclosed) + if err != nil { + return "", err + } + + acceptCtx := MintChoiceContext(bootstrap.InstrumentConfiguration, true) + return acceptMintRequest(ctx, client, bootstrap.Party, owner, mintReqCID, acceptCtx, instDisclosed) +} + +func requestMint( + ctx context.Context, + client ledger.Client, + bootstrap BootstrapResult, + owner, amount string, + ctxData splice_api_token_metadata_v1.ChoiceContext, + disclosed *apiv2.DisclosedContract, +) (string, error) { + now := time.Now() + args := registryapp.AllocationFactoryRequestMint{ + ExpectedAdmin: types.PARTY(bootstrap.Party), + Mint: registryapp.Mint{ + InstrumentId: splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(bootstrap.Party), + Id: types.TEXT(bootstrap.InstrumentID), + }, + Amount: types.NUMERIC(amount), + Holder: types.PARTY(owner), + Reference: types.TEXT(fmt.Sprintf("mint-%s", uuid.NewString()[:8])), + RequestedAt: types.TIMESTAMP(now), + ExecuteBefore: types.TIMESTAMP(now.Add(24 * time.Hour)), + Meta: emptyMetadata(), + }, + ExtraArgs: splice_api_token_metadata_v1.ExtraArgs{ + Context: ctxData, + Meta: emptyMetadata(), + }, + } + res, err := client.SubmitExerciseMulti(ctx, mintActAs(bootstrap.Party, owner), registryapp.AllocationFactory{}, bootstrap.AllocationFactory, "AllocationFactory_RequestMint", args, []*apiv2.DisclosedContract{disclosed}) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "MintRequest") + if !ok { + return "", fmt.Errorf("MintRequest not created") + } + + return cid, nil +} + +func acceptMintRequest( + ctx context.Context, + client ledger.Client, + registrar, party, mintReqCID string, + ctxData splice_api_token_metadata_v1.ChoiceContext, + disclosed *apiv2.DisclosedContract, +) (string, error) { + args := registryapp.MintRequestAccept{ + ExtraArgs: splice_api_token_metadata_v1.ExtraArgs{ + Context: ctxData, + Meta: emptyMetadata(), + }, + } + res, err := client.SubmitExerciseMulti(ctx, mintActAs(registrar, party), registryapp.MintRequest{}, mintReqCID, "MintRequest_Accept", args, []*apiv2.DisclosedContract{disclosed}) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "Holding") + if !ok { + return "", fmt.Errorf("Registry Holding not created") + } + + return cid, nil +} + +func mintActAs(registrar, owner string) []string { + actAs := []string{registrar} + if owner != "" && owner != registrar { + actAs = append(actAs, owner) + } + return actAs +} + +// DiscloseByID fetches a disclosed contract blob for JSON API submission. +func DiscloseByID(ctx context.Context, client ledger.Client, party, contractID string) (*apiv2.DisclosedContract, error) { + return testhelpers.GetDisclosedContractById(ctx, client.ForParty(party), contractID) +} diff --git a/registry-kit/registry/mint_devnet.go b/registry-kit/registry/mint_devnet.go new file mode 100644 index 000000000..1a9cb1112 --- /dev/null +++ b/registry-kit/registry/mint_devnet.go @@ -0,0 +1,128 @@ +package registry + +import ( + "context" + "fmt" + "time" + + apiv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2" + "github.com/google/uuid" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/registry-kit/operator" + registryapp "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_app_v0" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + splice_api_token_metadata_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_metadata_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// MintDevnetInput identifies the registrar instrument and factories for devnet mint. +type MintDevnetInput struct { + RegistrarParty string + InstrumentID string + AllocationFactoryCID string + Holder string + Amount string +} + +// RequestMintViaOperatorBackend runs AllocationFactory_RequestMint with DA operator-backend context. +func RequestMintViaOperatorBackend( + ctx context.Context, + client ledger.Client, + backend *operator.Client, + in MintDevnetInput, +) (string, error) { + instrument := splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(in.RegistrarParty), + Id: types.TEXT(in.InstrumentID), + } + holder := in.Holder + if holder == "" { + holder = in.RegistrarParty + } + + choiceCtx, err := backend.MintRequestContext(ctx, holder, instrument) + if err != nil { + return "", fmt.Errorf("fetch mint request context: %w", err) + } + + now := time.Now() + args := registryapp.AllocationFactoryRequestMint{ + ExpectedAdmin: types.PARTY(in.RegistrarParty), + Mint: registryapp.Mint{ + InstrumentId: instrument, + Amount: types.NUMERIC(in.Amount), + Holder: types.PARTY(holder), + Reference: types.TEXT(fmt.Sprintf("mint-%s", uuid.NewString()[:8])), + RequestedAt: types.TIMESTAMP(now), + ExecuteBefore: types.TIMESTAMP(now.Add(24 * time.Hour)), + Meta: emptyMetadata(), + }, + ExtraArgs: splice_api_token_metadata_v1.ExtraArgs{ + Context: choiceCtx.Context, + Meta: emptyMetadata(), + }, + } + + res, err := client.SubmitExerciseMulti(ctx, []string{in.RegistrarParty}, registryapp.AllocationFactory{}, in.AllocationFactoryCID, "AllocationFactory_RequestMint", args, choiceCtx.DisclosedContracts) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "MintRequest") + if !ok { + return "", fmt.Errorf("MintRequest not created") + } + return cid, nil +} + +// AcceptMintViaOperatorBackend runs MintRequest_Accept with DA operator-backend context. +func AcceptMintViaOperatorBackend( + ctx context.Context, + client ledger.Client, + backend *operator.Client, + registrarParty, mintRequestCID string, +) (string, error) { + choiceCtx, err := backend.MintAcceptContext(ctx, mintRequestCID) + if err != nil { + return "", fmt.Errorf("fetch mint accept context: %w", err) + } + + args := registryapp.MintRequestAccept{ + ExtraArgs: splice_api_token_metadata_v1.ExtraArgs{ + Context: choiceCtx.Context, + Meta: emptyMetadata(), + }, + } + + var disclosed []*apiv2.DisclosedContract + if len(choiceCtx.DisclosedContracts) > 0 { + disclosed = choiceCtx.DisclosedContracts + } else { + instDisclosed, derr := DiscloseByID(ctx, client, registrarParty, mintRequestCID) + if derr == nil { + disclosed = []*apiv2.DisclosedContract{instDisclosed} + } + } + + res, err := client.SubmitExerciseMulti(ctx, []string{registrarParty}, registryapp.MintRequest{}, mintRequestCID, "MintRequest_Accept", args, disclosed) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "Holding") + if !ok { + return "", fmt.Errorf("Registry Holding not created") + } + return cid, nil +} + +// FindMintRequestForInstrument returns the first pending MintRequest CID for an instrument. +func FindMintRequestForInstrument(ctx context.Context, client ledger.Client, registrarParty, instrumentID string) (string, error) { + refs, err := FindContractsByEntity(ctx, client, registrarParty, registryapp.MintRequest{}, "MintRequest") + if err != nil { + return "", err + } + if len(refs) == 0 { + return "", nil + } + // When multiple exist, return the most recently listed (ACS sort is by created time in testhelpers). + return refs[len(refs)-1].ContractID, nil +} diff --git a/registry-kit/registry/onboarding.go b/registry-kit/registry/onboarding.go new file mode 100644 index 000000000..b176128f2 --- /dev/null +++ b/registry-kit/registry/onboarding.go @@ -0,0 +1,174 @@ +package registry + +import ( + "context" + "fmt" + "time" + + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + registryapp "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_app_v0" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// OnboardingParties lists Registry role parties for devnet onboarding. +type OnboardingParties struct { + Operator string + Provider string + Registrar string +} + +// RequestProviderService creates a ProviderServiceRequest (DA operator must accept). +func RequestProviderService(ctx context.Context, client ledger.Client, parties OnboardingParties) (string, error) { + req := registryapp.ProviderServiceRequest{ + Operator: types.PARTY(parties.Operator), + Provider: types.PARTY(parties.Provider), + } + res, err := client.SubmitCreate(ctx, parties.Provider, req) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "ProviderServiceRequest") + if !ok { + return "", fmt.Errorf("ProviderServiceRequest not created") + } + return cid, nil +} + +// WaitForProviderService polls ACS until ProviderService exists for the provider party. +func WaitForProviderService(ctx context.Context, client ledger.Client, providerParty string, timeout time.Duration) (string, error) { + deadline := time.Now().Add(timeout) + for { + cid, err := FindFirstContractByEntity(ctx, client, providerParty, registryapp.ProviderService{}, "ProviderService") + if err != nil { + return "", err + } + if cid != "" { + return cid, nil + } + if time.Now().After(deadline) { + return "", fmt.Errorf("timed out waiting for ProviderService for %s", providerParty) + } + select { + case <-ctx.Done(): + return "", ctx.Err() + case <-time.After(5 * time.Second): + } + } +} + +// OnboardRegistrarResult holds CIDs from provider-led registrar onboarding. +type OnboardRegistrarResult struct { + ProviderConfigurationCID string + RegistrarServiceRequestCID string + RegistrarServiceCID string + AllocationFactoryCID string + TransferRuleCID string +} + +// OnboardRegistrar runs ProviderConfiguration → RegistrarServiceRequest → AcceptRegistrarServiceRequest. +func OnboardRegistrar(ctx context.Context, client ledger.Client, parties OnboardingParties, providerServiceCID string) (OnboardRegistrarResult, error) { + providerCfgCID, err := createDevnetProviderConfiguration(ctx, client, parties.Provider, providerServiceCID) + if err != nil { + return OnboardRegistrarResult{}, err + } + + registrarReqCID, err := createRegistrarServiceRequestDevnet(ctx, client, parties) + if err != nil { + return OnboardRegistrarResult{}, err + } + + regSvcCID, allocCID, transferRuleCID, err := acceptRegistrarServiceRequestDevnet(ctx, client, parties.Provider, providerServiceCID, registrarReqCID, providerCfgCID) + if err != nil { + return OnboardRegistrarResult{}, err + } + + return OnboardRegistrarResult{ + ProviderConfigurationCID: providerCfgCID, + RegistrarServiceRequestCID: registrarReqCID, + RegistrarServiceCID: regSvcCID, + AllocationFactoryCID: allocCID, + TransferRuleCID: transferRuleCID, + }, nil +} + +func createDevnetProviderConfiguration(ctx context.Context, client ledger.Client, providerParty, providerServiceCID string) (string, error) { + args := registryapp.ProviderServiceCreateProviderConfiguration{ + RegistrarRequirements: nil, + HolderRequirements: nil, + } + res, err := client.SubmitExercise(ctx, providerParty, registryapp.ProviderService{}, providerServiceCID, "ProviderService_CreateProviderConfiguration", args) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "ProviderConfiguration") + if !ok { + return "", fmt.Errorf("ProviderConfiguration not created") + } + return cid, nil +} + +func createRegistrarServiceRequestDevnet(ctx context.Context, client ledger.Client, parties OnboardingParties) (string, error) { + createTransferRule := types.BOOL(true) + createAllocationFactory := types.BOOL(true) + req := registryapp.RegistrarServiceRequest{ + Operator: types.PARTY(parties.Operator), + Provider: types.PARTY(parties.Provider), + Registrar: types.PARTY(parties.Registrar), + CreateTransferRule: &createTransferRule, + CreateAllocationFactory: &createAllocationFactory, + } + res, err := client.SubmitCreate(ctx, parties.Provider, req) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "RegistrarServiceRequest") + if !ok { + return "", fmt.Errorf("RegistrarServiceRequest not created") + } + return cid, nil +} + +func acceptRegistrarServiceRequestDevnet(ctx context.Context, client ledger.Client, providerParty, providerServiceCID, registrarReqCID, providerCfgCID string) (string, string, string, error) { + args := registryapp.ProviderServiceAcceptRegistrarServiceRequest{ + Cid: types.CONTRACT_ID(registrarReqCID), + Payload: registryapp.RegistrarServiceRequestAccept{ + ProviderConfigurationCid: types.CONTRACT_ID(providerCfgCID), + CredentialCids: nil, + }, + } + res, err := client.SubmitExercise(ctx, providerParty, registryapp.ProviderService{}, providerServiceCID, "ProviderService_AcceptRegistrarServiceRequest", args) + if err != nil { + return "", "", "", err + } + + registrarSvcCID, ok := ledger.CreatedContractID(res.GetTransaction(), "RegistrarService") + if !ok { + return "", "", "", fmt.Errorf("RegistrarService not created") + } + allocCID, ok := ledger.CreatedContractID(res.GetTransaction(), "AllocationFactory") + if !ok { + return "", "", "", fmt.Errorf("AllocationFactory not created") + } + transferRuleCID, _ := ledger.CreatedContractID(res.GetTransaction(), "TransferRule") + + return registrarSvcCID, allocCID, transferRuleCID, nil +} + +// CreateInstrumentConfiguration exercises RegistrarService_CreateInstrumentConfiguration. +func CreateInstrumentConfiguration(ctx context.Context, client ledger.Client, registrarParty, registrarServiceCID, instrumentID string) (string, error) { + args := registryapp.RegistrarServiceCreateInstrumentConfiguration{ + InstrumentId: types.TEXT(instrumentID), + AdditionalIdentifiers: nil, + HolderRequirements: nil, + IssuerRequirements: nil, + } + res, err := client.SubmitExercise(ctx, registrarParty, registryapp.RegistrarService{}, registrarServiceCID, "RegistrarService_CreateInstrumentConfiguration", args) + if err != nil { + return "", err + } + cid, ok := ledger.CreatedContractID(res.GetTransaction(), "InstrumentConfiguration") + if !ok { + return "", fmt.Errorf("InstrumentConfiguration not created") + } + return cid, nil +} diff --git a/registry-kit/registry/packages.go b/registry-kit/registry/packages.go new file mode 100644 index 000000000..48a616f65 --- /dev/null +++ b/registry-kit/registry/packages.go @@ -0,0 +1,89 @@ +package registry + +import ( + "context" + "fmt" + + adminv2 "github.com/digital-asset/dazl-client/v8/go/api/com/daml/ledger/api/v2/admin" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-deployments-framework/chain/canton" +) + +// UtilityPackages lists vendored Canton Network Utility DARs for upload (dependency order). +func UtilityPackages() []contracts.Package { + return []contracts.Package{ + contracts.UtilityCommercialsV0, + contracts.UtilityCredentialV0, + contracts.UtilityCredentialAppV0, + contracts.UtilityRegistryV0, + contracts.UtilityRegistryHoldingV0, + contracts.UtilityRegistryAppV0, + } +} + +// LoadUtilityDARs loads Registry utility DAR bytes for the current contracts version. +func LoadUtilityDARs() ([][]byte, error) { + var dars [][]byte + for _, pkg := range UtilityPackages() { + dar, err := contracts.GetDar(pkg, contracts.CurrentVersion) + if err != nil { + return nil, fmt.Errorf("load DAR for %s: %w", pkg, err) + } + dars = append(dars, dar) + } + + return dars, nil +} + +// RequiredRegistryPackages are utility DARs needed for registry-kit Registry flows. +var RequiredRegistryPackages = map[string]string{ + "utility-registry-app-v0": contracts.UtilityRegistryAppV0PackageID, + "utility-registry-v0": contracts.UtilityRegistryV0PackageID, + "utility-registry-holding-v0": contracts.UtilityRegistryHoldingV0PackageID, + "utility-credential-app-v0": contracts.UtilityCredentialAppV0PackageID, + "utility-credential-v0": contracts.UtilityCredentialV0PackageID, +} + +// PackageCheckResult is one required package presence check. +type PackageCheckResult struct { + Name string + Expected string + Found bool + FoundID string +} + +// CheckPackages verifies pinned Registry utility package IDs exist on the participant. +func CheckPackages(ctx context.Context, participant canton.Participant) ([]PackageCheckResult, error) { + if participant.LedgerServices.Admin.PackageManagement == nil { + return nil, fmt.Errorf("package management client unavailable (check admin_api_url and auth)") + } + + resp, err := participant.LedgerServices.Admin.PackageManagement.ListKnownPackages(ctx, &adminv2.ListKnownPackagesRequest{}) + if err != nil { + return nil, fmt.Errorf("list known packages: %w", err) + } + installed := map[string]string{} + for _, pkg := range resp.GetPackageDetails() { + installed[pkg.GetPackageId()] = pkg.GetPackageId() + } + + results := make([]PackageCheckResult, 0, len(RequiredRegistryPackages)) + missing := 0 + for name, expectedID := range RequiredRegistryPackages { + _, found := installed[expectedID] + if !found { + missing++ + } + results = append(results, PackageCheckResult{ + Name: name, + Expected: expectedID, + Found: found, + FoundID: expectedID, + }) + } + if missing > 0 { + return results, fmt.Errorf("%d required Registry packages missing on participant", missing) + } + + return results, nil +} diff --git a/registry-kit/registry/supply.go b/registry-kit/registry/supply.go new file mode 100644 index 000000000..8b51c59e4 --- /dev/null +++ b/registry-kit/registry/supply.go @@ -0,0 +1,53 @@ +package registry + +import ( + "context" + "fmt" + + "github.com/shopspring/decimal" + "github.com/smartcontractkit/chainlink-canton/bindings" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + registryholding "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_holding_v0" +) + +// HoldingRow is one Registry Holding contract for an instrument. +type HoldingRow struct { + ContractID string + Owner string + Amount decimal.Decimal +} + +// QuerySupply aggregates Registry Holding template amounts for an instrument. +func QuerySupply(ctx context.Context, client ledger.Client, registrarParty, instrumentID string) (decimal.Decimal, []HoldingRow, error) { + holdingTpl := contracts.IdentifierFromBinding(registryholding.Holding{}) + active, err := testhelpers.ListActiveContractsByTemplateId(ctx, client.ForParty(registrarParty), holdingTpl) + if err != nil { + return decimal.Zero, nil, fmt.Errorf("list holdings: %w", err) + } + + total := decimal.Zero + rows := make([]HoldingRow, 0) + for _, ac := range active { + holding, err := bindings.UnmarshalCreatedEvent[registryholding.Holding](ac.GetCreatedEvent()) + if err != nil { + return decimal.Zero, nil, fmt.Errorf("unmarshal holding: %w", err) + } + if string(holding.Instrument.Id) != instrumentID { + continue + } + amount, err := parseDecimal("holding amount", string(holding.Amount)) + if err != nil { + return decimal.Zero, nil, err + } + total = total.Add(amount) + rows = append(rows, HoldingRow{ + ContractID: ac.GetCreatedEvent().GetContractId(), + Owner: string(holding.Owner), + Amount: amount, + }) + } + + return total, rows, nil +} diff --git a/registry-kit/registry/verify.go b/registry-kit/registry/verify.go new file mode 100644 index 000000000..1fbc5ce12 --- /dev/null +++ b/registry-kit/registry/verify.go @@ -0,0 +1,105 @@ +package registry + +import ( + "context" + "fmt" + "math/big" + + "github.com/smartcontractkit/chainlink-canton/bindings" + "github.com/smartcontractkit/chainlink-canton/contracts" + "github.com/smartcontractkit/chainlink-canton/registry-kit/ledger" + "github.com/smartcontractkit/chainlink-canton/testhelpers" + registryholding "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/utility/registry_holding_v0" + splice_api_token_holding_v1 "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/splice/splice_api_token_holding_v1" + "github.com/smartcontractkit/go-daml/pkg/types" +) + +// VerifyHolding checks the Registry Holding template and HoldingV1 interface view. +// owner is the Holding owner; registrar is the instrument admin. +func VerifyHolding(ctx context.Context, client ledger.Client, owner, registrar, holdingCID, instrumentID, expectedAmount string) error { + holdingTpl := contracts.IdentifierFromBinding(registryholding.Holding{}) + active, err := testhelpers.ListActiveContractsByTemplateId(ctx, client.ForParty(owner), holdingTpl) + if err != nil { + return fmt.Errorf("list holdings: %w", err) + } + + var found *registryholding.Holding + for _, ac := range active { + if ac.GetCreatedEvent().GetContractId() != holdingCID { + continue + } + found, err = bindings.UnmarshalCreatedEvent[registryholding.Holding](ac.GetCreatedEvent()) + if err != nil { + return fmt.Errorf("unmarshal holding: %w", err) + } + } + if found == nil { + return fmt.Errorf("Registry Holding %s not in ACS", holdingCID) + } + if types.PARTY(owner) != found.Owner { + return fmt.Errorf("owner: expected %s got %s", owner, found.Owner) + } + expected, err := parseDecimal("expected amount", expectedAmount) + if err != nil { + return err + } + actual, err := parseDecimal("holding amount", string(found.Amount)) + if err != nil { + return err + } + if !expected.Equal(actual) { + return fmt.Errorf("amount: expected %s got %s", expectedAmount, found.Amount) + } + if types.PARTY(registrar) != found.Registrar { + return fmt.Errorf("registrar: expected %s got %s", registrar, found.Registrar) + } + + instrument := holdingsInstrumentQuery(registrar, instrumentID) + partyParticipant := client.ForParty(owner) + holdings, err := testhelpers.ListHoldingsForInstrument(ctx, partyParticipant, instrument, testhelpers.WithHoldingOwner(owner)) + if err != nil { + return fmt.Errorf("list HoldingV1: %w", err) + } + + var holdingV1 *testhelpers.ListedHolding + for i := range holdings { + if holdings[i].ContractID == holdingCID { + holdingV1 = &holdings[i] + break + } + } + if holdingV1 == nil { + return fmt.Errorf("HoldingV1 interface view for %s not found", holdingCID) + } + if string(holdingV1.View.InstrumentId.Admin) != registrar { + return fmt.Errorf("HoldingV1 instrumentId.admin: expected %s got %s", registrar, holdingV1.View.InstrumentId.Admin) + } + holdingV1Amount, err := parseDecimal("HoldingV1 amount", string(holdingV1.View.Amount)) + if err != nil { + return err + } + if !expected.Equal(holdingV1Amount) { + return fmt.Errorf("HoldingV1 amount: expected %s got %s", expectedAmount, holdingV1.View.Amount) + } + + balance, err := testhelpers.GetHoldingsBalance(ctx, partyParticipant, instrument, testhelpers.WithHoldingOwner(owner)) + if err != nil { + return fmt.Errorf("aggregate balance: %w", err) + } + expectedRat := new(big.Rat) + if _, ok := expectedRat.SetString(expectedAmount); !ok { + return fmt.Errorf("aggregate balance: invalid expected amount %q", expectedAmount) + } + if expectedRat.Cmp(balance) != 0 { + return fmt.Errorf("aggregate balance: expected %s got %s", expectedAmount, balance.FloatString(10)) + } + + return nil +} + +func holdingsInstrumentQuery(registrar, instrumentID string) *splice_api_token_holding_v1.InstrumentId { + return &splice_api_token_holding_v1.InstrumentId{ + Admin: types.PARTY(registrar), + Id: types.TEXT(instrumentID), + } +}