import {getAccountAddress} from "@onflow/flow-js-testing"

const main = async () => {
  const Alice = await getAccountAddress("Alice")
  console.log({Alice})
}

main()

import path from "path";
import { init, emulator, deployContractByName } from "@onflow/flow-js-testing";

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence");

  await init(basePath);
  await emulator.start();

  // We will deploy our contract to the address that corresponds to "Alice" alias
  const to = await getAccountAddress("Alice");

  // We assume there is a file on "../cadence/contracts/Wallet.cdc" path
  const name = "Wallet";

  // Arguments will be processed and type matched in the same order as they are specified
  // inside of a contract template
  const args = [1337, "Hello", { name: "Alice" }];

  const [deploymentResult, err] = await deployContractByName({ to, name });
  console.log({ deploymentResult }, { err });
  }

  await emulator.stop();
};

main();

import path from "path"
import {
  init,
  emulator,
  getAccountAddress,
  deployContract,
  executeScript,
} from "@onflow/flow-js-testing"
;(async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)
  await emulator.start()

  // We can specify, which account will hold the contract
  const to = await getAccountAddress("Alice")

  const name = "Wallet"
  const code = `
        pub contract Wallet{
            pub let balance: UInt
            init(balance: UInt){
              self.balance = balance
            }
        }
    `
  const args = [1337]

  await deployContract({to, name, code, args})

  const [balance, err] = await executeScript({
    code: `
      import Wallet from 0x01
      pub fun main(): UInt{
        return Wallet.balance
      }
    `,
  })
  console.log({balance}, {err})

  await emulator.stop()
})()

import path from "path"
import {init, emulator, deployContractByName, getContractAddress} from "../src"
;(async () => {
  const basePath = path.resolve(__dirname, "./cadence")

  await init(basePath)
  await emulator.start()

  // if we omit "to" it will be deployed to Service Account
  // but let's pretend we don't know where it will be deployed :)
  await deployContractByName({name: "Hello"})

  const contractAddress = await getContractAddress("Hello")
  console.log({contractAddress})

  await emulator.stop()
})()

import path from "path"
import {emulator, init} from "../src"
;(async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)

  // Start emulator instance on port 8080
  await emulator.start()
  console.log("emulator is working")

  // Stop running emulator
  await emulator.stop()
  console.log("emulator has been stopped")
})()

import {emulator, init} from "@onflow/flow-js-testing"

describe("test setup", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "../cadence")

    await init(basePath)
    await emulator.start()
  })

  // Stop emulator, so it could be restarted
  afterEach(async () => {
    await emulator.stop()
  })
})

import path from "path"
import {emulator, init} from "@onflow/flow-js-testing"

describe("test setup", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "../cadence")

    await init(basePath)
    await emulator.start()
  })

  // Stop emulator, so it could be restarted
  afterEach(async () => {
    await emulator.stop()
  })

  test("basic test", async () => {
    // Turn on logging from begining
    emulator.setLogging(true)
    // some asserts and interactions

    // Turn off logging for later calls
    emulator.setLogging(false)
    // more asserts and interactions here
  })
})

import {
  init,
  emulator,
  getAccountAddress,
  getFlowBalance,
} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)
  await emulator.start()

  const Alice = await getAccountAddress("Alice")

  const [result, error] = await getFlowBalance(Alice)
  console.log({result}, {error})

  await emulator.stop()
}

main()

import path from "path"
import {
  init,
  emulator,
  getAccountAddress,
  getFlowBalance,
  mintFlow,
} from "../src"
;(async () => {
  const basePath = path.resolve(__dirname, "./cadence")

  await init(basePath)
  await emulator.start()

  // Get address for account with alias "Alice"
  const Alice = await getAccountAddress("Alice")

  // Get initial balance
  const [initialBalance] = await getFlowBalance(Alice)
  console.log(initialBalance)

  // Add 1.0 FLOW tokens to Alice account
  await mintFlow(Alice, "1.0")

  // Check updated balance
  const updatedBalance = await getFlowBalance(Alice)
  console.log({updatedBalance})

  await emulator.stop()
})()

import path from "path"
import {init} from "@onflow/flow-js-testing"

describe("test setup", () => {
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "../cadence")
    await init(basePath)

    // alternatively you can pass specific port
    // await init(basePath, {port: 8085})
  })
})

