# IPublicLockV12



> The PublicLock Interface





## Methods

### DEFAULT_ADMIN_ROLE

```solidity
function DEFAULT_ADMIN_ROLE() external view returns (bytes32 role)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |

### KEY_GRANTER_ROLE

```solidity
function KEY_GRANTER_ROLE() external view returns (bytes32 role)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |

### LOCK_MANAGER_ROLE

```solidity
function LOCK_MANAGER_ROLE() external view returns (bytes32 role)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |

### addKeyGranter

```solidity
function addKeyGranter(address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

### addLockManager

```solidity
function addLockManager(address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

### approve

```solidity
function approve(address to, uint256 tokenId) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| to | address | undefined |
| tokenId | uint256 | undefined |

### balanceOf

```solidity
function balanceOf(address _owner) external view returns (uint256 balance)
```

In the specific case of a Lock, `balanceOf` returns only the tokens with a valid expiration timerange



#### Parameters

| Name | Type | Description |
|---|---|---|
| _owner | address | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| balance | uint256 | The number of valid keys owned by `_keyOwner` |

### burn

```solidity
function burn(uint256 _tokenId) external nonpayable
```

Deactivate an existing keythe key will be expired and ownership records will be destroyed



#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the id of token to burn |

### cancelAndRefund

```solidity
function cancelAndRefund(uint256 _tokenId) external nonpayable
```



*allows the key manager to expire a given tokenId and send a refund to the keyOwner based on the amount of time remaining.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The id of the key to cancel. |

### expirationDuration

```solidity
function expirationDuration() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### expireAndRefundFor

```solidity
function expireAndRefundFor(uint256 _tokenId, uint256 _amount) external nonpayable
```



*Invoked by a Lock manager to expire the user&#39;s key and perform a refund and cancellation of the keyThrows if called by other than a Lock managerThrows if _keyOwner does not have a valid key*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The key id we wish to refund to |
| _amount | uint256 | The amount to refund to the key-owner |

### extend

```solidity
function extend(uint256 _value, uint256 _tokenId, address _referrer, bytes _data) external payable
```



*Extend functionThrows if lock is disabled or key does not exist for _recipient. Throws if _recipient == address(0).*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _value | uint256 | the number of tokens to pay for this purchase &gt;= the current keyPrice - any applicable discount (_value is ignored when using ETH) |
| _tokenId | uint256 | the id of the key to extend |
| _referrer | address | address of the user making the referral |
| _data | bytes | arbitrary data populated by the front-end which initiated the sale |

### freeTrialLength

```solidity
function freeTrialLength() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### gasRefundValue

```solidity
function gasRefundValue() external view returns (uint256 _gasRefundValue)
```

_gasRefundValue price in wei or token in smallest price unit

*Returns the value/rpice to be refunded to the sender on purchase*


#### Returns

| Name | Type | Description |
|---|---|---|
| _gasRefundValue | uint256 | undefined |

### getApproved

```solidity
function getApproved(uint256 _tokenId) external view returns (address operator)
```

Get the approved address for a single NFT

*Throws if `_tokenId` is not a valid NFT.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The NFT to find the approved address for |

#### Returns

| Name | Type | Description |
|---|---|---|
| operator | address | The approved address for this NFT, or the zero address if there is none |

### getCancelAndRefundValue

```solidity
function getCancelAndRefundValue(uint256 _tokenId) external view returns (uint256 refund)
```

Due to the time required to mine a tx, the actual refund amount will be lower than what the user reads from this call.

*Determines how much of a refund a key owner would receive if they issued*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the id of the token to get the refund value for. |

#### Returns

| Name | Type | Description |
|---|---|---|
| refund | uint256 | the amount of tokens refunded |

### getHasValidKey

```solidity
function getHasValidKey(address _user) external view returns (bool)
```

Checks if the user has a non-expired key.



#### Parameters

| Name | Type | Description |
|---|---|---|
| _user | address | The address of the key owner |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### getRoleAdmin

```solidity
function getRoleAdmin(bytes32 role) external view returns (bytes32)
```

Innherited from Open Zeppelin AccessControl.sol



#### Parameters

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bytes32 | undefined |

### getTransferFee

```solidity
function getTransferFee(uint256 _tokenId, uint256 _time) external view returns (uint256)
```

Determines how much of a fee would need to be paid in order to transfer to another account.  This is pro-rated so the fee goes down overtime.

*Throws if _tokenId does not have a valid key*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The id of the key check the transfer fee for. |
| _time | uint256 | The amount of time to calculate the fee for. |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | The transfer fee in seconds. |

### grantKeyExtension

```solidity
function grantKeyExtension(uint256 _tokenId, uint256 _duration) external nonpayable
```

Allows the Lock owner to extend an existing keys with no charge.

*set `_duration` to 0 to use the default duration of the lock*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The id of the token to extend |
| _duration | uint256 | The duration in secondes to add ot the key |

### grantKeys

```solidity
function grantKeys(address[] _recipients, uint256[] _expirationTimestamps, address[] _keyManagers) external nonpayable returns (uint256[])
```

Allows a Lock manager to give a collection of users a key with no charge. Each key may be assigned a different expiration date.

*Throws if called by other than a Lock manager*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _recipients | address[] | An array of receiving addresses |
| _expirationTimestamps | uint256[] | An array of expiration Timestamps for the keys being granted |
| _keyManagers | address[] | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256[] | the ids of the granted tokens |

### grantRole

```solidity
function grantRole(bytes32 role, address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |
| account | address | undefined |

### hasRole

```solidity
function hasRole(bytes32 role, address account) external view returns (bool)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |
| account | address | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### initialize

```solidity
function initialize(address _lockCreator, uint256 _expirationDuration, address _tokenAddress, uint256 _keyPrice, uint256 _maxNumberOfKeys, string _lockName) external nonpayable
```

Functions



#### Parameters

| Name | Type | Description |
|---|---|---|
| _lockCreator | address | undefined |
| _expirationDuration | uint256 | undefined |
| _tokenAddress | address | undefined |
| _keyPrice | uint256 | undefined |
| _maxNumberOfKeys | uint256 | undefined |
| _lockName | string | undefined |

### isApprovedForAll

```solidity
function isApprovedForAll(address _owner, address _operator) external view returns (bool)
```



*Tells whether an operator is approved by a given keyManager*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _owner | address | owner address which you want to query the approval of |
| _operator | address | operator address which you want to query the approval of |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | bool whether the given operator is approved by the given owner |

### isKeyGranter

```solidity
function isKeyGranter(address account) external view returns (bool)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### isLockManager

```solidity
function isLockManager(address account) external view returns (bool)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### isOwner

```solidity
function isOwner(address account) external view returns (bool isOwner)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| isOwner | bool | undefined |

### isValidKey

```solidity
function isValidKey(uint256 _tokenId) external view returns (bool)
```

Check if a certain key is validthis makes use of the onValidKeyHook if it is set



#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the id of the key to check validity |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### keyExpirationTimestampFor

```solidity
function keyExpirationTimestampFor(uint256 _tokenId) external view returns (uint256 timestamp)
```



*Returns the key&#39;s ExpirationTimestamp field for a given owner.Returns 0 if the owner has never owned a key for this lock*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the id of the key |

#### Returns

| Name | Type | Description |
|---|---|---|
| timestamp | uint256 | undefined |

### keyManagerOf

```solidity
function keyManagerOf(uint256) external view returns (address)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | address | undefined |

### keyPrice

```solidity
function keyPrice() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### lendKey

```solidity
function lendKey(address from, address to, uint256 tokenId) external nonpayable
```

Lending a key allows you to transfer the token while retaining the ownerships right by setting yourself as a key manager first.This function can only be called by 1) the key owner when no key manager is set or 2) the key manager. After calling the function, the `_recipent` will be the new owner, and the sender of the tx will become the key manager.



#### Parameters

| Name | Type | Description |
|---|---|---|
| from | address | the owner of token to transfer |
| to | address | the address that will receive the token |
| tokenId | uint256 | the id of the token |

### maxKeysPerAddress

```solidity
function maxKeysPerAddress() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | the maximum number of key allowed for a single address |

### maxNumberOfKeys

```solidity
function maxNumberOfKeys() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### mergeKeys

```solidity
function mergeKeys(uint256 _tokenIdFrom, uint256 _tokenIdTo, uint256 _amount) external nonpayable
```

Merge existing keys



#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenIdFrom | uint256 | the id of the token to substract time from |
| _tokenIdTo | uint256 | the id of the destination token  to add time |
| _amount | uint256 | the amount of time to transfer (in seconds) |

### migrate

```solidity
function migrate(bytes _calldata) external nonpayable
```

Migrate data from the previous single owner =&gt; key mapping to the new data structure w multiple tokens.

*when all record schemas are sucessfully upgraded, this function will update the `schemaVersion` variable to the latest/current lock version*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _calldata | bytes | an ABI-encoded representation of the params (v10: the number of records to migrate as `uint`) |

### name

```solidity
function name() external view returns (string _name)
```

A descriptive name for a collection of NFTs in this contract




#### Returns

| Name | Type | Description |
|---|---|---|
| _name | string | undefined |

### numberOfOwners

```solidity
function numberOfOwners() external view returns (uint256)
```

Public function which returns the total number of unique owners (both expired and valid).  This may be larger than totalSupply.




#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### onKeyCancelHook

```solidity
function onKeyCancelHook() external view returns (address hookAddress)
```

Returns the address of the `onKeyCancelHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | address of the hook |

### onKeyExtendHook

```solidity
function onKeyExtendHook() external view returns (address hookAddress)
```

Returns the address of the `onKeyExtendHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | the address ok the hook |

### onKeyGrantHook

```solidity
function onKeyGrantHook() external view returns (address hookAddress)
```

Returns the address of the `onKeyGrantHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | the address ok the hook |

### onKeyPurchaseHook

```solidity
function onKeyPurchaseHook() external view returns (address hookAddress)
```

Returns the address of the `onKeyPurchaseHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | address of the hook |

### onKeyTransferHook

```solidity
function onKeyTransferHook() external view returns (address hookAddress)
```

Returns the address of the `onKeyTransferHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | address of the hook |

### onTokenURIHook

```solidity
function onTokenURIHook() external view returns (address hookAddress)
```

Returns the address of the `onTokenURIHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | address of the hook |

### onValidKeyHook

```solidity
function onValidKeyHook() external view returns (address hookAddress)
```

Returns the address of the `onValidKeyHook` hook.




#### Returns

| Name | Type | Description |
|---|---|---|
| hookAddress | address | address of the hook |

### owner

```solidity
function owner() external view returns (address owner)
```

`owner()` is provided as an helper to mimick the `Ownable` contract ABI. The `Ownable` logic is used by many 3rd party services to determine contract ownership - e.g. who is allowed to edit metadata on Opensea.This logic is NOT used internally by the Unlock Protocol and is made available only as a convenience helper.




#### Returns

| Name | Type | Description |
|---|---|---|
| owner | address | undefined |

### ownerOf

```solidity
function ownerOf(uint256 tokenId) external view returns (address _owner)
```



*Returns the owner of the NFT specified by `tokenId`.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| tokenId | uint256 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _owner | address | undefined |

### publicLockVersion

```solidity
function publicLockVersion() external pure returns (uint16)
```

The version number of the current implementation on this network.




#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint16 | The current version number. |

### purchase

```solidity
function purchase(uint256[] _values, address[] _recipients, address[] _referrers, address[] _keyManagers, bytes[] _data) external payable returns (uint256[] tokenIds)
```

when called for an existing and non-expired key, the `_keyManager` param will be ignored

*Purchase functionSetting _value to keyPrice exactly doubles as a security feature. That way if the lock owner increases the price while my transaction is pending I can&#39;t be charged more than I expected (only applicable to ERC-20 when more than keyPrice is approved for spending).*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _values | uint256[] | array of tokens amount to pay for this purchase &gt;= the current keyPrice - any applicable discount (_values is ignored when using ETH) |
| _recipients | address[] | array of addresses of the recipients of the purchased key |
| _referrers | address[] | array of addresses of the users making the referral |
| _keyManagers | address[] | optional array of addresses to grant managing rights to a specific address on creation |
| _data | bytes[] | array of arbitrary data populated by the front-end which initiated the sale |

#### Returns

| Name | Type | Description |
|---|---|---|
| tokenIds | uint256[] | the ids of the created tokens |

### purchasePriceFor

```solidity
function purchasePriceFor(address _recipient, address _referrer, bytes _data) external view returns (uint256)
```

returns the minimum price paid for a purchase with these params.

*this considers any discount from Unlock or the OnKeyPurchase hook.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _recipient | address | undefined |
| _referrer | address | undefined |
| _data | bytes | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### referrerFees

```solidity
function referrerFees(address _referrer) external view returns (uint256 referrerFee)
```

Returns the percentage of the keyPrice to be sent to the referrer (in basis points)



#### Parameters

| Name | Type | Description |
|---|---|---|
| _referrer | address | the address of the referrer |

#### Returns

| Name | Type | Description |
|---|---|---|
| referrerFee | uint256 | the percentage of the keyPrice to be sent to the referrer (in basis points) |

### refundPenaltyBasisPoints

```solidity
function refundPenaltyBasisPoints() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### renewMembershipFor

```solidity
function renewMembershipFor(uint256 _tokenId, address _referrer) external nonpayable
```

Renew a given tokenonly works for non-free, expiring, ERC20 locks



#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the ID fo the token to renew |
| _referrer | address | the address of the person to be granted UDT |

### renounceLockManager

```solidity
function renounceLockManager() external nonpayable
```






### renounceRole

```solidity
function renounceRole(bytes32 role, address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |
| account | address | undefined |

### revokeKeyGranter

```solidity
function revokeKeyGranter(address _granter) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| _granter | address | undefined |

### revokeRole

```solidity
function revokeRole(bytes32 role, address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| role | bytes32 | undefined |
| account | address | undefined |

### safeTransferFrom

```solidity
function safeTransferFrom(address from, address to, uint256 tokenId) external nonpayable
```



*Transfers a specific NFT (`tokenId`) from one account (`from`) to another (`to`). Requirements: - `from`, `to` cannot be zero. - `tokenId` must be owned by `from`. - If the caller is not `from`, it must be have been allowed to move this NFT by either `approve` or `setApprovalForAll`.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| from | address | undefined |
| to | address | undefined |
| tokenId | uint256 | undefined |

### safeTransferFrom

```solidity
function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| from | address | undefined |
| to | address | undefined |
| tokenId | uint256 | undefined |
| data | bytes | undefined |

### schemaVersion

```solidity
function schemaVersion() external view returns (uint256)
```

Returns the version number of the data schema currently used by the lockif this is different from `publicLockVersion`, then the ability to purchase, grant or extend keys is disabled.

*will return 0 if no ;igration has ever been run*


#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### setApprovalForAll

```solidity
function setApprovalForAll(address _operator, bool _approved) external nonpayable
```

disabled when transfers are disabled

*Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _operator | address | operator address to set the approval |
| _approved | bool | representing the status of the approval to be set |

### setEventHooks

```solidity
function setEventHooks(address _onKeyPurchaseHook, address _onKeyCancelHook, address _onValidKeyHook, address _onTokenURIHook, address _onKeyTransferHook, address _onKeyExtendHook, address _onKeyGrantHook) external nonpayable
```

Allows a Lock manager to add or remove an event hook



#### Parameters

| Name | Type | Description |
|---|---|---|
| _onKeyPurchaseHook | address | Hook called when the `purchase` function is called |
| _onKeyCancelHook | address | Hook called when the internal `_cancelAndRefund` function is called |
| _onValidKeyHook | address | Hook called to determine if the contract should overide the status for a given address |
| _onTokenURIHook | address | Hook called to generate a data URI used for NFT metadata |
| _onKeyTransferHook | address | Hook called when a key is transfered |
| _onKeyExtendHook | address | Hook called when a key is extended or renewed |
| _onKeyGrantHook | address | Hook called when a key is granted |

### setGasRefundValue

```solidity
function setGasRefundValue(uint256 _gasRefundValue) external nonpayable
```



*Set the value to be refunded to the sender on purchase*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _gasRefundValue | uint256 | price in wei or token in smallest price unit |

### setKeyManagerOf

```solidity
function setKeyManagerOf(uint256 _tokenId, address _keyManager) external nonpayable
```

Update transfer and cancel rights for a given key



#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The id of the key to assign rights for |
| _keyManager | address | The address to assign the rights to for the given key |

### setLockMetadata

```solidity
function setLockMetadata(string _lockName, string _lockSymbol, string _baseTokenURI) external nonpayable
```

Allows the Lock owner to assign



#### Parameters

| Name | Type | Description |
|---|---|---|
| _lockName | string | a descriptive name for this Lock. |
| _lockSymbol | string | a Symbol for this Lock (default to KEY). |
| _baseTokenURI | string | the baseTokenURI for this Lock |

### setOwner

```solidity
function setOwner(address account) external nonpayable
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| account | address | undefined |

### setReferrerFee

```solidity
function setReferrerFee(address _referrer, uint256 _feeBasisPoint) external nonpayable
```

Set a specific percentage of the keyPrice to be sent to the referrer while purchasing, extending or renewing a key.

*To send a fixed percentage of the key price to all referrers, sett a percentage to `address(0)`*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _referrer | address | the address of the referrer |
| _feeBasisPoint | uint256 | the percentage of the price to be used for this specific referrer (in basis points) |

### shareKey

```solidity
function shareKey(address _to, uint256 _tokenId, uint256 _timeShared) external nonpayable
```

Allows the key owner to safely share their key (parent key) by transferring a portion of the remaining time to a new key (child key).

*Throws if key is not valid.Throws if `_to` is the zero addressEmit Transfer event*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _to | address | The recipient of the shared key |
| _tokenId | uint256 | the key to share |
| _timeShared | uint256 | The amount of time shared checks if `_to` is a smart contract (code size &gt; 0). If so, it calls `onERC721Received` on `_to` and throws if the return value is not `bytes4(keccak256(&#39;onERC721Received(address,address,uint,bytes)&#39;))`. |

### supportsInterface

```solidity
function supportsInterface(bytes4 interfaceId) external view returns (bool)
```

From ERC165.sol



#### Parameters

| Name | Type | Description |
|---|---|---|
| interfaceId | bytes4 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | bool | undefined |

### symbol

```solidity
function symbol() external view returns (string)
```



*Gets the token symbol*


#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | string | string representing the token symbol |

### tokenAddress

```solidity
function tokenAddress() external view returns (address)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | address | undefined |

### tokenByIndex

```solidity
function tokenByIndex(uint256 index) external view returns (uint256)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| index | uint256 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### tokenOfOwnerByIndex

```solidity
function tokenOfOwnerByIndex(address _owner, uint256 index) external view returns (uint256 tokenId)
```





#### Parameters

| Name | Type | Description |
|---|---|---|
| _owner | address | undefined |
| index | uint256 | undefined |

#### Returns

| Name | Type | Description |
|---|---|---|
| tokenId | uint256 | undefined |

### tokenURI

```solidity
function tokenURI(uint256 _tokenId) external view returns (string)
```

A distinct Uniform Resource Identifier (URI) for a given asset.

*Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC  3986. The URI may point to a JSON file that conforms to the &quot;ERC721  Metadata JSON Schema&quot;. https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | The tokenID we&#39;re inquiring about |

#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | string | String representing the URI for the requested token |

### totalKeys

```solidity
function totalKeys(address _keyOwner) external view returns (uint256 numberOfKeys)
```

Returns the number of keys owned by `_keyOwner` (expired or not)



#### Parameters

| Name | Type | Description |
|---|---|---|
| _keyOwner | address | address for which we are retrieving the total number of keys |

#### Returns

| Name | Type | Description |
|---|---|---|
| numberOfKeys | uint256 | total number of keys owned by the address |

### totalSupply

```solidity
function totalSupply() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### transfer

```solidity
function transfer(uint256 _tokenId, address _to, uint256 _value) external nonpayable returns (bool success)
```



*The typical use case would be to call this with _value 1, which is on par with calling `transferFrom`. If the user has more than `expirationDuration` time remaining this may use the `shareKey` function to send some but not all of the token.*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenId | uint256 | the id of the token to transfer time from |
| _to | address | the recipient of the new token with time |
| _value | uint256 | sends a token with _value * expirationDuration (the amount of time remaining on a standard purchase). |

#### Returns

| Name | Type | Description |
|---|---|---|
| success | bool | the result of the transfer operation |

### transferFeeBasisPoints

```solidity
function transferFeeBasisPoints() external view returns (uint256)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | uint256 | undefined |

### transferFrom

```solidity
function transferFrom(address from, address to, uint256 tokenId) external nonpayable
```

an ERC721-like function to transfer a token from one account to another.

*Requirements: if the caller is not `from`, it must be approved to move this token by either `approve` or `setApprovalForAll`. The key manager will be reset to address zero after the transfer*

#### Parameters

| Name | Type | Description |
|---|---|---|
| from | address | the owner of token to transfer |
| to | address | the address that will receive the token |
| tokenId | uint256 | the id of the token |

### unlendKey

```solidity
function unlendKey(address _recipient, uint256 _tokenId) external nonpayable
```

Unlend is called when you have lent a key and want to claim its full ownership back.

*Only the key manager of the token can call this function*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _recipient | address | the address that will receive the token ownership |
| _tokenId | uint256 | the id of the token |

### unlockProtocol

```solidity
function unlockProtocol() external view returns (address)
```






#### Returns

| Name | Type | Description |
|---|---|---|
| _0 | address | undefined |

### updateKeyPricing

```solidity
function updateKeyPricing(uint256 _keyPrice, address _tokenAddress) external nonpayable
```

A function which lets a Lock manager of the lock to change the price for future purchases.

*Throws if called by other than a Lock managerThrows if lock has been disabledThrows if _tokenAddress is not a valid token*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _keyPrice | uint256 | The new price to set for keys |
| _tokenAddress | address | The address of the erc20 token to use for pricing the keys, or 0 to use ETH |

### updateLockConfig

```solidity
function updateLockConfig(uint256 _newExpirationDuration, uint256 _maxNumberOfKeys, uint256 _maxKeysPerAcccount) external nonpayable
```

Update the main key properties for the entire lock: - default duration of each key - the maximum number of keys the lock can edit - the maximum number of keys a single address can holdkeys previously bought are unaffected by this changes in expiration duration (i.e. existing keys timestamps are not recalculated/updated)

*_maxNumberOfKeys Can&#39;t be smaller than the existing supply*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _newExpirationDuration | uint256 | the new amount of time for each key purchased or type(uint).max for a non-expiring key |
| _maxNumberOfKeys | uint256 | uint the maximum number of keys |
| _maxKeysPerAcccount | uint256 | the maximum amount of key a single user can own |

### updateRefundPenalty

```solidity
function updateRefundPenalty(uint256 _freeTrialLength, uint256 _refundPenaltyBasisPoints) external nonpayable
```

Allow a Lock manager to change the refund penalty.

*Throws if called by other than a Lock manager*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _freeTrialLength | uint256 | The new duration of free trials for this lock |
| _refundPenaltyBasisPoints | uint256 | The new refund penaly in basis-points(bps) |

### updateSchemaVersion

```solidity
function updateSchemaVersion() external nonpayable
```

Set the schema version to the latestonly lock manager call call this




### updateTransferFee

```solidity
function updateTransferFee(uint256 _transferFeeBasisPoints) external nonpayable
```

Allow a Lock manager to change the transfer fee.

*Throws if called by other than a Lock manager*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _transferFeeBasisPoints | uint256 | The new transfer fee in basis-points(bps). Ex: 200 bps = 2% |

### withdraw

```solidity
function withdraw(address _tokenAddress, address payable _recipient, uint256 _amount) external nonpayable
```



*Called by lock manager to withdraw all funds from the lock*

#### Parameters

| Name | Type | Description |
|---|---|---|
| _tokenAddress | address | specifies the token address to withdraw or 0 for ETH. This is usually the same as `tokenAddress` in MixinFunds. |
| _recipient | address payable | specifies the address that will receive the tokens |
| _amount | uint256 | specifies the max amount to withdraw, which may be reduced when considering the available balance. Set to 0 or MAX_UINT to withdraw everything. -- however be wary of draining funds as it breaks the `cancelAndRefund` and `expireAndRefundFor` use cases. |




