@flowtyio/flow-contracts 0.0.2 → 0.0.4

package/contracts/NonFungibleToken.cdc

@@ -0,0 +1,202 @@
+/**
+
+## The Flow Non-Fungible Token standard
+
+## `NonFungibleToken` contract interface
+
+The interface that all Non-Fungible Token contracts could conform to.
+If a user wants to deploy a new NFT contract, their contract would need
+to implement the NonFungibleToken interface.
+
+Their contract would have to follow all the rules and naming
+that the interface specifies.
+
+## `NFT` resource
+
+The core resource type that represents an NFT in the smart contract.
+
+## `Collection` Resource
+
+The resource that stores a user's NFT collection.
+It includes a few functions to allow the owner to easily
+move tokens in and out of the collection.
+
+## `Provider` and `Receiver` resource interfaces
+
+These interfaces declare functions with some pre and post conditions
+that require the Collection to follow certain naming and behavior standards.
+
+They are separate because it gives the user the ability to share a reference
+to their Collection that only exposes the fields and functions in one or more
+of the interfaces. It also gives users the ability to make custom resources
+that implement these interfaces to do various things with the tokens.
+
+By using resources and interfaces, users of NFT smart contracts can send
+and receive tokens peer-to-peer, without having to interact with a central ledger
+smart contract.
+
+To send an NFT to another user, a user would simply withdraw the NFT
+from their Collection, then call the deposit function on another user's
+Collection to complete the transfer.
+
+*/
+
+/// The main NFT contract interface. Other NFT contracts will
+/// import and implement this interface
+///
+pub contract interface NonFungibleToken {
+
+    /// The total number of tokens of this type in existence
+    pub var totalSupply: UInt64
+
+    /// Event that emitted when the NFT contract is initialized
+    ///
+    pub event ContractInitialized()
+
+    /// Event that is emitted when a token is withdrawn,
+    /// indicating the owner of the collection that it was withdrawn from.
+    ///
+    /// If the collection is not in an account's storage, `from` will be `nil`.
+    ///
+    pub event Withdraw(id: UInt64, from: Address?)
+
+    /// Event that emitted when a token is deposited to a collection.
+    ///
+    /// It indicates the owner of the collection that it was deposited to.
+    ///
+    pub event Deposit(id: UInt64, to: Address?)
+
+    /// Interface that the NFTs have to conform to
+    /// The metadata views methods are included here temporarily
+    /// because enforcing the metadata interfaces in the standard
+    /// would break many contracts in an upgrade. Those breaking changes
+    /// are being saved for the stable cadence milestone
+    ///
+    pub resource interface INFT {
+        /// The unique ID that each NFT has
+        pub let id: UInt64
+
+        /// Function that returns all the Metadata Views implemented by a Non Fungible Token
+        ///
+        /// @return An array of Types defining the implemented views. This value will be used by
+        ///         developers to know which parameter to pass to the resolveView() method.
+        ///
+        pub fun getViews(): [Type] {
+            return []
+        }
+
+        /// Function that resolves a metadata view for this token.
+        ///
+        /// @param view: The Type of the desired view.
+        /// @return A structure representing the requested view.
+        ///
+        pub fun resolveView(_ view: Type): AnyStruct? {
+            return nil
+        }
+    }
+
+    /// Requirement that all conforming NFT smart contracts have
+    /// to define a resource called NFT that conforms to INFT
+    ///
+    pub resource NFT: INFT {
+        pub let id: UInt64
+    }
+
+    /// Interface to mediate withdraws from the Collection
+    ///
+    pub resource interface Provider {
+        /// Removes an NFT from the resource implementing it and moves it to the caller
+        ///
+        /// @param withdrawID: The ID of the NFT that will be removed
+        /// @return The NFT resource removed from the implementing resource
+        ///
+        pub fun withdraw(withdrawID: UInt64): @NFT {
+            post {
+                result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
+            }
+        }
+    }
+
+    /// Interface to mediate deposits to the Collection
+    ///
+    pub resource interface Receiver {
+
+        /// Adds an NFT to the resource implementing it
+        ///
+        /// @param token: The NFT resource that will be deposited
+        ///
+        pub fun deposit(token: @NFT)
+    }
+
+    /// Interface that an account would commonly 
+    /// publish for their collection
+    ///
+    pub resource interface CollectionPublic {
+        pub fun deposit(token: @NFT)
+        pub fun getIDs(): [UInt64]
+        pub fun borrowNFT(id: UInt64): &NFT
+        /// Safe way to borrow a reference to an NFT that does not panic
+        ///
+        /// @param id: The ID of the NFT that want to be borrowed
+        /// @return An optional reference to the desired NFT, will be nil if the passed id does not exist
+        ///
+        pub fun borrowNFTSafe(id: UInt64): &NFT? {
+            post {
+                result == nil || result!.id == id: "The returned reference's ID does not match the requested ID"
+            }
+            return nil
+        }
+    }
+
+    /// Requirement for the concrete resource type
+    /// to be declared in the implementing contract
+    ///
+    pub resource Collection: Provider, Receiver, CollectionPublic {
+
+        /// Dictionary to hold the NFTs in the Collection
+        pub var ownedNFTs: @{UInt64: NFT}
+
+        /// Removes an NFT from the collection and moves it to the caller
+        ///
+        /// @param withdrawID: The ID of the NFT that will be withdrawn
+        /// @return The resource containing the desired NFT
+        ///
+        pub fun withdraw(withdrawID: UInt64): @NFT
+
+        /// Takes a NFT and adds it to the collections dictionary
+        /// and adds the ID to the ID array
+        /// 
+        /// @param token: An NFT resource
+        ///
+        pub fun deposit(token: @NFT)
+
+        /// Returns an array of the IDs that are in the collection
+        ///
+        /// @return An array containing all the IDs on the collection
+        ///
+        pub fun getIDs(): [UInt64]
+
+        /// Returns a borrowed reference to an NFT in the collection
+        /// so that the caller can read data and call methods from it
+        ///
+        /// @param id: The ID of the NFT that want to be borrowed
+        /// @return A reference to the NFT
+        ///
+        pub fun borrowNFT(id: UInt64): &NFT {
+            pre {
+                self.ownedNFTs[id] != nil: "NFT does not exist in the collection!"
+            }
+        }
+    }
+
+    /// Creates an empty Collection and returns it to the caller so that they can own NFTs
+    ///
+    /// @return A new Collection resource
+    /// 
+    pub fun createEmptyCollection(): @Collection {
+        post {
+            result.getIDs().length == 0: "The created collection must be empty!"
+        }
+    }
+}
+ 