import path from "path"
import {init, emulator, getBlockOffset} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  init(basePath)
  await emulator.start()

  const [blockOffset, err] = await getBlockOffset()
  console.log({blockOffset}, {err})

  await emulator.stop()
}

main()

import path from "path"
import {
  init,
  emulator,
  executeScript,
  getBlockOffset,
  setBlockOffset,
  builtInMethods,
  sendTransaction,
} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  init(basePath)
  await emulator.start()

  // Offset current block height by 42
  await setBlockOffset(42)

  const [blockOffset, err] = await getBlockOffset()
  console.log({blockOffset}, {err})

  // "getCurrentBlock().height" in your Cadence code will be replaced by Manager to a mocked value
  const code = `
    pub fun main(): UInt64 {
      return getCurrentBlock().height
    }
  `

  // "transformers" field expects array of functions to operate update the code.
  // We will pass single operator "builtInMethods" provided by the framework
  const transformers = [builtInMethods]
  const [result, error] = await executeScript({code, transformers})
  console.log({result}, {error})

  await emulator.stop()
}

main()

import path from "path"
import {init, emulator, getTimestampOffset} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  init(basePath)
  await emulator.start()

  const [timestampOffset, err] = await getTimestampOffset()
  console.log({timestampOffset}, {err})

  await emulator.stop()
}

main()

import path from "path"
import {
  init,
  emulator,
  executeScript,
  getTimestampOffset,
  setTimestampOffset,
  builtInMethods,
  sendTransaction,
} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  init(basePath)
  await emulator.start()

  // Offset current timestamp by 10s
  await setTimestampOffset(10)

  const [timestampOffset, err] = await getTimestampOffset()
  console.log({timestampOffset}, {err})

  // "getCurrentBlock().timestamp" in your Cadence code will be replaced by Manager to a mocked value
  const code = `
    pub fun main(): UInt64 {
      return getCurrentBlock().timestamp
    }
  `

  // "transformers" field expects array of functions to operate update the code.
  // We will pass single operator "builtInMethods" provided by the framework
  const transformers = [builtInMethods]
  const [result, error] = await executeScript({code, transformers})
  console.log({result}, {error})

  await emulator.stop()
}

main()

import path from "path"
import {
  init,
  emulator,
  shallPass,
  sendTransaction,
  getAccountAddress,
} from "js-testing-framework"

// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)

describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })

  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })

  test("basic transaction", async () => {
    const code = `
      transaction(message: String){
        prepare(singer: AuthAccount){
          log(message)
        }
      }
    `
    const Alice = await getAccountAddress("Alice")
    const signers = [Alice]
    const args = ["Hello, Cadence"]

    const [txResult, error] = await shallPass(
      sendTransaction({
        code,
        signers,
        args,
      })
    )

    // Transaction result will hold status, events and error message
    console.log({txResult}, {error})
  })
})

import path from "path"
import {
  init,
  emulator,
  shallPass,
  sendTransaction,
  getAccountAddress,
} from "js-testing-framework"

// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)

describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })

  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })

  test("basic transaction", async () => {
    const code = `
      transaction(message: String){
        prepare(singer: AuthAccount){
          panic("You shall not pass!")
        }
      }
    `
    const Alice = await getAccountAddress("Alice")
    const signers = [Alice]
    const args = ["Hello, Cadence"]

    const [txResult, error] = await shallRevert(
      sendTransaction({
        code,
        signers,
        args,
      })
    )

    // Transaction result will hold status, events and error message
    console.log({txResult}, {error})
  })
})

import path from "path"
import {init, emulator, shallPass, executeScript} from "js-testing-framework"

// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)

describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })

  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })

  test("basic script", async () => {
    const code = `
      pub fun main():Int{
        return 42
      }
    `

    const [result, error] = await shallResolve(
      executeScript({
        code,
      })
    )

    expect(result).toBe(42)
    expect(error).toBe(null)
  })
})

import path from "path"
import {init, emulator, executeScript} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  // Init framework
  init(basePath)
  // Start emulator
  await emulator.start()

  // Define code and arguments we want to pass
  const code = `
    pub fun main(message: String): Int{
      log(message)

      return 42
    }
  `
  const args = ["Hello, from Cadence"]

  const [result, error] = await executeScript({code, args})
  console.log({result}, {error})

  // Stop emulator instance
  await emulator.stop()
}

