# Contract Class

Every chaincode program contains one or more smart contracts. Each smart contract must extend the **Contract** class, whose methods are called in response to received transactions. The **Contract** class is declared in the [**fabric-contract-api**](https://www.npmjs.com/package/fabric-contract-api) **npm** package:

```typescript
export class Contract {
   constructor(name?: string); 

   static _isContract(): boolean; 

   beforeTransaction(ctx: Context): Promise<void>;
   afterTransaction(ctx: Context, result: any): Promise<void>; 

   unknownTransaction(ctx: Context): Promise<void>; 

   createContext(): Context;
   getName(): string;
}
```

Within each smart contract instance, it is possible to have as many functions as necessary. These can either be a transaction function that can be called by applications, or a helper function prefixed by an underscore. If the function name is prefixed by an underscore, the function is "unknown" for external callers.

Every transaction function must take a transaction context as the first parameter. A transaction context object is represented by the **Context** class or its inheritors and provides two crucial objects to interact with the ledger and transaction proposal data.

* **stub: ChaincodeStub** encapsulates API to interact with the world state, private collections, transaction proposal, etc.
* **clientIdentity: ClientIdentity** provides details about the transaction creator.

The **Context** object is created by **Contract.createContext** function which can be overridden to extend information provided by the transaction context.

The **Contract** class also provides default implementations of *Before*, *After*, and *Unknown* transaction handlers. Transaction handlers are optional functions that receive control before or after a transaction, or in case a request is made to invoke a transaction not defined in a smart contract. They can be used if specific actions should be performed around each transaction, such as caller identity checks.

Considering the above, we can implement a dummy contract, that does nothing valuable, but can be operated in the network:

{% code title="simpleContract.js" %}

```typescript
'use strict'; 

const { Contract } = require('fabric-contract-api'); 

class SimpleContract extends Contract {
} 

module.exports = SimpleContract;
```

{% endcode %}

Let’s save this chaincode in a **simpleContract.js** file into the **simple\_chaincode/lib** folder.