package/contracts/ViewResolver.cdc

@@ -0,0 +1,25 @@
+// Taken from the NFT Metadata standard, this contract exposes an interface to let 
+// anyone borrow a contract and resolve views on it.
+//
+// This will allow you to obtain information about a contract without necessarily knowing anything about it.
+// All you need is its address and name and you're good to go!
+pub contract interface ViewResolver {
+    /// Function that returns all the Metadata Views implemented by the resolving contract
+    ///
+    /// @return An array of Types defining the implemented views. This value will be used by
+    ///         developers to know which parameter to pass to the resolveView() method.
+    ///
+    pub fun getViews(): [Type] {
+        return []
+    }
+
+    /// Function that resolves a metadata view for this token.
+    ///
+    /// @param view: The Type of the desired view.
+    /// @return A structure representing the requested view.
+    ///
+    pub fun resolveView(_ view: Type): AnyStruct? {
+        return nil
+    }
+}
+ 

package/dependency-tree.js

@@ -0,0 +1,49 @@
+const {getContractCode, getProjectConfig} = require("./utils")
+
+// Read a contract from ./contracts and determine what other contracts need to be imported
+const getImports = (contractName) => {
+  const projectConfig = getProjectConfig()
+  const contract = projectConfig.contracts[contractName]
+  if (!contract) {
+    throw new Error(`Contract "${contractName}" could not be found`)
+  }
+
+  const contractCode = getContractCode(contractName)
+  const linesWithImport = contractCode.match(/^import ".+/gm);
+  if (!linesWithImport) {
+    return []
+  }
+
+  // we need to split these up next so that we can get the contract name
+  // from each import statement
+  // import NonFungibleToken from "..."
+
+  const imports = {}
+
+  // keep track of all imports we find in all dependencies
+  const allImports = {}
+
+  if (!linesWithImport) {
+    return []
+  }
+
+  linesWithImport.forEach(line => {
+    const foundName = line.split(" ")[1].replace(/^"|"$/g, '')
+    imports[foundName] = true
+    allImports[foundName] = true
+  })
+
+  Object.keys(imports).forEach(importedContract => {
+    allImports[importedContract] = true
+    const subImports = getImports(importedContract)
+    for (const item of subImports) {
+      allImports[item] = true
+    }
+  })
+
+  return Object.keys(allImports)
+}
+
+module.exports = {
+  getImports
+}

package/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const {add, addAll} = require("./add");
+const {getDefaultConfigPath} = require("./utils");
+const program = new Command();
+
+program
+  .name("flow-contracts")
+  .description("A CLI to help manage and import Flow contracts")
+
+program.command('add')
+  .description('Add a contract (and its dependencies) to your flow.json config')
+  .argument('<contractName>', 'The contract to be added')
+  .option('-c, --config <config>', 'File location of the config to be edited')
+  .option('-a, --account <account>', 'Account that will deploy this imported contract', 'emulator-account')
+  .action((contractName, options) => {
+    if(!options.config) {
+      options.config = getDefaultConfigPath()
+    }
+
+    add(
+    {
+      name: contractName,
+      ...options
+    })
+  });
+
+program.command("add-all")
+  .description("Add all contracts to your flow.json config")
+  .option('-c, --config <config>', 'File location of the config to be edited')
+  .option('-a, --account <account>', 'Account to be used for signing', 'emulator-account')
+  .action(({config, account}) => {
+    if(!config) {
+      config = getDefaultConfigPath()
+    }
+
+    addAll(config, account)
+  })
+
+program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@flowtyio/flow-contracts",
-    "version": "0.0.2",
-    "main": "index.json", 
+    "version": "0.0.4",
+    "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",
     "license": "MIT",
@@ -10,14 +10,26 @@
         "url": "git+https://github.com/Flowtyio/flow-contracts.git"
     },
     "keywords": [
-      "cadence",
-      "nft",
-      "NonFungibleToken",
-      "flow"
+        "cadence",
+        "nft",
+        "NonFungibleToken",
+        "flow"
     ],
     "bugs": {
         "issues": "https://github.com/Flowtyio/flow-contracts/issues"
     },
