Manage Dars and Packages

A package is a unit of compiled Daml code corresponding to one Daml project. A DAR is a collection of packages including a main package and all other packages from the dependencies of this Daml project.

Uploading DARs

To use a Daml application on a participant, you need to upload it to your participant node. The application always comes packaged as one or more DARs that need to be uploaded in the order of their dependency. There are two ways to upload DARs to a Canton node: either via the Ledger Api, or through Canton console command:

@ participant2.dars.upload("dars/CantonExamples.dar")
res1: String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

Inspecting DARs and Packages

You can get a list of uploaded DARs using:

@ participant2.dars.list()
res2: Seq[com.digitalasset.canton.participant.admin.v0.DarDescription] = Vector(
  DarDescription(
    hash = "1220c5a4ac582223dcf2a59d323e474b3411df96f39cfa1304e2739ab7ca97f3b6b8",
    name = "AdminWorkflows"
  ),
  DarDescription(
    hash = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16",
    name = "CantonExamples"
  )
)

Please note that the package “AdminWorkflows” is a package that ships with Canton. It contains the Daml templates used by the participant.health.ping command.

In order to inspect the contents of the DAR, you need to grab the hash identifying it:

@ val dars = participant2.dars.list(filterName = "CantonExamples")
dars : Seq[com.digitalasset.canton.participant.admin.v0.DarDescription] = Vector(
  DarDescription(
    hash = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16",
    name = "CantonExamples"
  )
)

@ val hash = dars.head.hash
hash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

Using that hash, you can inspect the contents of the DAR using:

