create-canton-app 1.4.2 → 1.5.2

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.readonlyInclude": {
+        "**/.daml/unpacked-dars/**": true
+    }
+}

package/README.md

@@ -60,9 +60,9 @@ Edit `src/commands/create.js` line 43:
 
 ```javascript
 choices: [
-  { name: 'Token Contract', value: 'token' },
+  { name: 'Bond Trading', value: 'bondtrading' },
 
-  { name: 'Escrow Contract', value: 'escrow' },
+  { name: 'Collateral Master', value: 'collateral' },
 
   { name: 'My Template', value: 'my-template' }, // ADD THIS
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-canton-app",
-  "version": "1.4.2",
+  "version": "1.5.2",
   "description": "Scaffold Canton Network/Daml projects in seconds",
   "main": "bin/create-canton-app.js",
   "repository": {

package/src/commands/create.js

@@ -139,9 +139,9 @@ async function create(projectName, options) {
           name: 'template',
           message: 'Which template would you like to use?',
           choices: [
-            { name: 'Token Contract (fungible token like ERC20)', value: 'token' },
-            { name: 'Escrow Contract (multi-party escrow)', value: 'escrow' },
-            { name: 'Empty Template (blank starter)', value: 'empty' }
+            { name: 'Token Transfer System Template', value: 'TokenTransfer' },
+            { name: 'Multi-Party Agreement System Template', value: 'Multiparty' },
+            { name: 'Asset Holding System Template', value: 'AssetOwner' }
           ]
         }
       ]);

package/src/templates/AssetOwner/daml/AssetHolding.daml

@@ -0,0 +1,276 @@
+-- | Asset Holding System for Canton Network
+-- CIP-0056 Token Standard Compatible
+-- UTXO-style holdings with memo support for exchange deposits
+module AssetHolding where
+
+import DA.TextMap (TextMap)
+import qualified DA.TextMap as TM
+import Daml.Script
+
+-------------------------------------------------------------------------------
+-- DATA TYPES
+-------------------------------------------------------------------------------
+
+data InstrumentId = InstrumentId
+  with
+    admin : Party
+    id : Text
+  deriving (Eq, Show)
+
+data AssetLock = AssetLock
+  with
+    lockHolder : Party
+    lockReason : Text
+    lockedUntil : Optional Time
+  deriving (Eq, Show)
+
+data Metadata = Metadata
+  with
+    values : TextMap Text
+  deriving (Eq, Show)
+
+-------------------------------------------------------------------------------
+-- METADATA HELPERS
+-------------------------------------------------------------------------------
+
+createMemo : Text -> Metadata
+createMemo memo = Metadata with
+  values = TM.fromList [("splice.lfdecentralizedtrust.org/reason", memo)]
+
+getMemo : Metadata -> Optional Text
+getMemo (Metadata values) = TM.lookup "splice.lfdecentralizedtrust.org/reason" values
+
+emptyMetadata : Metadata
+emptyMetadata = Metadata with values = TM.empty
+
+-------------------------------------------------------------------------------
+-- MAIN ASSET CONTRACT
+-------------------------------------------------------------------------------
+
+template Asset
+  with
+    issuer : Party
+    owner : Party
+    amount : Decimal
+    symbol : Text
+    instrumentId : InstrumentId
+    lock : Optional AssetLock
+    meta : Metadata
+  where
+    signatory issuer, owner
+    observer (case lock of
+      Some l -> [l.lockHolder]
+      None -> [])
+
+    ensure 
+      amount > 0.0 &&
+      instrumentId.admin == issuer
+
+    choice Transfer : ContractId Asset
+      with
+        newOwner : Party
+        transferMeta : Metadata
+      controller owner
+      do
+        assertMsg "Cannot transfer locked asset" (isNone lock)
+        assertMsg "Cannot transfer to self" (newOwner /= owner)
+        create this with
+          owner = newOwner
+          meta = transferMeta
+
+    choice ProposeTransfer : ContractId TransferOffer
+      with
+        newOwner : Party
+        offerMeta : Metadata
+        expiresAt : Time
+      controller owner
+      do
+        assertMsg "Cannot propose transfer of locked asset" (isNone lock)
+        now <- getTime
+        assertMsg "Expiry must be in future" (expiresAt > now)
+        
+        create TransferOffer with
+          assetCid = self
+          asset = this
+          sender = owner
+          receiver = newOwner
+          offerMetadata = offerMeta
+          createdAt = now
+          expiresAt = expiresAt
+
+    choice Split : (ContractId Asset, ContractId Asset)
+      with
+        splitAmount : Decimal
+      controller owner
+      do
+        assertMsg "Split amount must be positive" (splitAmount > 0.0)
+        assertMsg "Insufficient amount for split" (amount > splitAmount)
+        assertMsg "Cannot split locked asset" (isNone lock)
+        
+        asset1 <- create this with
+          amount = splitAmount
+          meta = createMemo "Split from parent holding"
+        
+        asset2 <- create this with
+          amount = amount - splitAmount
+          meta = createMemo "Split from parent holding"
+        
+        return (asset1, asset2)
+
+    choice Merge : ContractId Asset
+      with
+        otherAssetCid : ContractId Asset
+      controller owner
+      do
+        other <- fetch otherAssetCid
+        
+        assertMsg "Issuers must match" (other.issuer == issuer)
+        assertMsg "Symbols must match" (other.symbol == symbol)
+        assertMsg "Owners must match" (other.owner == owner)
+        assertMsg "InstrumentIds must match" (other.instrumentId == instrumentId)
+        assertMsg "Cannot merge locked assets" (isNone lock && isNone other.lock)
+        
+        exercise otherAssetCid Archive
+        
+        create this with
+          amount = amount + other.amount
+          meta = createMemo "Merged from multiple holdings"
+
+    choice LockAsset : ContractId Asset
+      with
+        lockData : AssetLock
+      controller owner
+      do
+        assertMsg "Asset is already locked" (isNone lock)
+        create this with lock = Some lockData
+
+    choice UnlockAsset : ContractId Asset
+      with
+        unlockTime : Time
+        lockHolder : Party
+      controller lockHolder
+      do
+        assertMsg "Asset is not locked" (isSome lock)
+        
+        case lock of
+          Some l -> do
+            assertMsg "Not the lock holder" (l.lockHolder == lockHolder)
+            case l.lockedUntil of
+              Some until -> assertMsg "Lock period not expired" (unlockTime >= until)
+              None -> return ()
+          None -> abort "Asset is not locked"
+        
+        create this with lock = None
+
+    choice Burn : ()
+      controller owner
+      do
+        assertMsg "Cannot burn locked asset" (isNone lock)
+        return ()
+
+template TransferOffer
+  with
+    assetCid : ContractId Asset
+    asset : Asset
+    sender : Party
+    receiver : Party
+    offerMetadata : Metadata
+    createdAt : Time
+    expiresAt : Time
+  where
+    signatory sender
+    observer receiver
+
+    choice AcceptTransfer : ContractId Asset
+      controller receiver
+      do
+        now <- getTime
+        assertMsg "Transfer offer has expired" (now <= expiresAt)
+        
+        exercise assetCid Archive
+        
+        create asset with
+          owner = receiver
+          meta = offerMetadata
+
+    choice RejectTransfer : ContractId Asset
+      with
+        rejectionReason : Text
+      controller receiver
+      do
+        return assetCid
+
+    choice WithdrawOffer : ContractId Asset
+      controller sender
+      do
+        return assetCid
+
+-------------------------------------------------------------------------------
+-- EXCHANGE DEPOSIT TEMPLATE
+-------------------------------------------------------------------------------
+
+template ExchangeDepositAddress
+  with
+    exchange : Party
+    exchangeVault : Party
+    depositMemo : Text
+    supportedInstruments : [InstrumentId]
+  where
+    signatory exchange
+    observer exchangeVault
+
+    nonconsuming choice DepositToExchange : ContractId Asset
+      with
+        userAssetCid : ContractId Asset
+        user : Party
+      controller user, exchange
+      do
+        asset <- fetch userAssetCid
+        
+        assertMsg "Instrument not supported" 
+          (asset.instrumentId `elem` supportedInstruments)
+        
+        exercise userAssetCid Transfer with
+          newOwner = exchangeVault
+          transferMeta = createMemo depositMemo
+
+-------------------------------------------------------------------------------
+-- HELPER FUNCTIONS
+-------------------------------------------------------------------------------
+
+isNone : Optional a -> Bool
+isNone opt = case opt of
+  None -> True
+  Some _ -> False
+
+isSome : Optional a -> Bool
+isSome opt = not (isNone opt)
+
+-------------------------------------------------------------------------------
+-- TEST SCRIPTS
+-------------------------------------------------------------------------------
+
+setup : Script ()
+setup = do
+  issuer <- allocateParty "AssetIssuer"
+  alice <- allocateParty "Alice"
+  bob <- allocateParty "Bob"
+  
+  let instrumentId = InstrumentId with
+        admin = issuer
+        id = "GOLD-TOKEN"
+  
+  assetCid <- submitMulti [issuer, alice] [] $ createCmd Asset with
+    issuer = issuer
+    owner = alice
+    amount = 1000.0
+    symbol = "GOLD"
+    instrumentId = instrumentId
+    lock = None
+    meta = createMemo "Initial issuance"
+  
+  submitMulti [alice, issuer] [] $ exerciseCmd assetCid Transfer with
+    newOwner = bob
+    transferMeta = createMemo "Payment to Bob"
+  
+  return ()

package/src/templates/AssetOwner/daml.yaml

@@ -0,0 +1,18 @@
+# Asset Ownership System for Canton Network
+# CIP-0056 Token Standard Compatible
+# SPDX-License-Identifier: Apache-2.0
+
+sdk-version: 3.4.9
+name: AssetOwnership
+source: daml/AssetHolding.daml
+parties:
+  - AssetIssuer
+  - Alice
+  - Bob
+  - Exchange
+  - ExchangeVault
+version: 1.0.0
+dependencies:
+  - daml-prim
+  - daml-stdlib
+  - daml-script

package/src/templates/Multiparty/daml/MultiPartyAgreement.daml

@@ -0,0 +1,256 @@
+-- | Multi-Party Agreement System for Canton Network
+-- Supports incremental signing, governance, multi-sig workflows
+module MultiPartyAgreement where
+
+import DA.List (delete, sort)
+import Daml.Script
+
+-------------------------------------------------------------------------------
+-- DATA TYPES
+-------------------------------------------------------------------------------
+
+data AgreementType
+  = Governance
+  | Transaction
+  | Legal
+  | Policy
+  | Custom Text
+  deriving (Eq, Show)
+
+data AgreementMetadata = AgreementMetadata
+  with
+    agreementType : AgreementType
+    createdAt : Time
+    description : Text
+    attachmentHashes : [Text]
+  deriving (Eq, Show)
+
+data Signature = Signature
+  with
+    signer : Party
+    signedAt : Time
+    comments : Optional Text
+  deriving (Eq, Show)
+
+-------------------------------------------------------------------------------
+-- FINALIZED AGREEMENT
+-------------------------------------------------------------------------------
+
+template Agreement
+  with
+    signatories : [Party]
+    terms : Text
+    agreementId : Text
+    metadata : AgreementMetadata
+    signatures : [Signature]
+    finalizedAt : Time
+  where
+    signatory signatories
+
+    ensure uniqueParties signatories
+
+    choice ArchiveAgreement : ()
+      controller signatories
+      do
+        return ()
+
+    choice ProposeAmendment : ContractId AgreementProposal
+      with
+        proposer : Party
+        newTerms : Text
+        amendmentReason : Text
+      controller proposer
+      do
+        assertMsg "Proposer must be a signatory" (proposer `elem` signatories)
+        now <- getTime
+        create AgreementProposal with
+          proposer = proposer
+          allParties = signatories
+          alreadySigned = [proposer]
+          pendingParties = delete proposer signatories
+          terms = newTerms
+          agreementId = agreementId <> "-amendment"
+          metadata = metadata with
+            description = amendmentReason
+            createdAt = now
+          signatures = [Signature with
+            signer = proposer
+            signedAt = now
+            comments = Some amendmentReason]
+          requiredSignatures = length signatories
+          expiresAt = None
+
+-------------------------------------------------------------------------------
+-- AGREEMENT PROPOSAL
+-------------------------------------------------------------------------------
+
+template AgreementProposal
+  with
+    proposer : Party
+    allParties : [Party]
+    alreadySigned : [Party]
+    pendingParties : [Party]
+    terms : Text
+    agreementId : Text
+    metadata : AgreementMetadata
+    signatures : [Signature]
+    requiredSignatures : Int
+    expiresAt : Optional Time
+  where
+    signatory alreadySigned
+    observer allParties
+
+    ensure 
+      uniqueParties allParties &&
+      uniqueParties alreadySigned &&
+      requiredSignatures > 0 &&
+      requiredSignatures <= length allParties &&
+      length alreadySigned <= requiredSignatures
+
+    choice Sign : ContractId AgreementProposal
+      with
+        signer : Party
+        signatureComments : Optional Text
+      controller signer
+      do
+        now <- getTime
+        
+        assertMsg "Party is not in required signatories" (signer `elem` allParties)
+        assertMsg "Party has already signed" (signer `notElem` alreadySigned)
+        assertMsg "Party is not in pending list" (signer `elem` pendingParties)
+        
+        case expiresAt of
+          Some expiry -> assertMsg "Proposal has expired" (now <= expiry)
+          None -> return ()
+        
+        let newSignature = Signature with
+              signer = signer
+              signedAt = now
+              comments = signatureComments
+        
+        create this with
+          alreadySigned = signer :: alreadySigned
+          pendingParties = delete signer pendingParties
+          signatures = newSignature :: signatures
+
+    choice Finalize : ContractId Agreement
+      controller proposer
+      do
+        now <- getTime
+        assertMsg "Not enough signatures" 
+          (length alreadySigned >= requiredSignatures)
+        
+        case expiresAt of
+          Some expiry -> assertMsg "Cannot finalize expired proposal" (now <= expiry)
+          None -> return ()
+        
+        create Agreement with
+          signatories = sort alreadySigned
+          terms = terms
+          agreementId = agreementId
+          metadata = metadata
+          signatures = reverse signatures
+          finalizedAt = now
+
+    choice Reject : ()
+      with
+        rejector : Party
+        reason : Text
+      controller rejector
+      do
+        assertMsg "Only proposer or signatories can reject" 
+          (rejector == proposer || rejector `elem` allParties)
+        return ()
+
+    choice UpdateExpiration : ContractId AgreementProposal
+      with
+        newExpiry : Optional Time
+      controller proposer
+      do
+        now <- getTime
+        case newExpiry of
+          Some expiry -> assertMsg "New expiry must be in future" (expiry > now)
+          None -> return ()
+        create this with expiresAt = newExpiry
+
+    choice AddRequiredParty : ContractId AgreementProposal
+      with
+        newParty : Party
+      controller proposer
+      do
+        assertMsg "Party is already required" (newParty `notElem` allParties)
+        create this with
+          allParties = newParty :: allParties
+          pendingParties = newParty :: pendingParties
+          requiredSignatures = requiredSignatures + 1
+
+    choice RemoveRequiredParty : ContractId AgreementProposal
+      with
+        partyToRemove : Party
+      controller proposer
+      do
+        assertMsg "Cannot remove party who has signed" 
+          (partyToRemove `notElem` alreadySigned)
+        assertMsg "Party is not in required list" 
+          (partyToRemove `elem` allParties)
+        
+        create this with
+          allParties = delete partyToRemove allParties
+          pendingParties = delete partyToRemove pendingParties
+          requiredSignatures = requiredSignatures - 1
+
+-------------------------------------------------------------------------------
+-- HELPER FUNCTIONS
+-------------------------------------------------------------------------------
+
+uniqueParties : [Party] -> Bool
+uniqueParties parties = length parties == length (dedup parties)
+
+dedup : Eq a => [a] -> [a]
+dedup [] = []
+dedup (x::xs) = x :: dedup (filter (/= x) xs)
+
+-------------------------------------------------------------------------------
+-- TEST SCRIPTS
+-------------------------------------------------------------------------------
+
+setup : Script ()
+setup = do
+  alice <- allocateParty "Alice"
+  bob <- allocateParty "Bob"
+  charlie <- allocateParty "Charlie"
+  
+  now <- getTime
+  
+  let meta = AgreementMetadata with
+        agreementType = Governance
+        createdAt = now
+        description = "Partnership agreement"
+        attachmentHashes = []
+  
+  proposalCid <- submit alice $ createCmd AgreementProposal with
+    proposer = alice
+    allParties = [alice, bob, charlie]
+    alreadySigned = [alice]
+    pendingParties = [bob, charlie]
+    terms = "All parties agree to cooperate on the project"
+    agreementId = "AGREEMENT-001"
+    metadata = meta
+    signatures = [Signature with
+      signer = alice
+      signedAt = now
+      comments = Some "Initiated by Alice"]
+    requiredSignatures = 3
+    expiresAt = None
+  
+  proposalCid2 <- submit bob $ exerciseCmd proposalCid Sign with
+    signer = bob
+    signatureComments = Some "Approved by Bob"
+  
+  proposalCid3 <- submit charlie $ exerciseCmd proposalCid2 Sign with
+    signer = charlie
+    signatureComments = Some "Approved by Charlie"
+  
+  submit alice $ exerciseCmd proposalCid3 Finalize
+  
+  return ()

package/src/templates/Multiparty/daml.yaml

@@ -0,0 +1,15 @@
+# Multi-Party Agreement System for Canton Network
+# SPDX-License-Identifier: Apache-2.0
+
+sdk-version: 3.4.9
+name: MultiPartyAgreement
+source: daml/MultiPartyAgreement.daml
+parties:
+  - Alice
+  - Bob
+  - Charlie
+version: 1.0.0
+dependencies:
+  - daml-prim
+  - daml-stdlib
+  - daml-script

package/src/templates/TokenTransfer/daml/Token.daml

@@ -0,0 +1,222 @@
+-- | Token Transfer System for Canton Network
+-- Supports 1-step and 2-step transfers, split/merge, locking
+module Token where
+
+import Daml.Script
+
+-------------------------------------------------------------------------------
+-- DATA TYPES
+-------------------------------------------------------------------------------
+
+data TransferMetadata = TransferMetadata
+  with
+    reason : Optional Text
+    reference : Optional Text
+    timestamp : Time
+  deriving (Eq, Show)
+
+data TokenLock = TokenLock
+  with
+    lockHolder : Party
+    unlockCondition : Text
+    expiresAt : Optional Time
+  deriving (Eq, Show)
+
+-------------------------------------------------------------------------------
+-- MAIN TOKEN CONTRACT
+-------------------------------------------------------------------------------
+
+template Token
+  with
+    issuer : Party
+    owner : Party
+    amount : Decimal
+    tokenId : Text
+    symbol : Text
+    lock : Optional TokenLock
+    metadata : TransferMetadata
+  where
+    signatory issuer, owner
+    observer (case lock of
+      Some l -> [l.lockHolder]
+      None -> [])
+
+    ensure amount > 0.0
+
+    choice Transfer : ContractId Token
+      with
+        newOwner : Party
+        newMetadata : TransferMetadata
+      controller owner
+      do
+        assertMsg "Cannot transfer locked tokens" (isNone lock)
+        assertMsg "Cannot transfer to self" (newOwner /= owner)
+        create this with
+          owner = newOwner
+          metadata = newMetadata
+
+    choice ProposeTransfer : ContractId TransferProposal
+      with
+        newOwner : Party
+        proposalMetadata : TransferMetadata
+        expiresAt : Time
+      controller owner
+      do
+        assertMsg "Cannot propose transfer of locked tokens" (isNone lock)
+        assertMsg "Expiry must be in the future" (expiresAt > proposalMetadata.timestamp)
+        create TransferProposal with
+          tokenCid = self
+          currentOwner = owner
+          proposedOwner = newOwner
+          token = this
+          metadata = proposalMetadata
+          expiresAt = expiresAt
+
+    choice Split : (ContractId Token, ContractId Token)
+      with
+        splitAmount : Decimal
+        splitTime : Time
+      controller owner
+      do
+        assertMsg "Split amount must be positive" (splitAmount > 0.0)
+        assertMsg "Split amount must be less than total" (splitAmount < amount)
+        assertMsg "Cannot split locked tokens" (isNone lock)
+        
+        let newMetadata = TransferMetadata with
+              reason = Some "Token split"
+              reference = metadata.reference
+              timestamp = splitTime
+        
+        t1 <- create this with
+          amount = splitAmount
+          metadata = newMetadata
+        t2 <- create this with
+          amount = amount - splitAmount
+          metadata = newMetadata
+        
+        return (t1, t2)
+
+    choice MergeToken : ContractId Token
+      with
+        otherTokenCid : ContractId Token
+        mergeTime : Time
+      controller owner
+      do
+        other <- fetch otherTokenCid
+        assertMsg "Issuers must match" (other.issuer == issuer)
+        assertMsg "Token IDs must match" (other.tokenId == tokenId)
+        assertMsg "Owners must match" (other.owner == owner)
+        assertMsg "Cannot merge locked tokens" (isNone lock && isNone other.lock)
+        
+        exercise otherTokenCid Archive
+        
+        create this with
+          amount = amount + other.amount
+          metadata = TransferMetadata with
+            reason = Some "Token merge"
+            reference = metadata.reference
+            timestamp = mergeTime
+
+    choice LockTokens : ContractId Token
+      with
+        lockData : TokenLock
+      controller owner
+      do
+        assertMsg "Token is already locked" (isNone lock)
+        create this with lock = Some lockData
+
+    choice UnlockTokens : ContractId Token
+      with
+        lockHolder : Party
+      controller lockHolder
+      do
+        assertMsg "Token is not locked" (isSome lock)
+        case lock of
+          Some l -> assertMsg "Not the lock holder" (l.lockHolder == lockHolder)
+          None -> abort "Token is not locked"
+        create this with lock = None
+
+    choice Burn : ()
+      controller owner
+      do
+        assertMsg "Cannot burn locked tokens" (isNone lock)
+        return ()
+
+template TransferProposal
+  with
+    tokenCid : ContractId Token
+    currentOwner : Party
+    proposedOwner : Party
+    token : Token
+    metadata : TransferMetadata
+    expiresAt : Time
+  where
+    signatory currentOwner
+    observer proposedOwner
+
+    choice AcceptTransfer : ContractId Token
+      with
+        acceptTime : Time
+      controller proposedOwner
+      do
+        assertMsg "Transfer proposal has expired" (acceptTime <= expiresAt)
+        exercise tokenCid Archive
+        create token with
+          owner = proposedOwner
+          metadata = metadata with timestamp = acceptTime
+
+    choice RejectTransfer : ContractId Token
+      controller proposedOwner
+      do
+        return tokenCid
+
+    choice WithdrawProposal : ContractId Token
+      controller currentOwner
+      do
+        return tokenCid
+
+-------------------------------------------------------------------------------
+-- HELPER FUNCTIONS
+-------------------------------------------------------------------------------
+
+isNone : Optional a -> Bool
+isNone opt = case opt of
+  None -> True
+  Some _ -> False
+
+isSome : Optional a -> Bool
+isSome opt = not (isNone opt)
+
+-------------------------------------------------------------------------------
+-- TEST SCRIPTS
+-------------------------------------------------------------------------------
+
+setup : Script ()
+setup = do
+  alice <- allocateParty "Alice"
+  bob <- allocateParty "Bob"
+  issuer <- allocateParty "TokenIssuer"
+  
+  now <- getTime
+  
+  let transferMeta = TransferMetadata with
+        reason = Some "Initial allocation"
+        reference = None
+        timestamp = now
+  
+  tokenCid <- submitMulti [issuer, alice] [] $ createCmd Token with
+    issuer = issuer
+    owner = alice
+    amount = 1000.0
+    tokenId = "TEST-TOKEN"
+    symbol = "TEST"
+    lock = None
+    metadata = transferMeta
+  
+  submitMulti [alice, issuer] [] $ exerciseCmd tokenCid Transfer with
+    newOwner = bob
+    newMetadata = transferMeta with
+      reason = Some "Payment to Bob"
+      timestamp = now
+  
+  return ()

package/src/templates/TokenTransfer/daml.yaml

@@ -0,0 +1,15 @@
+# Token Transfer System for Canton Network
+# SPDX-License-Identifier: Apache-2.0
+
+sdk-version: 3.4.9
+name: TokenTransfer
+source: daml/Token.daml
+parties:
+  - TokenIssuer
+  - Alice
+  - Bob
+version: 1.0.0
+dependencies:
+  - daml-prim
+  - daml-stdlib
+  - daml-script

package/src/templates/empty/daml/Main.daml

@@ -1,22 +0,0 @@
--- Main.daml
--- Your Canton smart contract starts here!
-
-module Main where
-
-import Daml.Script
-
-template MyContract
-  with
-    party1 : Party
-  where
-    signatory party1
-
-setup : Script ()
-setup = script do
-  alice <- allocateParty "Alice"
-  
-  submit alice do
-    createCmd MyContract with
-      party1 = alice
-
-  return ()

package/src/templates/escrow/daml/Escrow.daml

@@ -1,53 +0,0 @@
--- Escrow.daml
--- A two-party escrow with an arbiter
-
-module Escrow where
-
-import Daml.Script
-
-template EscrowAgreement
-  with
-    buyer : Party
-    seller : Party
-    arbiter : Party
-    amount : Decimal
-    description : Text
-  where
-    signatory buyer, seller, arbiter
-
-    choice Release : ()
-      controller buyer
-      do
-        return ()
-
-    choice Dispute : ()
-      with
-        decision : Text
-      controller arbiter
-      do
-        return ()
-
-    choice Cancel : ()
-      controller buyer, seller
-      do
-        return ()
-
-setup : Script ()
-setup = script do
-  alice <- allocateParty "Alice"
-  bob <- allocateParty "Bob"
-  charlie <- allocateParty "Charlie"
-
-  escrow <- submit alice do
-    submitMulti [alice, bob, charlie] [] do
-      createCmd EscrowAgreement with
-        buyer = alice
-        seller = bob
-        arbiter = charlie
-        amount = 1000.0
-        description = "Laptop purchase"
-
-  submit alice do
-    exerciseCmd escrow Release
-
-  return ()

package/src/templates/token/daml/Token.daml

@@ -1,56 +0,0 @@
--- Token.daml
--- A simple fungible token on Canton Network
-
-module Token where
-
-import Daml.Script
-
--- The Token template represents a token holding
-template Token
-  with
-    issuer : Party
-    owner : Party
-    amount : Decimal
-    symbol : Text
-  where
-    signatory issuer
-    observer owner
-
-    -- Transfer tokens to another party
-    choice Transfer : ContractId Token
-      with
-        newOwner : Party
-      controller owner
-      do
-        create this with owner = newOwner
-
-    -- Split tokens (for partial transfers)
-    choice Split : (ContractId Token, ContractId Token)
-      with
-        splitAmount : Decimal
-      controller owner
-      do
-        assertMsg "Split amount must be less than total" (splitAmount < amount)
-        token1 <- create this with amount = splitAmount
-        token2 <- create this with amount = amount - splitAmount
-        return (token1, token2)
-
--- Example: How to use this in practice
-setup : Script ()
-setup = script do
-  alice <- allocateParty "Alice"
-  bob <- allocateParty "Bob"
-  issuer <- allocateParty "TokenIssuer"
-
-  aliceToken <- submit issuer do
-    createCmd Token with
-      issuer = issuer
-      owner = alice
-      amount = 1000.0
-      symbol = "TEST"
-
-  submit alice do
-    exerciseCmd aliceToken Transfer with
-      newOwner = bob
-
-  return ()