create-canton-app 1.5.0 → 1.6.0

package/README.md

@@ -60,13 +60,13 @@ Edit `src/commands/create.js` line 43:
 
 ```javascript
 choices: [
-  { name: 'Bond Trading', value: 'bondtrading' },
+  { name: 'Token Transfer System Template', value: 'TokenTransfer' },
 
-  { name: 'Collateral Master', value: 'collateral' },
+  { name: 'Multi-Party Agreement System Template', value: 'Multiparty' },
 
-  { name: 'My Template', value: 'my-template' }, // ADD THIS
+  { name: 'Asset Holding System Template', value: 'AssetOwner' }
 
-  { name: '📄 Empty Template', value: 'empty' }
+  { name: 'My Template', value: 'my-template' }, // ADD THIS
 ]
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-canton-app",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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: 'Bond Trading', value: 'bondtrading' },
-            { name: 'Collateral Master', value: 'collateral' },
-            { 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