token

type AcceptChoiceContext struct {
	Values map[string]AnyValue `json:"values"`
}

type AcceptContextResponse struct {
	ChoiceContextData  AcceptChoiceContext         `json:"choiceContextData"`
	DisclosedContracts []registryDisclosedContract `json:"disclosedContracts"`
}

type AnyValue struct {
	Tag   string          `json:"tag"`
	Value json.RawMessage `json:"value"`
}

type AnyValueMap struct {
	Values map[string]any `json:"values"`
}

type BurnRequest struct {
	HoldingCID  string
	Amount      string
	TokenSymbol string            // needed for GetTokenConfigCID lookup
	EventMeta   map[string]string // bridge context; nil for native burns
}

type ChoiceArguments struct {
	ExpectedAdmin string                 `json:"expectedAdmin"`
	Transfer      RegistryTransferDetail `json:"transfer"`
	ExtraArgs     ExtraArgs              `json:"extraArgs"`
}

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

type Config struct {
	DomainID    string `yaml:"domain_id"`
	IssuerParty string `yaml:"issuer_party"`
	UserID      string `yaml:"user_id"`

	CIP56PackageID              string `yaml:"cip56_package_id" validate:"required"`
	SpliceTransferPackageID     string `yaml:"splice_transfer_package_id" validate:"required"`
	SpliceHoldingPackageID      string `yaml:"splice_holding_package_id" validate:"required"`
	UtilityRegistryAppPackageID string `yaml:"utility_registry_app_package_id"`
	// UtilityRegistryPackageID is the utility_registry_v0 package ID.
	// Required when using AllocationFactory-based tokens (e.g., USDCx on P2) so that
	// InstrumentConfiguration and TransferRule can be looked up and provided as context
	// for the TransferFactory_Transfer choice.
	UtilityRegistryPackageID string `yaml:"utility_registry_package_id"`

	// ExternalTokens maps InstrumentAdmin party IDs to their registry configuration.
	// Tokens whose InstrumentAdmin matches IssuerParty use local ACS-based factory discovery.
	// Tokens whose InstrumentAdmin is in this map use the external registry API.
	ExternalTokens map[string]ExternalTokenConfig `yaml:"external_tokens"`
}

type EventType string

type ExecuteTransferRequest struct {
	PreparedTransfer *PreparedTransfer // The prepared transfer to execute
	Signature        []byte            // DER-encoded ECDSA signature of TransactionHash
	SignedBy         string            // Canton multihash fingerprint of signing key
}

type ExternalTokenConfig struct {
	RegistryURL string `yaml:"registry_url" validate:"required"`
}

type ExtraArgs struct {
	Context AnyValueMap `json:"context"`
	Meta    AnyValueMap `json:"meta"`
}

type Holding struct {
	ContractID      string
	Issuer          string
	Owner           string
	Amount          string
	Symbol          string // derived from Metadata["splice.chainsafe.io/symbol"]
	InstrumentAdmin string
	InstrumentID    string
	Locked          bool
	Metadata        map[string]string
}

type InstrumentRef struct {
	Admin string `json:"admin"`
	ID    string `json:"id"`
}

type KeyResolver func(partyID string) (Signer, error)

type MintRequest struct {
	RecipientParty string
	Amount         string
	TokenSymbol    string // needed for GetTokenConfigCID lookup
	ConfigCID      string
	EventMeta      map[string]string // bridge context; nil for native mints
}

type Option func(*settings)

type PrepareTransferRequest struct {
	FromPartyID string
	ToPartyID   string
	Amount      string
	TokenSymbol string
}

type PreparedTransfer struct {
	TransferID           string                             // UUID
	TransactionHash      []byte                             // PreparedTransactionHash from Canton (what client signs)
	PreparedTransaction  *interactivev2.PreparedTransaction // Opaque protobuf message (passed back on execute)
	HashingSchemeVersion interactivev2.HashingSchemeVersion // Must match on execute
	PartyID              string                             // The acting party
	ExpiresAt            time.Time                          // Cache TTL deadline
}

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

type RegistryRequest struct {
	ChoiceArguments    ChoiceArguments `json:"choiceArguments"`
	ExcludeDebugFields bool            `json:"excludeDebugFields"`
}

type RegistryResponse struct {
	FactoryID          string          `json:"factoryId"`
	TransferKind       string          `json:"transferKind"`
	ChoiceContext      json.RawMessage `json:"choiceContext"`
	DisclosedContracts json.RawMessage `json:"disclosedContracts"`
}

type RegistryTransferDetail struct {
	Sender           string        `json:"sender"`
	Receiver         string        `json:"receiver"`
	Amount           string        `json:"amount"`
	InstrumentID     InstrumentRef `json:"instrumentId"`
	InputHoldingCIDs []string      `json:"inputHoldingCids"`
	Meta             AnyValueMap   `json:"meta"`
	ExecuteBefore    string        `json:"executeBefore"`
	RequestedAt      string        `json:"requestedAt"`
}

type Signer interface {
	SignDER(message []byte) ([]byte, error)
	Fingerprint() (string, error)
}

type TemplateIdentifier struct {
	PackageID  string `json:"package_id"`
	ModuleName string `json:"module_name"`
	EntityName string `json:"entity_name"`
}

