424 lines
15 KiB
TypeScript
424 lines
15 KiB
TypeScript
import { getContractAddressesForChainOrThrow } from '@0x/contract-addresses';
|
|
import { SupportedProvider } from 'ethereum-types';
|
|
import { EIP712TypedData } from '@0x/types';
|
|
import { BigNumber, hexUtils, NULL_ADDRESS } from '@0x/utils';
|
|
|
|
import { ZERO } from './constants';
|
|
import {
|
|
createExchangeProxyEIP712Domain,
|
|
EIP712_DOMAIN_PARAMETERS,
|
|
getExchangeProxyEIP712Hash,
|
|
getTypeHash,
|
|
} from './eip712_utils';
|
|
import {
|
|
eip712SignHashWithKey,
|
|
eip712SignTypedDataWithProviderAsync,
|
|
ethSignHashWithKey,
|
|
ethSignHashWithProviderAsync,
|
|
Signature,
|
|
SignatureType,
|
|
} from './signature_utils';
|
|
|
|
export enum TradeDirection {
|
|
SellNFT = 0,
|
|
BuyNFT = 1,
|
|
}
|
|
|
|
export enum OrderStatus {
|
|
Invalid = 0,
|
|
Fillable = 1,
|
|
Unfillable = 2,
|
|
Expired = 3,
|
|
}
|
|
|
|
interface Fee {
|
|
recipient: string;
|
|
amount: BigNumber;
|
|
feeData: string;
|
|
}
|
|
|
|
interface Property {
|
|
propertyValidator: string;
|
|
propertyData: string;
|
|
}
|
|
|
|
const NFT_ORDER_DEFAULT_VALUES = {
|
|
direction: TradeDirection.SellNFT,
|
|
maker: NULL_ADDRESS,
|
|
taker: NULL_ADDRESS,
|
|
expiry: ZERO,
|
|
nonce: ZERO,
|
|
erc20Token: NULL_ADDRESS,
|
|
erc20TokenAmount: ZERO,
|
|
fees: [] as Fee[],
|
|
chainId: 1,
|
|
verifyingContract: getContractAddressesForChainOrThrow(1).exchangeProxy,
|
|
};
|
|
|
|
const ERC721_ORDER_DEFAULT_VALUES = {
|
|
direction: TradeDirection.SellNFT,
|
|
maker: NULL_ADDRESS,
|
|
taker: NULL_ADDRESS,
|
|
expiry: ZERO,
|
|
nonce: ZERO,
|
|
erc20Token: NULL_ADDRESS,
|
|
erc20TokenAmount: ZERO,
|
|
fees: [] as Fee[],
|
|
erc721Token: NULL_ADDRESS,
|
|
erc721TokenId: ZERO,
|
|
erc721TokenProperties: [] as Property[],
|
|
chainId: 1,
|
|
verifyingContract: getContractAddressesForChainOrThrow(1).exchangeProxy,
|
|
};
|
|
|
|
const ERC1155_ORDER_DEFAULT_VALUES = {
|
|
direction: TradeDirection.SellNFT,
|
|
maker: NULL_ADDRESS,
|
|
taker: NULL_ADDRESS,
|
|
expiry: ZERO,
|
|
nonce: ZERO,
|
|
erc20Token: NULL_ADDRESS,
|
|
erc20TokenAmount: ZERO,
|
|
fees: [] as Fee[],
|
|
erc1155Token: NULL_ADDRESS,
|
|
erc1155TokenId: ZERO,
|
|
erc1155TokenProperties: [] as Property[],
|
|
erc1155TokenAmount: ZERO,
|
|
chainId: 1,
|
|
verifyingContract: getContractAddressesForChainOrThrow(1).exchangeProxy,
|
|
};
|
|
|
|
type CommonNFTOrderFields = typeof NFT_ORDER_DEFAULT_VALUES;
|
|
type ERC721OrderFields = typeof ERC721_ORDER_DEFAULT_VALUES;
|
|
type ERC1155OrderFields = typeof ERC1155_ORDER_DEFAULT_VALUES;
|
|
|
|
export abstract class NFTOrder {
|
|
public static readonly FEE_ABI = [
|
|
{ type: 'address', name: 'recipient' },
|
|
{ type: 'uint256', name: 'amount' },
|
|
{ type: 'bytes', name: 'feeData' },
|
|
];
|
|
public static readonly PROPERTY_ABI = [
|
|
{ type: 'address', name: 'propertyValidator' },
|
|
{ type: 'bytes', name: 'propertyData' },
|
|
];
|
|
public static readonly FEE_TYPE_HASH = getTypeHash('Fee', NFTOrder.FEE_ABI);
|
|
public static readonly PROPERTY_TYPE_HASH = getTypeHash('Property', NFTOrder.PROPERTY_ABI);
|
|
|
|
public direction: TradeDirection;
|
|
public maker: string;
|
|
public taker: string;
|
|
public expiry: BigNumber;
|
|
public nonce: BigNumber;
|
|
public erc20Token: string;
|
|
public erc20TokenAmount: BigNumber;
|
|
public fees: Fee[];
|
|
public chainId: number;
|
|
public verifyingContract: string;
|
|
|
|
protected constructor(fields: Partial<CommonNFTOrderFields> = {}) {
|
|
const _fields = { ...NFT_ORDER_DEFAULT_VALUES, ...fields };
|
|
this.direction = _fields.direction;
|
|
this.maker = _fields.maker;
|
|
this.taker = _fields.taker;
|
|
this.expiry = _fields.expiry;
|
|
this.nonce = _fields.nonce;
|
|
this.erc20Token = _fields.erc20Token;
|
|
this.erc20TokenAmount = _fields.erc20TokenAmount;
|
|
this.fees = _fields.fees;
|
|
this.chainId = _fields.chainId;
|
|
this.verifyingContract = _fields.verifyingContract;
|
|
}
|
|
|
|
public abstract getStructHash(): string;
|
|
public abstract getEIP712TypedData(): EIP712TypedData;
|
|
protected abstract _getProperties(): Property[];
|
|
|
|
public willExpire(secondsFromNow = 0): boolean {
|
|
const millisecondsInSecond = 1000;
|
|
const currentUnixTimestampSec = new BigNumber(Date.now() / millisecondsInSecond).integerValue();
|
|
return this.expiry.isLessThan(currentUnixTimestampSec.plus(secondsFromNow));
|
|
}
|
|
|
|
public getHash(): string {
|
|
return getExchangeProxyEIP712Hash(this.getStructHash(), this.chainId, this.verifyingContract);
|
|
}
|
|
|
|
public async getSignatureWithProviderAsync(
|
|
provider: SupportedProvider,
|
|
type: SignatureType = SignatureType.EthSign,
|
|
signer: string = this.maker,
|
|
): Promise<Signature> {
|
|
switch (type) {
|
|
case SignatureType.EIP712:
|
|
return eip712SignTypedDataWithProviderAsync(this.getEIP712TypedData(), signer, provider);
|
|
case SignatureType.EthSign:
|
|
return ethSignHashWithProviderAsync(this.getHash(), signer, provider);
|
|
default:
|
|
throw new Error(`Cannot sign with signature type: ${type}`);
|
|
}
|
|
}
|
|
|
|
public getSignatureWithKey(key: string, type: SignatureType = SignatureType.EthSign): Signature {
|
|
switch (type) {
|
|
case SignatureType.EIP712:
|
|
return eip712SignHashWithKey(this.getHash(), key);
|
|
case SignatureType.EthSign:
|
|
return ethSignHashWithKey(this.getHash(), key);
|
|
default:
|
|
throw new Error(`Cannot sign with signature type: ${type}`);
|
|
}
|
|
}
|
|
|
|
protected _getPropertiesHash(): string {
|
|
return hexUtils.hash(
|
|
hexUtils.concat(
|
|
...this._getProperties().map(property =>
|
|
hexUtils.hash(
|
|
hexUtils.concat(
|
|
hexUtils.leftPad(NFTOrder.PROPERTY_TYPE_HASH),
|
|
hexUtils.leftPad(property.propertyValidator),
|
|
hexUtils.hash(property.propertyData),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
protected _getFeesHash(): string {
|
|
return hexUtils.hash(
|
|
hexUtils.concat(
|
|
...this.fees.map(fee =>
|
|
hexUtils.hash(
|
|
hexUtils.concat(
|
|
hexUtils.leftPad(NFTOrder.FEE_TYPE_HASH),
|
|
hexUtils.leftPad(fee.recipient),
|
|
hexUtils.leftPad(fee.amount),
|
|
hexUtils.hash(fee.feeData),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
export class ERC721Order extends NFTOrder {
|
|
public static readonly STRUCT_NAME = 'ERC721Order';
|
|
public static readonly STRUCT_ABI = [
|
|
{ type: 'uint8', name: 'direction' },
|
|
{ type: 'address', name: 'maker' },
|
|
{ type: 'address', name: 'taker' },
|
|
{ type: 'uint256', name: 'expiry' },
|
|
{ type: 'uint256', name: 'nonce' },
|
|
{ type: 'address', name: 'erc20Token' },
|
|
{ type: 'uint256', name: 'erc20TokenAmount' },
|
|
{ type: 'Fee[]', name: 'fees' },
|
|
{ type: 'address', name: 'erc721Token' },
|
|
{ type: 'uint256', name: 'erc721TokenId' },
|
|
{ type: 'Property[]', name: 'erc721TokenProperties' },
|
|
];
|
|
|
|
public static readonly TYPE_HASH = getTypeHash(ERC721Order.STRUCT_NAME, ERC721Order.STRUCT_ABI, {
|
|
['Fee']: NFTOrder.FEE_ABI,
|
|
['Property']: NFTOrder.PROPERTY_ABI,
|
|
});
|
|
|
|
public erc721Token: string;
|
|
public erc721TokenId: BigNumber;
|
|
public erc721TokenProperties: Property[];
|
|
|
|
constructor(fields: Partial<ERC721OrderFields> = {}) {
|
|
const _fields = { ...ERC721_ORDER_DEFAULT_VALUES, ...fields };
|
|
super(_fields);
|
|
this.erc721Token = _fields.erc721Token;
|
|
this.erc721TokenId = _fields.erc721TokenId;
|
|
this.erc721TokenProperties = _fields.erc721TokenProperties;
|
|
}
|
|
|
|
public clone(fields: Partial<ERC721OrderFields> = {}): ERC721Order {
|
|
return new ERC721Order({
|
|
direction: this.direction,
|
|
maker: this.maker,
|
|
taker: this.taker,
|
|
expiry: this.expiry,
|
|
nonce: this.nonce,
|
|
erc20Token: this.erc20Token,
|
|
erc20TokenAmount: this.erc20TokenAmount,
|
|
fees: this.fees,
|
|
erc721Token: this.erc721Token,
|
|
erc721TokenId: this.erc721TokenId,
|
|
erc721TokenProperties: this.erc721TokenProperties,
|
|
chainId: this.chainId,
|
|
verifyingContract: this.verifyingContract,
|
|
...fields,
|
|
});
|
|
}
|
|
|
|
public getStructHash(): string {
|
|
return hexUtils.hash(
|
|
hexUtils.concat(
|
|
hexUtils.leftPad(ERC721Order.TYPE_HASH),
|
|
hexUtils.leftPad(this.direction),
|
|
hexUtils.leftPad(this.maker),
|
|
hexUtils.leftPad(this.taker),
|
|
hexUtils.leftPad(this.expiry),
|
|
hexUtils.leftPad(this.nonce),
|
|
hexUtils.leftPad(this.erc20Token),
|
|
hexUtils.leftPad(this.erc20TokenAmount),
|
|
this._getFeesHash(),
|
|
hexUtils.leftPad(this.erc721Token),
|
|
hexUtils.leftPad(this.erc721TokenId),
|
|
this._getPropertiesHash(),
|
|
),
|
|
);
|
|
}
|
|
|
|
public getEIP712TypedData(): EIP712TypedData {
|
|
return {
|
|
types: {
|
|
EIP712Domain: EIP712_DOMAIN_PARAMETERS,
|
|
[ERC721Order.STRUCT_NAME]: ERC721Order.STRUCT_ABI,
|
|
['Fee']: NFTOrder.FEE_ABI,
|
|
['Property']: NFTOrder.PROPERTY_ABI,
|
|
},
|
|
domain: createExchangeProxyEIP712Domain(this.chainId, this.verifyingContract) as any,
|
|
primaryType: ERC721Order.STRUCT_NAME,
|
|
message: {
|
|
direction: this.direction,
|
|
maker: this.maker,
|
|
taker: this.taker,
|
|
expiry: this.expiry.toString(10),
|
|
nonce: this.nonce.toString(10),
|
|
erc20Token: this.erc20Token,
|
|
erc20TokenAmount: this.erc20TokenAmount.toString(10),
|
|
fees: this.fees.map(fee => ({
|
|
recipient: fee.recipient,
|
|
amount: fee.amount.toString(10),
|
|
feeData: fee.feeData,
|
|
})) as any,
|
|
erc721Token: this.erc721Token,
|
|
erc721TokenId: this.erc721TokenId.toString(10),
|
|
erc721TokenProperties: this.erc721TokenProperties as any,
|
|
},
|
|
};
|
|
}
|
|
|
|
protected _getProperties(): Property[] {
|
|
return this.erc721TokenProperties;
|
|
}
|
|
}
|
|
|
|
export class ERC1155Order extends NFTOrder {
|
|
public static readonly STRUCT_NAME = 'ERC1155Order';
|
|
public static readonly STRUCT_ABI = [
|
|
{ type: 'uint8', name: 'direction' },
|
|
{ type: 'address', name: 'maker' },
|
|
{ type: 'address', name: 'taker' },
|
|
{ type: 'uint256', name: 'expiry' },
|
|
{ type: 'uint256', name: 'nonce' },
|
|
{ type: 'address', name: 'erc20Token' },
|
|
{ type: 'uint256', name: 'erc20TokenAmount' },
|
|
{ type: 'Fee[]', name: 'fees' },
|
|
{ type: 'address', name: 'erc1155Token' },
|
|
{ type: 'uint256', name: 'erc1155TokenId' },
|
|
{ type: 'Property[]', name: 'erc1155TokenProperties' },
|
|
{ type: 'uint128', name: 'erc1155TokenAmount' },
|
|
];
|
|
|
|
public static readonly TYPE_HASH = getTypeHash(ERC1155Order.STRUCT_NAME, ERC1155Order.STRUCT_ABI, {
|
|
['Fee']: NFTOrder.FEE_ABI,
|
|
['Property']: NFTOrder.PROPERTY_ABI,
|
|
});
|
|
|
|
public erc1155Token: string;
|
|
public erc1155TokenId: BigNumber;
|
|
public erc1155TokenProperties: Property[];
|
|
public erc1155TokenAmount: BigNumber;
|
|
|
|
constructor(fields: Partial<ERC1155OrderFields> = {}) {
|
|
const _fields = { ...ERC1155_ORDER_DEFAULT_VALUES, ...fields };
|
|
super(_fields);
|
|
this.erc1155Token = _fields.erc1155Token;
|
|
this.erc1155TokenId = _fields.erc1155TokenId;
|
|
this.erc1155TokenProperties = _fields.erc1155TokenProperties;
|
|
this.erc1155TokenAmount = _fields.erc1155TokenAmount;
|
|
}
|
|
|
|
public clone(fields: Partial<ERC1155OrderFields> = {}): ERC1155Order {
|
|
return new ERC1155Order({
|
|
direction: this.direction,
|
|
maker: this.maker,
|
|
taker: this.taker,
|
|
expiry: this.expiry,
|
|
nonce: this.nonce,
|
|
erc20Token: this.erc20Token,
|
|
erc20TokenAmount: this.erc20TokenAmount,
|
|
fees: this.fees,
|
|
erc1155Token: this.erc1155Token,
|
|
erc1155TokenId: this.erc1155TokenId,
|
|
erc1155TokenProperties: this.erc1155TokenProperties,
|
|
erc1155TokenAmount: this.erc1155TokenAmount,
|
|
chainId: this.chainId,
|
|
verifyingContract: this.verifyingContract,
|
|
...fields,
|
|
});
|
|
}
|
|
|
|
public getStructHash(): string {
|
|
return hexUtils.hash(
|
|
hexUtils.concat(
|
|
hexUtils.leftPad(ERC1155Order.TYPE_HASH),
|
|
hexUtils.leftPad(this.direction),
|
|
hexUtils.leftPad(this.maker),
|
|
hexUtils.leftPad(this.taker),
|
|
hexUtils.leftPad(this.expiry),
|
|
hexUtils.leftPad(this.nonce),
|
|
hexUtils.leftPad(this.erc20Token),
|
|
hexUtils.leftPad(this.erc20TokenAmount),
|
|
this._getFeesHash(),
|
|
hexUtils.leftPad(this.erc1155Token),
|
|
hexUtils.leftPad(this.erc1155TokenId),
|
|
this._getPropertiesHash(),
|
|
hexUtils.leftPad(this.erc1155TokenAmount),
|
|
),
|
|
);
|
|
}
|
|
|
|
public getEIP712TypedData(): EIP712TypedData {
|
|
return {
|
|
types: {
|
|
EIP712Domain: EIP712_DOMAIN_PARAMETERS,
|
|
[ERC1155Order.STRUCT_NAME]: ERC1155Order.STRUCT_ABI,
|
|
['Fee']: NFTOrder.FEE_ABI,
|
|
['Property']: NFTOrder.PROPERTY_ABI,
|
|
},
|
|
domain: createExchangeProxyEIP712Domain(this.chainId, this.verifyingContract) as any,
|
|
primaryType: ERC1155Order.STRUCT_NAME,
|
|
message: {
|
|
direction: this.direction,
|
|
maker: this.maker,
|
|
taker: this.taker,
|
|
expiry: this.expiry.toString(10),
|
|
nonce: this.nonce.toString(10),
|
|
erc20Token: this.erc20Token,
|
|
erc20TokenAmount: this.erc20TokenAmount.toString(10),
|
|
fees: this.fees.map(fee => ({
|
|
recipient: fee.recipient,
|
|
amount: fee.amount.toString(10),
|
|
feeData: fee.feeData,
|
|
})) as any,
|
|
erc1155Token: this.erc1155Token,
|
|
erc1155TokenId: this.erc1155TokenId.toString(10),
|
|
erc1155TokenProperties: this.erc1155TokenProperties as any,
|
|
erc1155TokenAmount: this.erc1155TokenAmount.toString(10),
|
|
},
|
|
};
|
|
}
|
|
|
|
protected _getProperties(): Property[] {
|
|
return this.erc1155TokenProperties;
|
|
}
|
|
}
|