common

public func intHash(value : Int) : Hash.Hash

type PackageName = Text

type Version = Text

type VersionRange = (Version, Version)

type CommonPackageInfo = { guid : Blob; name : PackageName; version : Version; price : Nat; upgradePrice : Nat; shortDescription : Text; longDescription : Text; developer : ?CyclesLedger.Account }

Common properties of package and virtual package.

public func amendedGUID(guid : Blob, name : PackageName) : Blob

type Location = (canister : Principal, id : Blob)

type ModuleEvent = {#CodeInstalledForAllCanisters; #CodeUpgradedForAllCanisters; #WithdrawCycles}

type MethodName = { method : Text }

Shared/query method name.

type ModuleCode = {#Wasm : Location; #Assets : { wasm : Location; assets : Principal }}

type SharedModule = { code : ModuleCode; installByDefault : Bool; forceReinstall : Bool; canisterVersion : ?Nat64; callbacks : [(ModuleEvent, MethodName)] }

type Module = { code : ModuleCode; installByDefault : Bool; forceReinstall : Bool; canisterVersion : ?Nat64; callbacks : HashMap.HashMap<ModuleEvent, MethodName> }

public func shareModule(m : Module) : SharedModule

public func unshareModule(m : SharedModule) : Module

type ModuleUploadCode = {#Wasm : Blob; #Assets : { wasm : Blob; assets : Principal }}

type ModuleUpload = { code : ModuleUploadCode; installByDefault : Bool; forceReinstall : Bool; canisterVersion : ?Nat64; callbacks : [(ModuleEvent, MethodName)] }

type CheckInitializedCallback = { moduleName : Text; how : {#methodName : Text; #urlPath : Text} }

If how is #methodName, then the module is considered initialized when the method is called and doesn't trap. If how is #urlPath, then the module is considered initialized when the URL path (starting with /) exists.

type SharedRealPackageInfo = { modules : [(Text, SharedModule)]; dependencies : [(PackageName, ?[VersionRange])]; suggests : [(PackageName, ?[VersionRange])]; recommends : [(PackageName, ?[VersionRange])]; functions : [(PackageName, ?[VersionRange])]; permissions : [(Text, [MethodName])]; checkInitializedCallback : ?CheckInitializedCallback; frontendModule : ?Text }

See RealPackageInfo.

type RealPackageInfo = { modules : HashMap.HashMap<Text, Module>; dependencies : [(PackageName, ?[VersionRange])]; suggests : [(PackageName, ?[VersionRange])]; recommends : [(PackageName, ?[VersionRange])]; functions : [(PackageName, ?[VersionRange])]; permissions : [(Text, [MethodName])]; checkInitializedCallback : ?CheckInitializedCallback; frontendModule : ?Text }

dependencies, suggests, recommends (akin Debian) are currently not supported. Package's functions (currently not supported) are unrelated to Motoko functions. modules are named canisters. (Names are needed for example to know which module should be replaced by which during an upgrade.)

public func shareRealPackageInfo(package : RealPackageInfo) : SharedRealPackageInfo

public func unshareRealPackageInfo(package : SharedRealPackageInfo) : RealPackageInfo

type RealPackageInfoUpload = { modules : [(Text, ModuleUpload)]; dependencies : [(PackageName, ?[VersionRange])]; suggests : [(PackageName, ?[VersionRange])]; recommends : [(PackageName, ?[VersionRange])]; functions : [(PackageName, ?[VersionRange])]; permissions : [(Text, [MethodName])]; checkInitializedCallback : ?CheckInitializedCallback; frontendModule : ?Text }

See RealPackageInfo.

type VirtualPackageInfo = { choice : [(PackageName, ?[VersionRange])]; default : PackageName }

Yet unsupported.

type SharedPackageInfo = { base : CommonPackageInfo; specific : {#real : SharedRealPackageInfo; #virtual : VirtualPackageInfo} }

type PackageInfo = { base : CommonPackageInfo; specific : {#real : RealPackageInfo; #virtual : VirtualPackageInfo} }

public func sharePackageInfo(info : PackageInfo) : SharedPackageInfo

public func unsharePackageInfo(info : SharedPackageInfo) : PackageInfo

type InstallationId = Nat

type UninstallationId = Nat

type UpgradeId = Nat

type RepositoryRO = actor { getRepositoryName : shared query () -> async Text; getRepositoryInfoURL : shared query () -> async Text; getReleases : shared query () -> async [(Text, ?Text)]; getPackage : shared query (name : PackageName, version : Version) -> async SharedPackageInfo; getWasmModule : shared query (sk : Blob) -> async Blob }

type InstalledPackageInfo = { id : InstallationId; var package : PackageInfo; var packageRepoCanister : Principal; var modulesInstalledByDefault : HashMap.HashMap<Text, Principal>; additionalModules : HashMap.HashMap<Text, Buffer.Buffer<Principal>>; var pubKey : ?Blob; var pinned : Bool }

public func modulesIterator(pkg : InstalledPackageInfo) : Iter.Iter<(Text, Principal)>

Iterate over all modules in pkg.namedModules.

public func numberOfModules(pkg : InstalledPackageInfo) : Nat

type SharedInstalledPackageInfo = { id : InstallationId; package : SharedPackageInfo; packageRepoCanister : Principal; modulesInstalledByDefault : [(Text, Principal)]; additionalModules : [(Text, [Principal])]; pubKey : ?Blob; pinned : Bool }

public func installedPackageInfoShare(info : InstalledPackageInfo) : SharedInstalledPackageInfo

public func installedPackageInfoUnshare(info : SharedInstalledPackageInfo) : InstalledPackageInfo

type SharedFullPackageInfo = { packages : [(Version, SharedPackageInfo)]; versionsMap : [(Version, Version)] }

type FullPackageInfo = { packages : HashMap.HashMap<Version, PackageInfo>; versionsMap : HashMap.HashMap<Version, Version> }

public func shareFullPackageInfo(info : FullPackageInfo) : SharedFullPackageInfo

public func unshareFullPackageInfo(info : SharedFullPackageInfo) : FullPackageInfo

public func extractModuleLocation(code : ModuleCode) : (Principal, Blob)

public func extractModuleUploadBlob(code : ModuleUploadCode) : Blob

type CanisterFulfillment = { threshold : Nat; topupAmount : Nat }

public func principalToSubaccount(principal : Principal) : Blob

public let cycles_transfer_fee :

public let icp_transfer_fee :

public let minimalFunding :