main()

import path from "path"
import {init, emulator, executeScript} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  // Init framework
  init(basePath)
  // Start emulator
  await emulator.start()

  // Define arguments we want to pass
  const args = ["Hello, from Cadence"]

  // We assume there is a file `scripts/log-message.cdc` under base path
  const [result, error] = await executeScript("log-message", args)
  console.log({result}, {error})

  await emulator.stop()
}

main()

import path from "path"
import {
  init,
  emulator,
  sendTransaction,
  getAccountAddress,
} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  // Init framework
  await init(basePath)
  // Start emulator
  await emulator.start()

  // Define code and arguments we want to pass
  const code = `
    transaction(message: String){
      prepare(signer: AuthAccount){
        log(message)
      }
    }
  `
  const args = ["Hello, from Cadence"]
  const Alice = await getAccountAddress("Alice")
  const signers = [Alice]

  const [tx, error] = await sendTransaction({code, args, signers})
  console.log(tx, error)

  // Stop emulator instance
  await emulator.stop()
}

main()

import path from "path"
import {init, emulator, sendTransaction} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  // Init framework
  await init(basePath)
  // Start emulator
  await emulator.start()

  // Define arguments we want to pass
  const args = ["Hello, Cadence"]

  const [tx, error] = await sendTransaction("log-message", [], args)
  console.log(tx, error)
}

main()

import path from "path"
import {init, getTemplate} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")
  await init(basePath)

  const template = await getTemplate("../cadence/scripts/get-name.cdc")
  console.log({template})
}

main()

import path from "path"
import {init, emulator, getContractCode} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)
  await emulator.start()

  // Let's assume we need to import MessageContract
  await deployContractByName({name: "MessageContract"})
  const [MessageContract] = await getContractAddress("MessageContract")
  const addressMap = {MessageContract}

  const contractTemplate = await getContractCode("HelloWorld", {
    MessageContract,
  })
  console.log({contractTemplate})

  await emulator.stop()
}

main()

import path from "path"
import {init, emulator, getTransactionCode} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)
  await emulator.start()

  // Let's assume we need to import MessageContract
  await deployContractByName({name: "MessageContract"})
  const [MessageContract] = await getContractAddress("MessageContract")
  const addressMap = {MessageContract}

  const txTemplate = await getTransactionCode({
    name: "set-message",
    addressMap,
  })
  console.log({txTemplate})

  await emulator.stop()
}

main()

import path from "path"
import {init, emulator, getScriptCode} from "@onflow/flow-js-testing"

const main = async () => {
  const basePath = path.resolve(__dirname, "../cadence")

  await init(basePath)
  await emulator.start()

  // Let's assume we need to import MessageContract
  await deployContractByName({name: "MessageContract"})
  const [MessageContract] = await getContractAddress("MessageContract")
  const addressMap = {MessageContract}

  const scriptTemplate = await getScriptCode({
    name: "get-message",
    addressMap,
  })

  console.log({scriptTemplate})
  await emulator.stop()
}

main()

const addressMap = {
  Messanger: "0x01cf0e2f2f715450",
  Logger: "0x179b6b1cb6755e31",
}

const ix = async () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(1337)
    })
  }, 500)
}

const replaceAddress = async code => {
  const modified = code.replace(
    /import\s+FungibleToken\s+from\s+0xFUNGIBLETOKEN/,
    "import FungibleToken from 0xee82856bf20e2aa6"
  )

  return modified
}

import {pubFlowKey} from "@onflow/flow-js-testing"

const pubKey = await pubFlowKey({
  privateKey: ...,
  hashAlgorithm: ...,
  signatureAlgorithm: ...,
  weight: ...
})

import {isAddress} from "@onflow/flow-js-testing"

const badAddr = "0xqrtyff"
console.log(isAddress(badAddr)) // false

const goodAddrWithPrefix = "0xf8d6e0586b0a20c1"
console.log(isAddress(goodAddrWithPrefix)) // true

const goodAddrSansPrefix = "f8d6e0586b0a20c1"
console.log(isAddress(goodAddrSansPrefix)) // true