contract;
 
abi DemoContract {
    fn return_input(input: u64) -> u64;
}
 
impl DemoContract for Contract {
    fn return_input(input: u64) -> u64 {
        input
    }
}

import { generateTestWallet } from '@fuel-ts/account/test-utils';
import { safeExec } from '@fuel-ts/errors/test-utils';
import { ContractFactory, Provider, toHex, Wallet, FUEL_NETWORK_URL, Address } from 'fuels';
 
import storageSlots from '../contract/out/release/demo-contract-storage_slots.json';
 
import { DemoContractAbi__factory } from './contract-types';
import bytecode from './contract-types/DemoContractAbi.hex';
import type { PredicateAbiInputs } from './predicate-types';
import { PredicateAbi__factory } from './predicate-types';
import { ScriptAbi__factory } from './script-types';
 
let baseAssetId: string;
 
/**
 * @group node
 */
describe('ExampleContract', () => {
  beforeAll(async () => {
    const provider = await Provider.create(FUEL_NETWORK_URL);
    baseAssetId = provider.getBaseAssetId();
  });
  it('with imported storage slots', async () => {
    const provider = await Provider.create(FUEL_NETWORK_URL);
    const wallet = await generateTestWallet(provider, [[500_000, baseAssetId]]);
 
    import storageSlots from './contract/out/debug/demo-contract-storage_slots.json';
 
    const contract = await DemoContractAbi__factory.deployContract(bytecode, wallet, {
      storageSlots,
    });
 
    expect(contract.id).toBeTruthy();
  });
  it('should return the input', async () => {
    const provider = await Provider.create(FUEL_NETWORK_URL);
    const wallet = await generateTestWallet(provider, [[500_000, baseAssetId]]);
 
    // Deploy
    const factory = new ContractFactory(bytecode, DemoContractAbi__factory.abi, wallet);
    const contract = await factory.deployContract();
    const contractId = contract.id;
 
    // Call
    const { value } = await contract.functions.return_input(1337).call();
 
    // Assert
    expect(value.toHex()).toEqual(toHex(1337));
 
    // You can also make a call using the factory
    import { DemoContractAbi__factory } from './types';
 
    const contractInstance = DemoContractAbi__factory.connect(contractId, wallet);
    const { value: v2 } = await contractInstance.functions.return_input(1337).call();
    expect(v2.toHex()).toBe(toHex(1337));
  });
 
  it('deployContract method', async () => {
    const provider = await Provider.create(FUEL_NETWORK_URL);
    const wallet = await generateTestWallet(provider, [[500_000, baseAssetId]]);
 
    import { DemoContractAbi__factory } from './types';
    import bytecode from './types/DemoContractAbi.hex';
 
    // Deploy
    const contract = await DemoContractAbi__factory.deployContract(bytecode, wallet);
 
 
    // Call
    const { value } = await contract.functions.return_input(1337).call();
 
    // Assert
    expect(value.toHex()).toEqual(toHex(1337));
  });
});