type Token interface {
	// GetTokenConfigCID returns the active TokenConfig contract ID for the given token symbol.
	GetTokenConfigCID(ctx context.Context, tokenSymbol string) (string, error)

	// Mint mints tokens using TokenConfig.IssuerMint and returns the created holding contract ID.
	Mint(ctx context.Context, req *MintRequest) (string, error)

	// Burn burns tokens using TokenConfig.IssuerBurn.
	Burn(ctx context.Context, req *BurnRequest) error

	// GetHoldings returns holdings for the owner and token symbol.
	// Delegates to GetHoldingsByParty using the Splice HoldingV1 interface.
	GetHoldings(ctx context.Context, ownerParty string, tokenSymbol string) ([]*Holding, error)

	// GetHoldingsByParty queries all Splice HoldingV1 holdings visible to the given party,
	// optionally filtered by instrumentID (empty string returns all instruments).
	// This is the unified query path for all Splice-compliant tokens (CIP-56 and external).
	GetHoldingsByParty(ctx context.Context, ownerParty, instrumentID string) ([]*Holding, error)

	// GetAllHoldings returns all CIP56Holding contracts queried as IssuerParty.
	// Used by the indexer and totalSupply — does NOT use the unified HoldingV1 path.
	GetAllHoldings(ctx context.Context) ([]*Holding, error) // TODO: use pagination

	// GetBalanceByFingerprint returns the owner's total balance (sum of holdings) for the token symbol.
	GetBalanceByFingerprint(ctx context.Context, fingerprint string, tokenSymbol string) (string, error)

	// GetBalanceByPartyID returns the owner's total balance (sum of holdings) for the token symbol.
	GetBalanceByPartyID(ctx context.Context, partyID string, tokenSymbol string) (string, error)

	// GetTotalSupply returns the total supply (sum across all holdings) for the token symbol.
	GetTotalSupply(ctx context.Context, tokenSymbol string) (string, error)

	// TransferByFingerprint transfers tokens by resolving fingerprints to parties.
	// idempotencyKey is used as the Canton CommandId for idempotent submission.
	TransferByFingerprint(ctx context.Context, idempotencyKey, fromFingerprint, toFingerprint, amount, tokenSymbol string) error

	// TransferByPartyID transfers tokens by party IDs using Interactive Submission.
	// idempotencyKey is used as the Canton CommandId for idempotent submission.
	// Requires a KeyResolver configured via WithKeyResolver (external/secp256k1 parties only).
	TransferByPartyID(ctx context.Context, idempotencyKey, fromParty, toParty, amount, tokenSymbol string) error

	// TransferInternalByPartyID transfers tokens for an internal Canton party using
	// regular command submission (SubmitAndWaitForTransaction). Unlike TransferByPartyID,
	// no KeyResolver is required — the Canton node holds the signing key. Use this for
	// issuer or bridge parties that are not registered with an external secp256k1 key.
	// idempotencyKey is used as the Canton CommandId for idempotent submission.
	TransferInternalByPartyID(ctx context.Context, idempotencyKey, fromParty, toParty, amount, tokenSymbol string) error

	// GetTokenTransferEvents returns all active CIP56.Events.TokenTransferEvent contracts visible to relayerParty.
	GetTokenTransferEvents(ctx context.Context) ([]*TokenTransferEvent, error)

	// GetTransferFactory returns the active CIP56TransferFactory contract ID and its
	// CreatedEventBlob for explicit contract disclosure by external wallets (Splice Registry API).
	GetTransferFactory(ctx context.Context) (*TransferFactoryInfo, error)

	// PrepareTransfer builds a Canton transaction for a non-custodial transfer and returns
	// the hash that the client must sign externally.
	PrepareTransfer(ctx context.Context, req *PrepareTransferRequest) (*PreparedTransfer, error)

	// ExecuteTransfer completes a previously prepared transfer using the client's DER signature.
	ExecuteTransfer(ctx context.Context, req *ExecuteTransferRequest) error

	// FindPendingInboundTransferInstructions returns contract IDs of active TransferOffer contracts
	// where partyID is an observer (i.e. the receiver). Used by the accept worker to find offers
	// to accept on behalf of custodial parties.
	FindPendingInboundTransferInstructions(ctx context.Context, partyID string) ([]string, error)

	// AcceptTransferInstruction accepts a pending inbound transfer for a custodial party.
	// Calls the registrar's accept choice-context endpoint (keyed by instrumentAdmin), encodes
	// the AnyValue choiceContext, and exercises TransferInstruction_Accept via SubmitAndWait.
	AcceptTransferInstruction(ctx context.Context, partyID, instructionCID, instrumentAdmin string) error

	// PrepareAcceptTransfer builds a Canton transaction for accepting a pending inbound
	// transfer instruction and returns the hash that the client must sign externally.
	// Use ExecuteTransfer to complete the accept once the client has signed.
	PrepareAcceptTransfer(
		ctx context.Context, partyID, instructionCID, instrumentAdmin string,
	) (*PreparedTransfer, error)
}

type TokenTransferEvent struct {
	ContractID      string
	Issuer          string
	FromParty       string // empty = mint (no sender)
	ToParty         string // empty = burn (no receiver)
	Amount          string
	InstrumentAdmin string
	InstrumentID    string
	Timestamp       time.Time
	Meta            map[string]string // bridge context; nil for native ops
	AuditObservers  []string
}

type TransferFactoryInfo struct {
	ContractID       string
	CreatedEventBlob []byte
	TemplateID       TemplateIdentifier
}