# Getting Started with Aut ABI types & Contract proxy

A library which generates typescript types based on abis.

By providing an ExampleContract.abi.ts inside abis folder & running npm build it will:

- Create a folder in the ProviderFactory
- Generate aut-contract-functions.ts which includes all functions & emit events definitions in [ExampleContractFunctions & ExampleContractEventType]
- Generate index.ts which exports the provider as follows:

```ts
const Web3ExampleContractProvider = async (
  addressOrName: string,
  extras?: Partial<Web3ProviderExtras<ExampleContractEventType>>
) => {
  return Web3ContractProvider<ExampleContractEventType, ExampleContractFunctions>(
    addressOrName,
    ExampleABI,
    extras as Web3ProviderExtras<ExampleContractEventType>
  );
};

export { Web3ExampleContractProvider, ExampleContractEventType, ExampleContractFunctions };
```

... additionally there is a Contract Proxy which based on the type provided as seen in the Web3ExampleContractProvider it will provide code completion defined in the ExampleContractFunctions

It also waits for event transactions for example:

```ts
const contract = await Web3ExampleContractProvider(address, {
    event: ExampleContractEventType.SomeEvent
});
```

if the event provide matches the events returned in the transaction the it will **await tx.wait()** as well

This way we reduce a lot boilerplate code.

## How to use

### Generate types

```cmd
npm run build
```

### Install dependency

```cmd
npm install @aut-labs-private/abi-types
```

Example executing transaction with event

```ts
import { ExampleContractEventType, Web3ExampleContractProvider } from "@aut-labs-private/abi-types";

const address = 0x00000...;
(async () => {
  const contract = await Web3ExampleContractProvider(address, {
    event: ExampleContractEventType.SomeEvent,
  });
  try {
    await contract.someFunction();
  } catch (error) {
    console.log(error);
  }
})();
```

Example executing transaction without event

```ts
import { Web3AutIDProvider } from "@aut-labs-private/abi-types";

const address = 0x00000...;
(async () => {
  const contract = await Web3ExampleContractProvider(address);
  try {
    await contract.someFunction();
  } catch (error) {
    console.log(error);
  }
})();
```

## Extras

### Provider Config Parameters

```ts
export interface Web3ProviderExtras<EventTypes> {
  event: EventTypes;
  signer: () => Promise<ethers.providers.JsonRpcSigner>;
  provider: () => Promise<ethers.providers.Web3Provider>;
  beforeRequest: Function;
  afterRequest: Function;
  transactionState: (
    state: "started" | "rejected" | "waiting" | "done",
    ...args: any
  ) => void;
}
```

**NOTE** - By default it creates a provider from ethers.js which will deprectated and removed in the future

```ts
const provider = new ethers.providers.Web3Provider(window.ethereum);
```

Its recommended that you provide your own signer as follows:

```ts
import { ExampleContractEventType, Web3ExampleContractProvider } from "@aut-labs-private/abi-types";
import { ethers } from "ethers";

const address = 0x00000...;
(async () => {
  const provider = new ethers.providers.Web3Provider(window.ethereum);
  const signer = provider.getSigner();
  const contract = await Web3ExampleContractProvider(address, {
    event: ExampleContractEventType.SomeEvent,
    signer: async () => signer
  });
  try {
    await contract.someFunction();
  } catch (error) {
    console.log(error);
  }
})();
```


## Available Web3 Providers

- Web3AutIDProvider
- Web3CommunityCallProvider
- Web3DAOExpanderFactoryProvider
- Web3DAOExpanderProvider
- Web3DAOExpanderRegistryProvider
- Web3InteractionsProvider
- Web3ManifestoProvider
- Web3PollsProvider
- Web3TasksProvider