Add flix 1.0.0 generator

bindings/fcl-js_test.go

@@ -180,6 +180,17 @@ var minimumTemplate = &flixkit.FlowInteractionTemplate{
 	},
 }
 
+var minimumNoParamTemplate = &flixkit.FlowInteractionTemplate{
+	FType:    "InteractionTemplate",
+	FVersion: "1.0.0",
+	ID:       "290b6b6222b2a77b16db896a80ddf29ebd1fa3038c9e6625a933fa213fce51fa",
+	Data: flixkit.Data{
+		Type:      "script",
+		Interface: "",
+		Cadence:   "pub fun main(): Int { return 1 }",
+	},
+}
+
 func TestJSGenTransaction(t *testing.T) {
 	generator := FclJSGenerator{
 		TemplateDir: "./templates",
@@ -217,3 +228,11 @@ func TestJSGenMinScript(t *testing.T) {
 	assert.NoError(err, "ParseTemplate should not return an error")
 	autogold.ExpectFile(t, out)
 }
+func TestJSGenNoParamsScript(t *testing.T) {
+	generator := NewFclJSGenerator()
+	assert := assert.New(t)
+
+	out, err := generator.Generate(minimumNoParamTemplate, "./min.template.json", true)
+	assert.NoError(err, "ParseTemplate should not return an error")
+	autogold.ExpectFile(t, out)
+}

bindings/templates/js_fcl_main.tmpl

@@ -10,19 +10,20 @@ import flixTemplate from "{{.Location}}"
 {{- else}}
 const flixTemplate = "{{.Location}}"
 {{- end}}
-
 {{"\n"}}/**
 * {{.Description}}{{"\n"}}
    {{- if gt (len .Parameters) 0 -}}
 * @param {Object} Parameters - parameters for the cadence
     {{- range $index, $ele := .Parameters -}}
-{{"\n"}}* @param {{"{"}} {{$ele.JsType}} {{"}"}} Parameters.{{$ele.Name}} - {{$ele.Description}}: {{$ele.CadType}}
+{{"\n"}}* @param {{"{"}}{{$ele.JsType}}{{"}"}} Parameters.{{$ele.Name}} - {{$ele.Description}}: {{$ele.CadType}}
     {{- end -}}
- {{ end -}}
+    {{ else -}}
+* No parameters needed.
+ {{- end -}}
  {{- if not .IsScript -}}
 {{"\n"}}* @returns {Promise<string>} - returns a promise which resolves to the transaction id
  {{- end -}}
-{{"\n"}}*/
+{{- "\n"}}*/
 {{if .IsScript}}
 {{- template "js_fcl_script.tmpl" .}}
 {{else}}

bindings/templates/js_fcl_script.tmpl

@@ -1,10 +1,12 @@
-export async function {{.Title}}({ 
+export async function {{.Title}}( 
  {{- if len .Parameters -}}
+  {
     {{- range $index, $ele := .Parameters -}}
       {{if $index}}, {{end}}{{.Name}}
     {{- end -}}
+  }
   {{- end -}}
-}) {
+) {
   const info = await fcl.query({
     template: flixTemplate,
     {{ if len .Parameters -}}

bindings/testdata/TestJSGenArrayScript.golden

@@ -7,11 +7,10 @@
 import * as fcl from "@onflow/fcl"
 import flixTemplate from "./multiply-numbers.template.json"
 
-
 /**
 * Multiply numbers in an array
 * @param {Object} Parameters - parameters for the cadence
-* @param { Array<string> } Parameters.numbers - Array of numbers to be multiplied: Int
+* @param {Array<string>} Parameters.numbers - Array of numbers to be multiplied: Int
 */
 export async function multiplyNumbers({numbers}) {
   const info = await fcl.query({

bindings/testdata/TestJSGenMinScript.golden

@@ -7,11 +7,10 @@
 import * as fcl from "@onflow/fcl"
 import flixTemplate from "./min.template.json"
 
-
 /**
 *
 * @param {Object} Parameters - parameters for the cadence
-* @param { Array<string> } Parameters.numbers - : Int
+* @param {Array<string>} Parameters.numbers - : Int
 */
 export async function request({numbers}) {
   const info = await fcl.query({

bindings/testdata/TestJSGenNoParamsScript.golden

@@ -0,0 +1,27 @@
+`/**
+    This binding file was auto generated based on FLIX template v1.0.0.
+    Changes to this file might get overwritten.
+    Note fcl version 1.3.0 or higher is required to use templates.
+**/
+
+import * as fcl from "@onflow/fcl"
+import flixTemplate from "./min.template.json"
+
+/**
+*
+* No parameters needed.
+*/
+export async function request() {
+  const info = await fcl.query({
+    template: flixTemplate,
+
+  });
+
+  return info
+}
+
+
+
+
+
+`

bindings/testdata/TestJSGenScript.golden

@@ -7,12 +7,11 @@
 import * as fcl from "@onflow/fcl"
 import flixTemplate from "./multiply_two_integers.template.json"
 
-
 /**
 * Multiply two numbers to another
 * @param {Object} Parameters - parameters for the cadence
-* @param { string } Parameters.x - number to be multiplied: Int
-* @param { string } Parameters.y - second number to be multiplied: Int
+* @param {string} Parameters.x - number to be multiplied: Int
+* @param {string} Parameters.y - second number to be multiplied: Int
 */
 export async function multiplyTwoIntegers({x, y}) {
   const info = await fcl.query({

bindings/testdata/TestJSGenTransaction.golden

@@ -7,12 +7,11 @@
 import * as fcl from "@onflow/fcl"
 import flixTemplate from "./transfer_token.json"
 
-
 /**
 * Transfer tokens from one account to another
 * @param {Object} Parameters - parameters for the cadence
-* @param { string } Parameters.amount - The amount of FLOW tokens to send: UFix64
-* @param { string } Parameters.to - The Flow account the tokens will go to: Address
+* @param {string} Parameters.amount - The amount of FLOW tokens to send: UFix64
+* @param {string} Parameters.to - The Flow account the tokens will go to: Address
 * @returns {Promise<string>} - returns a promise which resolves to the transaction id
 */
 export async function transferTokens({amount, to}) {

generator/core_contracts.go

@@ -0,0 +1,101 @@
+package generator
+
+import (
+	"github.com/onflow/flixkit-go"
+)
+
+func getDefaultCoreContracts() flixkit.Contracts {
+	return flixkit.Contracts{
+		"FungibleToken": {
+			"mainnet": {
+				Address:        "0xf233dcee88fe0abe",
+				FqAddress:      "A.0xf233dcee88fe0abe.FungibleToken",
+				Contract:       "FungibleToken",
+				Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+				PinBlockHeight: 34166296,
+			},
+			"testnet": {
+				Address:        "0x9a0766d93b6608b7",
+				FqAddress:      "A.0x9a0766d93b6608b7.FungibleToken",
+				Contract:       "FungibleToken",
+				Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+				PinBlockHeight: 74776482,
+			},
+		},
+		"NonFungibleToken": {
+			"mainnet": {
+				Address:        "0x1d7e57aa55817448",
+				FqAddress:      "A.0x1d7e57aa55817448.NonFungibleToken",
+				Contract:       "NonFungibleToken",
+				Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+				PinBlockHeight: 47509012,
+			},
+			"testnet": {
+				Address:        "0x631e88ae7f1d7c20",
+				FqAddress:      "A.0x631e88ae7f1d7c20.NonFungibleToken",
+				Contract:       "NonFungibleToken",
+				Pin:            "83c9e3d61d3b5ebf24356a9f17b5b57b12d6d56547abc73e05f820a0ae7d9cf5",
+				PinBlockHeight: 95808228,
+			},
+		},
+		"MetadataViews": {
+			"mainnet": {
+				Address:        "0x1d7e57aa55817448",
+				FqAddress:      "A.0x1d7e57aa55817448.NonFungibleToken",
+				Contract:       "MetadataViews",
+				Pin:            "ba061d95016d5506e9f5d1afda15d82eb066aa8b0552e8b26dc7950fa5714d51",
+				PinBlockHeight: 47487348,
+			},
+			"testnet": {
+				Address:        "0x631e88ae7f1d7c20",
+				FqAddress:      "A.0x631e88ae7f1d7c20.NonFungibleToken",
+				Contract:       "MetadataViews",
+				Pin:            "ba061d95016d5506e9f5d1afda15d82eb066aa8b0552e8b26dc7950fa5714d51",
+				PinBlockHeight: 95782517,
+			},
+		},
+		"FlowToken": {
+			"mainnet": {
+				Address:        "0x1654653399040a61",
+				FqAddress:      "A.0x1654653399040a61.FlowToken",
+				Contract:       "FlowToken",
+				Pin:            "0326c320322c4e8dde768ba2975c384184fb7e41765c2c87e79a2040bfc71be8",
+				PinBlockHeight: 47509023,
+			},
+			"testnet": {
+				Address:        "0x7e60df042a9c0868",
+				FqAddress:      "A.0x7e60df042a9c0868.FlowToken",
+				Contract:       "FlowToken",
+				Pin:            "0326c320322c4e8dde768ba2975c384184fb7e41765c2c87e79a2040bfc71be8",
+				PinBlockHeight: 95808240,
+			},
+		},
+	}
+}
+
+// GetContractInformation returns the contract information for a given contract name
+// todo: this information should be generated so it can be updated easily
+// todo: this should be moved to a separate package or maybe this inforation already exists somewhere else
+func getContractInformation(contractName string, deployedContracts []flixkit.Contracts, coreContracts flixkit.Contracts) flixkit.Networks {
+	contracts := make(flixkit.Contracts)
+
+	for contractName, network := range coreContracts {
+		contracts[contractName] = network
+	}
+
+	// add deployed contracts to contracts map
+	for _, contract := range deployedContracts {
+		for contractName, network := range contract {
+			contracts[contractName] = network
+		}
+	}
+
+	// To lookup a specific entry:
+	_, exists := contracts[contractName]
+	if exists {
+		return contracts[contractName]
+	}
+
+	return nil
+
+}

generator/core_contracts_test.go

@@ -0,0 +1,31 @@
+package generator
+
+import "testing"
+
+func TestContractExist(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  string
+		output bool
+	}{
+		{
+			name:   "existing contract",
+			input:  "FungibleToken",
+			output: true,
+		},
+		{
+			name:   "non-existing contract",
+			input:  "NonExistingContract",
+			output: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := getContractInformation(tt.input, nil, getDefaultCoreContracts())
+			if tt.output && got == nil {
+				t.Errorf("ContractExist() got = %v, want %v", got, tt.output)
+			}
+		})
+	}
+}