@taqueria/plugin-contract-types 0.8.4 → 0.10.0

package/example/test-generation/example-contract-5.jest-demo.ts

@@ -0,0 +1,235 @@
+
+import { TezosToolkit } from '@taquito/taquito';
+import { char2Bytes } from '@taquito/utils';
+import { tas } from '../types-file/type-aliases';
+import { ExampleContract5ContractType as ContractType } from '../types-file/example-contract-5.types';
+import { ExampleContract5Code as ContractCode } from '../types-file/example-contract-5.code';
+
+describe('example-contract-5', () => {
+    const Tezos = new TezosToolkit('RPC_URL');
+    let contract: ContractType = undefined as unknown as ContractType;
+    beforeAll(async () => {
+            
+            const newContractOrigination = await Tezos.contract.originate<ContractType>({
+                code: ContractCode.code,
+                storage: {
+                        transfers: [(
+                            {
+                                xtz_transfer_type: {
+                                    amount: tas.mutez('42'),
+                                    recipient: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                }
+                            }
+                            | {
+                                token_transfer_type: {
+                                    contract_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                    transfer_list: [{
+                                        from_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                        txs: [{
+                                            to_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                            token_id: tas.nat('42'),
+                                            amount: tas.nat('42'),
+                                        }],
+                                    }],
+                                }
+                            }
+                        )],
+                    },
+            });
+            const newContractResult = await newContractOrigination.contract();
+            const newContractAddress = newContractResult.address;
+            contract = await Tezos.contract.at<ContractType>(newContractAddress);
+            
+    });
+
+
+    it('should call confirm_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const confirm_adminRequest = await contract.methodsObject.confirm_admin().send();
+        await confirm_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call pause', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const pauseRequest = await contract.methodsObject.pause(true).send();
+        await pauseRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call set_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const set_adminRequest = await contract.methodsObject.set_admin({
+                bid: tas.nat('42'),
+                transfers: [(
+                    {
+                        xtz_transfer_type: {
+                            amount: tas.mutez('42'),
+                            recipient: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                        }
+                    }
+                    | {
+                        token_transfer_type: {
+                            contract_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                            transfer_list: [{
+                                from_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                txs: [{
+                                    to_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                    token_id: tas.nat('42'),
+                                    amount: tas.nat('42'),
+                                }],
+                            }],
+                        }
+                    }
+                )],
+            }).send();
+        await set_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call bid', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const bidRequest = await contract.methodsObject.bid(tas.nat('42')).send();
+        await bidRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call cancel', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const cancelRequest = await contract.methodsObject.cancel(tas.nat('42')).send();
+        await cancelRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call configure', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const configureRequest = await contract.methodsObject.configure({
+                opening_price: tas.mutez('42'),
+                min_raise_percent: tas.nat('42'),
+                min_raise: tas.mutez('42'),
+                round_time: tas.nat('42'),
+                extend_time: tas.nat('42'),
+                asset: [{
+                    fa2_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                    fa2_batch: [{
+                        token_id: tas.nat('42'),
+                        amount: tas.nat('42'),
+                    }],
+                }],
+                start_time: tas.timestamp(new Date()),
+                end_time: tas.timestamp(new Date()),
+            }).send();
+        await configureRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call propose', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const proposeRequest = await contract.methodsObject.propose({
+                frozen_token: tas.nat('42'),
+                proposal_metadata: tas.map({ 
+                    'VALUE': [(
+                    {
+                        xtz_transfer_type: {
+                            amount: tas.mutez('42'),
+                            recipient: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                        }
+                    }
+                    | {
+                        token_transfer_type: {
+                            contract_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                            transfer_list: [{
+                                from_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                txs: [{
+                                    to_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                    token_id: tas.nat('42'),
+                                    amount: tas.nat('42'),
+                                }],
+                            }],
+                        }
+                    }
+                )],
+                }),
+            }).send();
+        await proposeRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+});

package/example/test-generation/example-contract-6.jest-demo.ts