@ val darContent = participant2.dars.list_contents(hash)
darContent : DarMetadata = DarMetadata(
  name = "CantonExamples",
  main = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
  packages = Vector(
    "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
    "8016b5e8e840ccc9bf15ba9a1a768cde2082f8913a313b23f42a72d9b2e36fe1",
    "cb0552debf219cc909f51cbb5c3b41e9981d39f8f645b1f35e2ef5be2e0b858a",
    "3f4deaf145a15cdcfa762c058005e2edb9baa75bb7f95a4f8f6f937378e86415",
..

You can also directly look at the packages, using:

@ participant2.packages.list()
res6: Seq[com.digitalasset.canton.participant.admin.v0.PackageDescription] = Vector(
  PackageDescription(
    packageId = "86828b9843465f419db1ef8a8ee741d1eef645df02375ebf509cdc8c3ddd16cb",
    sourceDescription = "CantonExamples"
  ),
  PackageDescription(
    packageId = "cc348d369011362a5190fe96dd1f0dfbc697fdfd10e382b9e9666f0da05961b7",
    sourceDescription = "CantonExamples"
..

Please note that a DAR can include packages that are already included in other DARs. In particular the Daml standard library are shipped with every DAR. Therefore, the sourceDescription will always contain only one textual reference to a DAR.

You can also inspect the content of a package, using:

@ participant2.packages.list_contents(darContent.main)
res7: Seq[com.digitalasset.canton.participant.admin.v0.ModuleDescription] = Vector(
  ModuleDescription(name = "CantonExamples"),
  ModuleDescription(name = "ContractKeys"),
  ModuleDescription(name = "SafePaint"),
  ModuleDescription(name = "LockIou"),
  ModuleDescription(name = "Iou"),
  ModuleDescription(name = "Divulgence"),
  ModuleDescription(name = "Paint"),
..

Understanding Package Vetting

Every participant operator uploads DARs individually to their participant node. There is no global DAR repository anywhere and participants do not have access to each others DAR repositories. Therefore, for two participants to synchronise on a transaction that uses packages contained in a certain DAR, we need both participant operators to have uploaded the same DAR before the transaction was submitted.

If one of the involved participants doesn’t know about a certain DAR, then the transaction will bounce with an error PACKAGE_NO_VETTED_BY_RECIPIENTS.

This error goes back to the fact that both participants not only upload the DAR, but also publicly declare towards their peers that they are ready to receive transactions referring to certain packages. This declaration happens automatically when you upload a DAR. The package vettings can be inspected using (preview):

@ participant2.topology.vetted_packages.list()
res8: Seq[ListVettedPackagesResult] = Vector(
  ListVettedPackagesResult(
    context = BaseResult(
      domain = "Authorized",
      validFrom = 2022-09-28T11:04:43.375952Z,
      validUntil = None,
      operation = Add,
      serialized = <ByteString@3888da29 size=2052 contents="\n\201\020\n\257\r\n\254\r\n\251\r\022 mqI4DPrBLIGvPAZG25JZz6omCZGkCM29J...">,
..

Vetting is necessary, as otherwise, a malicious participant might send a transaction referring to package a receiver does not have, which would make it impossible for the receiver to process the transaction, leading to a ledger fork. As transactions are valid only if all involved participants have vetted the used packages, this attack can not happen.

Removing Packages and DARs

Note

Note that package and DAR removal is under active development. The behaviour described in this documentation may change in the future. Package and DAR removal is a preview feature and should not be used in production.

Canton supports removal of both packages and DARs that are no longer in use. Removing unused packages and DARs has the following advantages:

• Freeing up storage
• Preventing accidental use of the old package / DAR
• Reducing the number of packages / DARs that are trusted and may potentially have to be audited

Certain conditions must to be met in order to remove packages or DARs. These conditions are designed to prevent removal of packages or DARs that are currently in use. The rest of this page describes the requirements.

Removing DARs

The following checks are performed before a DAR can be removed:

• The main package of the DAR must be unused – there should be no active contract from this package
• All package dependencies of the DAR should either be unused or contained in another of the participant node’s uploaded DARs. Canton uses this restriction to ensure that the package dependencies of the DAR don’t become “stranded” if they’re in use.
• The main package of the dar should not be vetted. If it is vetted, Canton will try to automatically revoke the vetting for the main package of the DAR, but this automatic vetting revocation will only succeed if the main package vetting originates from a standard dars.upload. Even if the automatic revocation fails, you can always manually revoke the package vetting.

The following tutorial shows how to remove a DAR with the Canton console. The first step is to upload a DAR so that we have one to removed. Additionally, store the packages that are present before the DAR is uploaded, as these can be used to double-check that DAR removal reverts to a clean state.

@ val packagesBefore = participant1.packages.list().map(_.packageId).toSet
packagesBefore : Set[String] = HashSet(
  "86828b9843465f419db1ef8a8ee741d1eef645df02375ebf509cdc8c3ddd16cb",
  "cc348d369011362a5190fe96dd1f0dfbc697fdfd10e382b9e9666f0da05961b7",
  "6839a6d3d430c569b2425e9391717b44ca324b88ba621d597778811b2d05031d",
  "99a2705ed38c1c26cbb8fe7acf36bbf626668e167a33335de932599219e0a235",
  "e22bce619ae24ca3b8e6519281cb5a33b64b3190cc763248b4c3f9ad5087a92c",
  "d58cf9939847921b2aab78eaa7b427dc4c649d25e6bee3c749ace4c3f52f5c97",
  "6c2c0667393c5f92f1885163068cd31800d2264eb088eb6fc740e11241b2bf06",
  "8a7806365bbd98d88b4c13832ebfa305f6abaeaf32cfa2b7dd25c4fa489b79fb",
  "c1f1f00558799eec139fb4f4c76f95fb52fa1837a5dd29600baa1c8ed1bdccfd",
..

@ val darHash = participant1.dars.upload("dars/CantonExamples.dar")
darHash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

If the DAR hash is unknown, it can be found using dars.list:

@ val darHash_ = participant1.dars.list().filter(_.name == "CantonExamples").head.hash
darHash_ : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

The DAR can then be removed with the following command:

@ participant1.dars.remove(darHash)

Note that, right now, DAR removal will only remove the main packages associated with the DAR:

@ val packageIds = participant1.packages.list().filter(_.sourceDescription == "CantonExamples").map(_.packageId)
packageIds : Seq[String] = Vector(
  "86828b9843465f419db1ef8a8ee741d1eef645df02375ebf509cdc8c3ddd16cb",
  "cc348d369011362a5190fe96dd1f0dfbc697fdfd10e382b9e9666f0da05961b7",
  "e491352788e56ca4603acc411ffe1a49fefd76ed8b163af86cf5ee5f4c38645b",
  "cb0552debf219cc909f51cbb5c3b41e9981d39f8f645b1f35e2ef5be2e0b858a",
  "38e6274601b21d7202bb995bc5ec147decda5a01b68d57dda422425038772af7",
  "99a2705ed38c1c26cbb8fe7acf36bbf626668e167a33335de932599219e0a235",
  "f20de1e4e37b92280264c08bf15eca0be0bc5babd7a7b5e574997f154c00cb78",
  "7efc35e331d20e12e1fcd3f58cbd026187ee79a16bc2bfcc5daeb81808bd5286",
  "8a7806365bbd98d88b4c13832ebfa305f6abaeaf32cfa2b7dd25c4fa489b79fb",
..

It’s possible to remove each of these manually, using package removal. There is a complication here that packages needed for admin workflows (e.g. the Ping command) cannot be removed, so these are skipped.

@ packageIds.filter(id => ! packagesBefore.contains(id)).foreach(id => participant1.packages.remove(id))

The following command verifies that all the packages have been removed.

@ val packages = participant1.packages.list().map(_.packageId).toSet
packages : Set[String] = HashSet(
  "86828b9843465f419db1ef8a8ee741d1eef645df02375ebf509cdc8c3ddd16cb",
  "cc348d369011362a5190fe96dd1f0dfbc697fdfd10e382b9e9666f0da05961b7",
  "6839a6d3d430c569b2425e9391717b44ca324b88ba621d597778811b2d05031d",
  "99a2705ed38c1c26cbb8fe7acf36bbf626668e167a33335de932599219e0a235",
  "e22bce619ae24ca3b8e6519281cb5a33b64b3190cc763248b4c3f9ad5087a92c",
  "d58cf9939847921b2aab78eaa7b427dc4c649d25e6bee3c749ace4c3f52f5c97",
  "6c2c0667393c5f92f1885163068cd31800d2264eb088eb6fc740e11241b2bf06",
  "8a7806365bbd98d88b4c13832ebfa305f6abaeaf32cfa2b7dd25c4fa489b79fb",
  "c1f1f00558799eec139fb4f4c76f95fb52fa1837a5dd29600baa1c8ed1bdccfd",
..

@ assert(packages == packagesBefore)

The following sections explain what happens when the DAR removal operation goes wrong, for various reasons.

Main package of the DAR is in use

The first step to illustrate this is to upload a DAR and create a contract using the main package of the DAR:

@ val darHash = participant1.dars.upload("dars/CantonExamples.dar")
darHash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

@ val packageId = participant1.packages.find("Iou").head.packageId
packageId : String = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f"

@ participant1.domains.connect_local(mydomain)

@ val createIouCmd = ledger_api_utils.create(packageId,"Iou","Iou",Map("payer" -> participant1.adminParty,"owner" -> participant1.adminParty,"amount" -> Map("value" -> 100.0, "currency" -> "EUR"),"viewers" -> List()))
..

@ participant1.ledger_api.commands.submit(Seq(participant1.adminParty), Seq(createIouCmd))
res21: com.daml.ledger.api.v1.transaction.TransactionTree = TransactionTree(
  transactionId = "122066503205d6f9681553d638bcb16f66f10720edef5ee753bade31fee7b16b3027",
  commandId = "115323e6-f570-45e5-b0d6-33d866ad2459",
  workflowId = "",
  effectiveAt = Some(
..

Now that a contract exists using the main package of the DAR, a subsequent DAR removal operation will fail:

@ participant1.dars.remove(darHash)
ERROR com.digitalasset.canton.integration.EnterpriseEnvironmentDefinition$$anon$3 - Request failed for participant1.
  GrpcRequestRefusedByServer: FAILED_PRECONDITION/PACKAGE_OR_DAR_REMOVAL_ERROR(9,ab47ae3e): The DAR DarDescriptor(SHA-256:5e00e8c00045...,CantonExamples) cannot be removed because its main package b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f is in-use by contract ContractId(007030510dfabfa3c3e449541058c2dd7a6a29d4afd5903c76eb3241604c8c058eca00122062984bc853b4d2fc51e8e41a8211805888482d3fcf4e5292ed36a417da143cdf)
on domain mydomain::122083acd031....
  Request: RemoveDar(12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16)
  CorrelationId: ab47ae3e97d9cd6bd8ac8544c37bf316
  Context: Map(participant -> participant1, test -> PackageDarManagementDocumentationIntegrationTest, pkg -> b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f)
  Command ParticipantAdministration$dars$.remove invoked from cmd10000056.sc:1

In order to remove the DAR, we must archive this contract. Note that the contract ID for this contract can also be found in the error message above.

@ val iou = participant1.ledger_api.acs.find_generic(participant1.adminParty, _.templateId == "Iou.Iou")
iou : com.digitalasset.canton.admin.api.client.commands.LedgerApiTypeWrappers.WrappedCreatedEvent = WrappedCreatedEvent(
  event = CreatedEvent(
    eventId = "#122066503205d6f9681553d638bcb16f66f10720edef5ee753bade31fee7b16b3027:0",
    contractId = "007030510dfabfa3c3e449541058c2dd7a6a29d4afd5903c76eb3241604c8c058eca00122062984bc853b4d2fc51e8e41a8211805888482d3fcf4e5292ed36a417da143cdf",
    templateId = Some(
      value = Identifier(
        packageId = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
        moduleName = "Iou",
        entityName = "Iou"
      )
..

@ val archiveIouCmd = ledger_api_utils.exercise("Archive", Map.empty, iou.event)
..

@ participant1.ledger_api.commands.submit(Seq(participant1.adminParty), Seq(archiveIouCmd))
res24: com.daml.ledger.api.v1.transaction.TransactionTree = TransactionTree(
  transactionId = "1220cf11084de69765010b56165fc7945b37a77ac7b5b1f70c81dd9d685dfaef05dc",
  commandId = "a5436955-132f-42e9-b823-311d5adcc01a",
  workflowId = "",
  effectiveAt = Some(
..

The DAR removal operation will now succeed.

@ participant1.dars.remove(darHash)

Main package of the DAR can’t be automatically removed

Similarly, DAR removal may fail because the DAR can’t be automatically removed. To illustrate this, upload the DAR without automatic vetting and subsequently vet all the packages manually.

@ val darHash = participant1.dars.upload("dars/CantonExamples.dar", vetAllPackages = false)
darHash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

@ import com.daml.lf.data.Ref.IdString.PackageId

@ val packageIds = participant1.packages.list().filter(_.sourceDescription == "CantonExamples").map(_.packageId).map(PackageId.assertFromString)
packageIds : Seq[PackageId] = Vector(
  "86828b9843465f419db1ef8a8ee741d1eef645df02375ebf509cdc8c3ddd16cb",
  "cc348d369011362a5190fe96dd1f0dfbc697fdfd10e382b9e9666f0da05961b7",
..

@ participant1.topology.vetted_packages.authorize(TopologyChangeOp.Add, participant1.id, packageIds)
res29: com.google.protobuf.ByteString = <ByteString@6db32dc1 size=2184 contents="\n\205\021\n\263\016\n\260\016\n\255\016\022 3t6ufqBX59HnMykU4OYjXTS2E2LbKdYLJ...">

The DAR removal operation will now fail:

@ participant1.dars.remove(darHash)
ERROR com.digitalasset.canton.integration.EnterpriseEnvironmentDefinition$$anon$3 - Request failed for participant1.
  GrpcRequestRefusedByServer: FAILED_PRECONDITION/PACKAGE_OR_DAR_REMOVAL_ERROR(9,0c07549d): An error was encountered whilst trying to unvet the DAR DarDescriptor(SHA-256:5e00e8c00045...,CantonExamples) with main package b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f for DAR removal. Details: IdentityManagerParentError(Mapping(VettedPackages(
  participant = participant1::12208063bac6...,
  packages = Seq(
    b4c9bc672582...,
    8016b5e8e840...,
    cb0552debf21...,
    3f4deaf145a1...,
    86828b984346...,
    f20de1e4e37b...,
    76bf0fd12bd9...,
    38e6274601b2...,
    d58cf...
  Request: RemoveDar(12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16)
  CorrelationId: 0c07549de9ea9a0bc6720fce5e873640
  Context: Map(participant -> participant1, test -> PackageDarManagementDocumentationIntegrationTest)
  Command ParticipantAdministration$dars$.remove invoked from cmd10000076.sc:1

The DAR can be successfully removed after manually revoking the vetting for the main package:

@ participant1.topology.vetted_packages.authorize(TopologyChangeOp.Remove, participant1.id, packageIds, force = true)
res30: com.google.protobuf.ByteString = <ByteString@73db2e6 size=2186 contents="\n\207\021\n\265\016\n\262\016\n\257\016\b\001\022 3t6ufqBX59HnMykU4OYjXTS2E2LbKdY...">

@ participant1.dars.remove(darHash)

Note that a force flag is needed used to revoke the package vetting; throughout this tutorial force will be used whenever a package vetting is being removed. See topology.vetted_packages.authorize for more detail.

Removing Packages

Canton also supports removing individual packages, giving the user more fine-grained control over the system. Packages can be removed if the package satisfies the following two requirements:

• The package must be unused. This means that there shouldn’t be an active contract corresponding to the package.
• The package must not be vetted. This means there shouldn’t be an active vetting transaction corresponding to the package.

The following tutorial shows how to remove a package using the Canton console. The first step is to upload and identify the package ID for the package to be removed.

@ val darHash = participant1.dars.upload("dars/CantonExamples.dar")
darHash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

@ val packageId = participant1.packages.find("Iou").head.packageId
packageId : String = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f"

Package removal will initially fail as, by default, uploading the DAR will add a vetting transaction for the package:

@ participant1.packages.remove(packageId)
ERROR com.digitalasset.canton.integration.EnterpriseEnvironmentDefinition$$anon$3 - Request failed for participant1.
  GrpcRequestRefusedByServer: FAILED_PRECONDITION/PACKAGE_OR_DAR_REMOVAL_ERROR(9,74d19063): Package b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f is currently vetted and available to use.
  Request: RemovePackage(b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f,false)
  CorrelationId: 74d19063e589bf0ab31c34602d185baa
  Context: Map(participant -> participant1, test -> PackageDarManagementDocumentationIntegrationTest)
  Command ParticipantAdministration$packages$.remove invoked from cmd10000087.sc:1

The vetting transaction must be manually revoked:

@ val packageIds = participant1.topology.vetted_packages.list().map(_.item.packageIds).filter(_.contains(packageId)).head
packageIds : Seq[com.digitalasset.canton.package.LfPackageId] = Vector(
  "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
  "8016b5e8e840ccc9bf15ba9a1a768cde2082f8913a313b23f42a72d9b2e36fe1",
..

@ participant1.topology.vetted_packages.authorize(TopologyChangeOp.Remove, participant1.id, packageIds, force = true)
res35: com.google.protobuf.ByteString = <ByteString@242740a9 size=2186 contents="\n\207\021\n\265\016\n\262\016\n\257\016\b\001\022 T1QwVJENW0xTHsp9J1NYRS5H0g6XYGb...">

And then the package can be removed:

@ participant1.packages.remove(packageId)

Package is in use

The operations above will fail if the package is in use. To illustrate this, first re-upload the package (uploading the associated DAR will work):

@ val darHash = participant1.dars.upload("dars/CantonExamples.dar")
darHash : String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

Then create a contract using the package:

@ val createIouCmd = ledger_api_utils.create(packageId,"Iou","Iou",Map("payer" -> participant1.adminParty,"owner" -> participant1.adminParty,"amount" -> Map("value" -> 100.0, "currency" -> "EUR"),"viewers" -> List()))
createIouCmd : com.daml.ledger.api.v1.commands.Command = Command(
  command = Create(
    value = CreateCommand(
      templateId = Some(
        value = Identifier(
..

@ participant1.ledger_api.commands.submit(Seq(participant1.adminParty), Seq(createIouCmd))
res39: com.daml.ledger.api.v1.transaction.TransactionTree = TransactionTree(
  transactionId = "1220353b3e16837e0c222c1016bee26c02411457de609fdfc2139d48f93b99975ac1",
  commandId = "b0dda4be-7eb7-47bd-9367-6a04cff66fda",
  workflowId = "",
  effectiveAt = Some(
    value = Timestamp(
      seconds = 1664363095L,
      nanos = 774507000,
      unknownFields = UnknownFieldSet(fields = Map())
    )
..

In this situation, the package cannot be removed:

@ participant1.packages.remove(packageId)
ERROR com.digitalasset.canton.integration.EnterpriseEnvironmentDefinition$$anon$3 - Request failed for participant1.
  GrpcRequestRefusedByServer: FAILED_PRECONDITION/PACKAGE_OR_DAR_REMOVAL_ERROR(9,57a8a51e): Package b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f is currently in-use by contract ContractId(0072aa8f4291642096ccf7a30f810eb36faefb20e342536b679e070215475fb2d0ca001220326957573d17b87702b907fd2bfc6ac13089633df9e1323467a4efca860e5831) on domain mydomain::122083acd031.... It may also be in-use by other contracts.
  Request: RemovePackage(b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f,false)
  CorrelationId: 57a8a51edb2bd7e4dfe0441323f8556d
  Context: HashMap(participant -> participant1, test -> PackageDarManagementDocumentationIntegrationTest, domain -> mydomain::122083acd031..., pkg -> b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f, contract -> ContractId(0072aa8f4291642096ccf7a30f810eb36faefb20e342536b679e070215475fb2d0ca001220326957573d17b87702b907fd2bfc6ac13089633df9e1323467a4efca860e5831))
  Command ParticipantAdministration$packages$.remove invoked from cmd10000103.sc:1

To remove the package, first archive the contract:

@ val iou = participant1.ledger_api.acs.find_generic(participant1.adminParty, _.templateId == "Iou.Iou")
iou : com.digitalasset.canton.admin.api.client.commands.LedgerApiTypeWrappers.WrappedCreatedEvent = WrappedCreatedEvent(
  event = CreatedEvent(
    eventId = "#1220353b3e16837e0c222c1016bee26c02411457de609fdfc2139d48f93b99975ac1:0",
    contractId = "0072aa8f4291642096ccf7a30f810eb36faefb20e342536b679e070215475fb2d0ca001220326957573d17b87702b907fd2bfc6ac13089633df9e1323467a4efca860e5831",
    templateId = Some(
      value = Identifier(
        packageId = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
        moduleName = "Iou",
        entityName = "Iou"
      )
..

@ val archiveIouCmd = ledger_api_utils.exercise("Archive", Map.empty, iou.event)
archiveIouCmd : com.daml.ledger.api.v1.commands.Command = Command(
  command = Exercise(
    value = ExerciseCommand(
      templateId = Some(
        value = Identifier(
          packageId = "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
          moduleName = "Iou",
          entityName = "Iou"
        )
      ),
..

@ participant1.ledger_api.commands.submit(Seq(participant1.adminParty), Seq(archiveIouCmd))
res42: com.daml.ledger.api.v1.transaction.TransactionTree = TransactionTree(
  transactionId = "1220488dc917735279b1ef0794d267741b36f070ae028450035d1c13355fd091d85c",
  commandId = "232399d0-a374-4d1f-b2f7-4637b0cfea29",
  workflowId = "",
  effectiveAt = Some(
    value = Timestamp(
      seconds = 1664363096L,
      nanos = 305710000,
      unknownFields = UnknownFieldSet(fields = Map())
    )
  ),
  offset = "00000000000000000c",
..

Then revoke the package vetting transaction:

@ val packageIds = participant1.topology.vetted_packages.list().map(_.item.packageIds).filter(_.contains(packageId)).head
packageIds : Seq[com.digitalasset.canton.package.LfPackageId] = Vector(
  "b4c9bc672582bcc8e3e539d30be416d46558000fc2d32dd255f39965ecc2ea3f",
  "8016b5e8e840ccc9bf15ba9a1a768cde2082f8913a313b23f42a72d9b2e36fe1",
..

@ participant1.topology.vetted_packages.authorize(TopologyChangeOp.Remove, participant1.id, packageIds, force = true)
res44: com.google.protobuf.ByteString = <ByteString@6aced019 size=2186 contents="\n\207\021\n\265\016\n\262\016\n\257\016\b\001\022 2Ipflku7qlUzmTF1ximdMWKoqCJVnso...">

The package removal operation should now succeed.

@ participant1.packages.remove(packageId)

Force-removing packages

Packages can also be forcibly removed, even if the conditions above are not satisfied. This is done by setting the force flag to true.

To experiment with this, first re-upload the DAR so the package becomes available again:

@ participant1.dars.upload("dars/CantonExamples.dar")
res46: String = "12205e00e8c00045e1c18cf9fe98cb64755d271c79ffc245ee3b0760fd7c358c8d16"

Then force-remove the package:

@ participant1.packages.remove(packageId, force = true)

Please note, this is a dangerous operation. Forced removal of packages should be avoided whenever possible.