fromInterfaceContractId

fromInterfaceContractId : HasFromInterface t i => ContractId i -> ContractId t

(Daml-LF >= 1.15) Convert an interface contract id into a template contract id. For example, fromInterfaceContractId @MyTemplate cid.

Can also be used to convert an interface contract id into a contract id of one of its requiring interfaces.

This function does not verify that the interface contract id actually points to a template of the given type. This means that a subsequent fetch, exercise, or archive may fail, if, for example, the contract id points to a contract that implements the interface but is of a different template type than expected.

Therefore, you should only use fromInterfaceContractId in situations where you already know that the contract id points to a contract of the right template type. You can also use it in situations where you will fetch, exercise, or archive the contract right away, when a transaction failure is the appropriate response to the contract having the wrong template type.

In all other cases, consider using fetchFromInterface instead.

coerceInterfaceContractId : (HasInterfaceTypeRep i, HasInterfaceTypeRep j) => ContractId i -> ContractId j

fetchFromInterface : (HasFromInterface t i, HasFetch i) => ContractId i -> Update (Optional (ContractId t, t))

do
  fetchResult <- fetchFromInterface @MyTemplate ifaceCid
  case fetchResult of
    None -> abort "Failed to convert interface to appropriate template type"
    Some (tplCid, tpl) -> do
       ... do something with tpl and tplCid ...

_exerciseInterfaceGuard : a -> b -> c -> Bool

view : HasInterfaceView i v => i -> v

partyToText : Party -> Text

partyFromText : Text -> Optional Party

∀ p. partyFromText (partyToText p) = Some p
∀ txt p. partyFromText txt = Some p ==> partyToText p = txt

coerceContractId : ContractId a -> ContractId b

curry : ((a, b) -> c) -> a -> b -> c

uncurry : (a -> b -> c) -> (a, b) -> c

>> : Action m => m a -> m b -> m b

ap : Applicative f => f (a -> b) -> f a -> f b

return : Applicative m => a -> m a

join : Action m => m (m a) -> m a

identity : a -> a

guard : ActionFail m => Bool -> m ()

foldl : (b -> a -> b) -> b -> [a] -> b

>>> foldl (+) 0 [1,2,3]
6

>>> foldl (^) 10 [2,3]
1000000

find : (a -> Bool) -> [a] -> Optional a

length : [a] -> Int

any : (a -> Bool) -> [a] -> Bool

all : (a -> Bool) -> [a] -> Bool

or : [Bool] -> Bool

and : [Bool] -> Bool

elem : Eq a => a -> [a] -> Bool

notElem : Eq a => a -> [a] -> Bool

<$> : Functor f => (a -> b) -> f a -> f b

optional : b -> (a -> b) -> Optional a -> b

>>> optional False (> 2) (Some 3)
True

>>> optional False (> 2) None
False

>>> optional 0 (*2) (Some 5)
10
>>> optional 0 (*2) None
0

>>> optional "" show (Some 5)
"5"
>>> optional "" show (None : Optional Int)
""

either : (a -> c) -> (b -> c) -> Either a b -> c

>>> let s = Left [1,2,3] : Either [Int] Int in either length (*2) s
3
>>> let n = Right 3 : Either [Int] Int in either length (*2) n
6

concat : [[a]] -> [a]

++ : [a] -> [a] -> [a]

flip : (a -> b -> c) -> b -> a -> c

reverse : [a] -> [a]

mapA : Applicative m => (a -> m b) -> [a] -> m [b]

forA : Applicative m => [a] -> (a -> m b) -> m [b]

sequence : Applicative m => [m a] -> m [a]

=<< : Action m => (a -> m b) -> m a -> m b

concatMap : (a -> [b]) -> [a] -> [b]

replicate : Int -> a -> [a]

take : Int -> [a] -> [a]

drop : Int -> [a] -> [a]

splitAt : Int -> [a] -> ([a], [a])

takeWhile : (a -> Bool) -> [a] -> [a]

dropWhile : (a -> Bool) -> [a] -> [a]

span : (a -> Bool) -> [a] -> ([a], [a])

partition : (a -> Bool) -> [a] -> ([a], [a])

>>> partition (<0) [1, -2, -3, 4, -5, 6]
([-2, -3, -5], [1, 4, 6])

break : (a -> Bool) -> [a] -> ([a], [a])

lookup : Eq a => a -> [(a, b)] -> Optional b

enumerate : (Enum a, Bounded a) => [a]

zip : [a] -> [b] -> [(a, b)]

zip3 : [a] -> [b] -> [c] -> [(a, b, c)]

zipWith : (a -> b -> c) -> [a] -> [b] -> [c]

zipWith3 : (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

unzip : [(a, b)] -> ([a], [b])

unzip3 : [(a, b, c)] -> ([a], [b], [c])

traceRaw : Text -> a -> a

trace : Show b => b -> a -> a

traceId : Show b => b -> b

debug : (Show b, Action m) => b -> m ()

debugRaw : Action m => Text -> m ()

fst : (a, b) -> a

snd : (a, b) -> b

truncate : Numeric n -> Int

intToNumeric : NumericScale n => Int -> Numeric n

intToDecimal : Int -> Decimal

roundBankers : Int -> Numeric n -> Numeric n

roundCommercial : NumericScale n => Int -> Numeric n -> Numeric n

round : NumericScale n => Numeric n -> Int

floor : NumericScale n => Numeric n -> Int

ceiling : NumericScale n => Numeric n -> Int

null : [a] -> Bool

filter : (a -> Bool) -> [a] -> [a]

sum : Additive a => [a] -> a

product : Multiplicative a => [a] -> a

undefined : a

softFetch : HasSoftFetch t => ContractId t -> Update t

softExercise : HasSoftExercise t c r => ContractId t -> c -> Update r

stakeholder : (HasSignatory t, HasObserver t) => t -> [Party]

maintainer : HasMaintainer t k => k -> [Party]

exerciseByKey : HasExerciseByKey t k c r => k -> c -> Update r

createAndExercise : (HasCreate t, HasExercise t c r) => t -> c -> Update r

templateTypeRep : HasTemplateTypeRep t => TemplateTypeRep

toAnyTemplate : HasToAnyTemplate t => t -> AnyTemplate

fromAnyTemplate : HasFromAnyTemplate t => AnyTemplate -> Optional t

toAnyChoice : (HasTemplateTypeRep t, HasToAnyChoice t c r) => c -> AnyChoice

fromAnyChoice : (HasTemplateTypeRep t, HasFromAnyChoice t c r) => AnyChoice -> Optional c

toAnyContractKey : (HasTemplateTypeRep t, HasToAnyContractKey t k) => k -> AnyContractKey

fromAnyContractKey : (HasTemplateTypeRep t, HasFromAnyContractKey t k) => AnyContractKey -> Optional k

visibleByKey : HasLookupByKey t k => k -> Update Bool