-    "homepage": "https://github.com/Flowtyio/flow-contracts/blob/main/README.md"
-  }
-  
+    "homepage": "https://github.com/Flowtyio/flow-contracts/blob/main/README.md",
+    "dependencies": {
+        "commander": "^11.0.0"
+    },
+    "bin": {
+        "flow-contracts": "./index.js"
+    },
+    "files": [
+        "*.js",
+        "README.md",
+        "index.json",
+        "contracts/*.cdc",
+        "LICENSE"
+    ]
+}

package/utils.js

@@ -0,0 +1,38 @@
+const fs = require("fs");
+
+const getDefaultConfigPath = () => {
+  const currentWorkingDirectory = process.cwd();
+  return `${currentWorkingDirectory}/flow.json`
+}
+
+const getConfig = (path) => {
+  const data = fs.readFileSync(path, 'utf8')
+  try {
+    return JSON.parse(data)
+  } catch (parseError) {
+    throw new Error(`Failed to parse config file ${parseError}`)
+  }
+}
+
+const getContractCode = (contractName) => {
+  const path = `${__dirname}/contracts/${contractName}.cdc`
+  return fs.readFileSync(path, 'utf8')
+}
+
+const writeConfig = (path, config) => {
+  const jsonData = JSON.stringify(config, null, 2)
+  fs.writeFileSync(path, jsonData);
+}
+
+const getProjectConfig = () => {
+  const configLocation = `${__dirname}/flow.json`
+  return getConfig(configLocation)
+}
+
+module.exports = {
+  getContractCode,
+  getDefaultConfigPath,
+  getConfig,
+  getProjectConfig,
+  writeConfig
+}