@@ -0,0 +1,277 @@
+
+import { TezosToolkit } from '@taquito/taquito';
+import { char2Bytes } from '@taquito/utils';
+import { tas } from '../types-file/type-aliases';
+import { ExampleContract6ContractType as ContractType } from '../types-file/example-contract-6.types';
+import { ExampleContract6Code as ContractCode } from '../types-file/example-contract-6.code';
+
+describe('example-contract-6', () => {
+    const Tezos = new TezosToolkit('RPC_URL');
+    let contract: ContractType = undefined as unknown as ContractType;
+    beforeAll(async () => {
+            
+            const newContractOrigination = await Tezos.contract.originate<ContractType>({
+                code: ContractCode.code,
+                storage: {
+                        admin: {
+                            admin: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                            paused: true,
+                            pending_admin: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                        },
+                        assets: {
+                            ledger: tas.bigMap([{ 
+                                key: {
+                                0: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                1: tas.nat('42'),
+                            }, 
+                                value: tas.nat('42'),
+                            }]),
+                            operators: tas.bigMap([{ 
+                                key: {
+                                0: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                1: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                2: tas.nat('42'),
+                            }, 
+                                value: tas.unit(),
+                            }]),
+                            token_metadata: tas.bigMap([{ 
+                                key: tas.nat('42'), 
+                                value: {
+                                token_id: tas.nat('42'),
+                                token_info: tas.map({ 
+                                    'VALUE': tas.bytes(char2Bytes('DATA')),
+                                }),
+                            },
+                            }]),
+                            token_total_supply: tas.bigMap([{ 
+                                key: tas.nat('42'), 
+                                value: tas.nat('42'),
+                            }]),
+                        },
+                        metadata: tas.bigMap({ 
+                            'VALUE': tas.bytes(char2Bytes('DATA')),
+                        }),
+                    },
+            });
+            const newContractResult = await newContractOrigination.contract();
+            const newContractAddress = newContractResult.address;
+            contract = await Tezos.contract.at<ContractType>(newContractAddress);
+            
+    });
+
+
+    it('should call confirm_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const confirm_adminRequest = await contract.methodsObject.confirm_admin().send();
+        await confirm_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call pause', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const pauseRequest = await contract.methodsObject.pause(true).send();
+        await pauseRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call set_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const set_adminRequest = await contract.methodsObject.set_admin(tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456')).send();
+        await set_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call balance_of', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const balance_ofRequest = await contract.methodsObject.balance_of({
+                requests: [{
+                    owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                    token_id: tas.nat('42'),
+                }],
+                callback: tas.contract('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+            }).send();
+        await balance_ofRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call transfer', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const transferRequest = await contract.methodsObject.transfer([{
+                    from_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                    txs: [{
+                        to_: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                        token_id: tas.nat('42'),
+                        amount: tas.nat('42'),
+                    }],
+                }]).send();
+        await transferRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call add_operator', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const add_operatorRequest = await contract.methodsObject.add_operator({
+                owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                operator: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                token_id: tas.nat('42'),
+            }).send();
+        await add_operatorRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call remove_operator', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const remove_operatorRequest = await contract.methodsObject.remove_operator({
+                owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                operator: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                token_id: tas.nat('42'),
+            }).send();
+        await remove_operatorRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call burn_tokens', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const burn_tokensRequest = await contract.methodsObject.burn_tokens([{
+                    owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                    token_id: tas.nat('42'),
+                    amount: tas.nat('42'),
+                }]).send();
+        await burn_tokensRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call create_token', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const create_tokenRequest = await contract.methodsObject.create_token({
+                token_id: tas.nat('42'),
+                token_info: tas.map({ 
+                    'VALUE': tas.bytes(char2Bytes('DATA')),
+                }),
+            }).send();
+        await create_tokenRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call mint_tokens', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const mint_tokensRequest = await contract.methodsObject.mint_tokens([{
+                    owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                    token_id: tas.nat('42'),
+                    amount: tas.nat('42'),
+                }]).send();
+        await mint_tokensRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+});

package/example/test-generation/example-contract-7.jest-demo.ts

@@ -0,0 +1,170 @@
+
+import { TezosToolkit } from '@taquito/taquito';
+import { char2Bytes } from '@taquito/utils';
+import { tas } from '../types-file/type-aliases';
+import { ExampleContract7ContractType as ContractType } from '../types-file/example-contract-7.types';
+import { ExampleContract7Code as ContractCode } from '../types-file/example-contract-7.code';
+
+describe('example-contract-7', () => {
+    const Tezos = new TezosToolkit('RPC_URL');
+    let contract: ContractType = undefined as unknown as ContractType;
+    beforeAll(async () => {
+            
+            const newContractOrigination = await Tezos.contract.originate<ContractType>({
+                code: ContractCode.code,
+                storage: {
+                        admin: {
+                            admin: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                            paused: true,
+                            pending_admin: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                        },
+                        sales: tas.bigMap([{ 
+                            key: {
+                            sale_seller: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                            tokens: {
+                                token_for_sale_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                token_for_sale_token_id: tas.nat('42'),
+                                money_token_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                                money_token_token_id: tas.nat('42'),
+                            },
+                        }, 
+                            value: tas.nat('42'),
+                        }]),
+                    },
+            });
+            const newContractResult = await newContractOrigination.contract();
+            const newContractAddress = newContractResult.address;
+            contract = await Tezos.contract.at<ContractType>(newContractAddress);
+            
+    });
+
+
+    it('should call confirm_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const confirm_adminRequest = await contract.methodsObject.confirm_admin().send();
+        await confirm_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call pause', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const pauseRequest = await contract.methodsObject.pause(true).send();
+        await pauseRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call set_admin', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const set_adminRequest = await contract.methodsObject.set_admin(tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456')).send();
+        await set_adminRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call buy', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const buyRequest = await contract.methodsObject.buy({
+                sale_seller: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                token_for_sale_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                token_for_sale_token_id: tas.nat('42'),
+                money_token_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                money_token_token_id: tas.nat('42'),
+            }).send();
+        await buyRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call mint', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const mintRequest = await contract.methodsObject.mint([{
+                    token_metadata: {
+                        token_id: tas.nat('42'),
+                        token_info: tas.map({ 
+                            'VALUE': tas.bytes(char2Bytes('DATA')),
+                        }),
+                    },
+                    owner: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                }]).send();
+        await mintRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+    it('should call sell', async () => {
+        
+        const getStorageValue = async () => {
+            const storage = await contract.storage();
+            const value = storage;
+            return value;
+        };
+
+        const storageValueBefore = await getStorageValue();
+        
+        const sellRequest = await contract.methodsObject.sell({
+                sale_price: tas.nat('42'),
+                token_for_sale_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                token_for_sale_token_id: tas.nat('42'),
+                money_token_address: tas.address('tz1ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456'),
+                money_token_token_id: tas.nat('42'),
+            }).send();
+        await sellRequest.confirmation(3);
+        
+        const storageValueAfter = await getStorageValue();
+
+        expect(storageValueAfter).toBe('');
+    });
+
+});