diff --git a/cypress/integration/transaction_view.spec.ts b/cypress/integration/transaction_view.spec.ts
index 6a7c9ea83c..ce94d22f6e 100644
--- a/cypress/integration/transaction_view.spec.ts
+++ b/cypress/integration/transaction_view.spec.ts
@@ -1,14 +1,60 @@
 /// <reference types="Cypress" />
+import ITransaction from '../../src/interfaces/ITransaction';
+import ISmartContract from '../../src/interfaces/ISmartContract';
 chai.should();
 describe('Cypress', () => {
 
+    const transactionOne: ITransaction = {
+        name: 'transactionOne',
+        parameters: [{
+            description: '',
+            name: 'name',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const transactionTwo: ITransaction = {
+        name: 'transactionTwo',
+        parameters: [{
+            description: '',
+            name: 'size',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const greenContract: ISmartContract = {
+        name: 'greenContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'greenContract@0.0.1',
+        transactions: [transactionOne, transactionTwo],
+        namespace: 'GreenContract'
+    };
+
+    const blueContract: ISmartContract = {
+        name: 'blueContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'blueContract@0.0.1',
+        transactions: [transactionOne, transactionTwo],
+        namespace: 'BlueContract'
+    };
+
     describe('Transaction home screen', () => {
 
-        const mockMessage: {path: string, state: {smartContracts: Array<string>, activeSmartContract: string}} = {
+        const mockMessage: {path: string, state: {smartContracts: Array<ISmartContract>, activeSmartContract: ISmartContract}} = {
             path: 'transaction',
             state: {
-                smartContracts: ['greenContract@0.0.1', 'blueContract@0.0.1'],
-                activeSmartContract: 'greenContract@0.0.1'
+                smartContracts: [greenContract, blueContract],
+                activeSmartContract: greenContract
             }
         };
 
@@ -58,21 +104,52 @@ describe('Cypress', () => {
 
         beforeEach(() => {
 
-            const mockMessage: {path: string, state: {smartContracts: Array<string>, activeSmartContract: string}} = {
+            const mockMessage: {path: string, state: {smartContracts: Array<ISmartContract>, activeSmartContract: ISmartContract}} = {
                 path: 'transaction/create',
                 state: {
-                    smartContracts: ['greenContract@0.0.1', 'blueContract@0.0.1'],
-                    activeSmartContract: 'greenContract@0.0.1'
+                    smartContracts: [greenContract, blueContract],
+                    activeSmartContract: greenContract
                 }
             };
-
             cy.visit('build/index.html').then((window: Window) => {
                 window.postMessage(mockMessage, '*');
             });
         });
 
-        it('is a transaction create screen', () => {
-            expect(true).to.equal(true);
+        it('generates appropriate arguments when a transaction is selected', () => {
+            cy.get('#transaction-name-select').select('transactionOne');
+            cy.get('#arguments-text-area')
+                .invoke('val')
+                .then((text: JQuery<HTMLElement>): void => {
+                    it('is a transaction create screen', () => {
+                        expect(text).to.equal('name: ');
+                    });
+                });
+        });
+
+        it('replaces generated arguments when a new transaction is selected', () => {
+            cy.get('#transaction-name-select').select('transactionOne');
+            cy.get('#arguments-text-area')
+                .invoke('val')
+                .then((text: JQuery<HTMLElement>): void => {
+                    it('is a transaction create screen', () => {
+                        expect(text).to.equal('name: ');
+                    });
+                });
+
+            cy.get('#transaction-name-select').select('transactionTwo');
+            cy.get('#arguments-text-area')
+                .invoke('val')
+                .then((text: JQuery<HTMLElement>): void => {
+                    it('is a transaction create screen', () => {
+                        expect(text).to.equal('size: ');
+                    });
+                });
+        });
+
+        it('can navigate back to the home screen', () => {
+            cy.get('.titles-container > span').click();
+            cy.url().should('include', '/transaction');
         });
     });
 });
diff --git a/enzyme/tests/App.test.tsx b/enzyme/tests/App.test.tsx
new file mode 100644
index 0000000000..59efdc1f6b
--- /dev/null
+++ b/enzyme/tests/App.test.tsx
@@ -0,0 +1,122 @@
+import React from 'react';
+import { mount } from 'enzyme';
+import App from '../../src/App';
+import chai from 'chai';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import ISmartContract from '../../src/interfaces/ISmartContract';
+import ITransaction from '../../src/interfaces/ITransaction';
+import Utils from '../../src/Utils';
+chai.should();
+chai.use(sinonChai);
+
+describe('App', () => {
+
+    let mySandBox: sinon.SinonSandbox;
+
+    const mockTxn: ITransaction = {
+        name: 'mockTxn',
+        parameters: [{
+            description: '',
+            name: 'name',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const greenContract: ISmartContract = {
+        name: 'greenContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'greenContract@0.0.1',
+        transactions: [mockTxn],
+        namespace: 'GreenContract'
+    };
+
+    const blueContract: ISmartContract = {
+        name: 'blueContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'blueContract@0.0.1',
+        transactions: [mockTxn],
+        namespace: 'BlueContract'
+    };
+
+    const mockState: { smartContracts: Array<ISmartContract>, activeSmartContract: ISmartContract } = {
+        smartContracts: [greenContract, blueContract],
+        activeSmartContract: greenContract
+    };
+
+    beforeEach(async () => {
+        mySandBox = sinon.createSandbox();
+    });
+
+    afterEach(async () => {
+        mySandBox.restore();
+    });
+
+    it('should redirect to the transaction home view', async () => {
+        const component: any = mount(<App/>);
+
+        const msg: MessageEvent = new MessageEvent('message', {
+            data: {
+                path: '/transaction',
+                state: mockState
+            }
+        });
+        dispatchEvent(msg);
+        expect(component.state().redirectPath).toBe('/transaction');
+    });
+
+    it('should redirect to the transaction create view', async () => {
+        const component: any = mount(<App/>);
+
+        const msg: MessageEvent = new MessageEvent('message', {
+            data: {
+                path: '/transaction/create',
+                    state: {
+                        smartContracts: [greenContract, blueContract],
+                        activeSmartContract: greenContract
+                    }
+            }
+        });
+        dispatchEvent(msg);
+        expect(component.state().redirectPath).toBe('/transaction/create');
+    });
+
+    it('does not overwrite state when redirecting to a different page', async () => {
+        const component: any = mount(<App/>);
+
+        const msg: MessageEvent = new MessageEvent('message', {
+            data: {
+                path: '/transaction',
+                state: mockState
+            }
+        });
+        dispatchEvent(msg);
+        expect(component.state().childState).toBe(mockState);
+
+        Utils.changeRoute('/transaction/create');
+        expect(component.state().childState).toBe(mockState);
+    });
+
+    it('updates the state correctly when switching smart contracts', async () => {
+        const component: any = mount(<App/>);
+
+        const msg: MessageEvent = new MessageEvent('message', {
+            data: {
+                path: '/transaction',
+                state: mockState
+            }
+        });
+        dispatchEvent(msg);
+        expect(component.state().childState.activeSmartContract).toBe(greenContract);
+
+        component.instance().switchSmartContract('blueContract@0.0.1');
+        expect(component.state().childState.activeSmartContract).toBe(blueContract);
+    });
+
+});
diff --git a/enzyme/tests/TransactionCreate.test.tsx b/enzyme/tests/TransactionCreate.test.tsx
index 396d76cb2e..43c7fb1a37 100644
--- a/enzyme/tests/TransactionCreate.test.tsx
+++ b/enzyme/tests/TransactionCreate.test.tsx
@@ -1,18 +1,61 @@
-
+// tslint:disable no-unused-expression
 import React from 'react';
 import renderer from 'react-test-renderer';
+import { mount } from 'enzyme';
 import TransactionCreate from '../../src/components/TransactionCreate/TransactionCreate';
 import chai from 'chai';
 import sinon from 'sinon';
 import sinonChai from 'sinon-chai';
+import ITransaction from '../../src/interfaces/ITransaction';
+import ISmartContract from '../../src/interfaces/ISmartContract';
+import Utils from '../../src/Utils';
 chai.should();
 chai.use(sinonChai);
 
 describe('TransactionCreate component', () => {
     let mySandbox: sinon.SinonSandbox;
+    let changeRouteStub: sinon.SinonStub;
+    let getTransactionArgumentsSpy: sinon.SinonSpy;
+
+    const transactionOne: ITransaction = {
+        name: 'transactionOne',
+        parameters: [{
+            description: '',
+            name: 'name',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const transactionTwo: ITransaction = {
+        name: 'transactionTwo',
+        parameters: [{
+            description: '',
+            name: 'size',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const greenContract: ISmartContract = {
+        name: 'greenContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'greenContract@0.0.1',
+        transactions: [transactionOne, transactionTwo],
+        namespace: 'GreenContract'
+    };
 
     beforeEach(async () => {
         mySandbox = sinon.createSandbox();
+        changeRouteStub = mySandbox.stub(Utils, 'changeRoute').resolves();
+        getTransactionArgumentsSpy = mySandbox.spy(TransactionCreate.prototype, 'getTransactionArguments');
     });
 
     afterEach(async () => {
@@ -21,8 +64,38 @@ describe('TransactionCreate component', () => {
 
     it('should render the expected snapshot', async () => {
         const component: any = renderer
-            .create(<TransactionCreate/>)
+            .create(<TransactionCreate activeSmartContract={greenContract}/>)
             .toJSON();
         expect(component).toMatchSnapshot();
     });
+
+    it('redirects back to the home page when the appropriate link is clicked on', async () => {
+        const component: any = mount(<TransactionCreate activeSmartContract={greenContract}/>);
+        component.find('.titles-container > span').simulate('click');
+        changeRouteStub.should.have.been.called;
+    });
+
+    it('generates transaction arguments when an option from the transaction select is chosen', async () => {
+        const component: any = mount(<TransactionCreate activeSmartContract={greenContract}/>);
+        expect(component.state().transactionArguments).toBe('');
+        component.find('select').at(0).prop('onChange')( { currentTarget: { value: 'transactionOne' } });
+        getTransactionArgumentsSpy.should.have.been.called;
+        expect(component.state().transactionArguments).toBe('name: \n');
+    });
+
+    it('does not generate arguments in the event that the chosen transaction doesn\'t exist', async () => {
+        const component: any = mount(<TransactionCreate activeSmartContract={greenContract}/>);
+        expect(component.state().transactionArguments).toBe('');
+        component.find('select').at(0).prop('onChange')( { currentTarget: { value: 'anotherTransaction' } });
+        getTransactionArgumentsSpy.should.have.been.called;
+        expect(component.state().transactionArguments).toBe('');
+    });
+
+    it('updates when the user types in the textarea', async () => {
+        const component: any = mount(<TransactionCreate activeSmartContract={greenContract}/>);
+        expect(component.state().transactionArguments).toBe('');
+        component.find('textarea').prop('onChange')( { currentTarget: { value: 'hello' } } );
+        expect(component.state().transactionArguments).toBe('hello');
+    });
+
 });
diff --git a/enzyme/tests/TransactionHome.test.tsx b/enzyme/tests/TransactionHome.test.tsx
index 0af5d9e52c..7d6fdb67b9 100644
--- a/enzyme/tests/TransactionHome.test.tsx
+++ b/enzyme/tests/TransactionHome.test.tsx
@@ -3,6 +3,8 @@ import React from 'react';
 import renderer from 'react-test-renderer';
 import { mount } from 'enzyme';
 import TransactionHome from '../../src/components/TransactionHome/TransactionHome';
+import ITransaction from '../../src/interfaces/ITransaction';
+import ISmartContract from '../../src/interfaces/ISmartContract';
 import chai from 'chai';
 import sinon from 'sinon';
 import sinonChai from 'sinon-chai';
@@ -12,16 +14,47 @@ chai.use(sinonChai);
 describe('TransactionHome component', () => {
 
     let mySandBox: sinon.SinonSandbox;
-    let switchSmartContractSpy: sinon.SinonSpy;
+    let switchSmartContractStub: sinon.SinonStub;
 
-    const mockState: {smartContracts: Array<string>, activeSmartContract: string} = {
-        smartContracts: ['greenContract@0.0.1', 'blueContract@0.0.1'],
-        activeSmartContract: 'greenContract@0.0.1'
+    const mockTxn: ITransaction = {
+        name: 'mockTxn',
+        parameters: [{
+            description: '',
+            name: 'name',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const greenContract: ISmartContract = {
+        name: 'greenContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'greenContract@0.0.1',
+        transactions: [mockTxn],
+        namespace: 'GreenContract'
+    };
+
+    const blueContract: ISmartContract = {
+        name: 'blueContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'blueContract@0.0.1',
+        transactions: [mockTxn],
+        namespace: 'BlueContract'
+    };
+
+    const mockState: {smartContracts: Array<ISmartContract>, activeSmartContract: ISmartContract} = {
+        smartContracts: [greenContract, blueContract],
+        activeSmartContract: greenContract
     };
 
     beforeEach(async () => {
         mySandBox = sinon.createSandbox();
-        switchSmartContractSpy = mySandBox.spy(TransactionHome.prototype, 'switchSmartContract');
+        switchSmartContractStub = mySandBox.stub().resolves();
     });
 
     afterEach(async () => {
@@ -30,23 +63,21 @@ describe('TransactionHome component', () => {
 
     it('should render the expected snapshot', async () => {
         const component: any = renderer
-            .create(<TransactionHome messageData={mockState}/>)
+            .create(<TransactionHome messageData={mockState} switchSmartContract={switchSmartContractStub}/>)
             .toJSON();
         expect(component).toMatchSnapshot();
     });
 
     it('should change the active smart contract if another contract is selected', async () => {
-        const component: any = mount(<TransactionHome messageData={mockState}/>);
+        const component: any = mount(<TransactionHome messageData={mockState} switchSmartContract={switchSmartContractStub}/>);
         component.find('li').at(1).simulate('click');
-        switchSmartContractSpy.should.have.been.calledOnce;
-        expect(component.state().activeSmartContract).toBe('blueContract@0.0.1');
+        switchSmartContractStub.should.have.been.calledOnce;
     });
 
     it('should do nothing if the current smart contract is selected', async () => {
-        const component: any = mount(<TransactionHome messageData={mockState}/>);
+        const component: any = mount(<TransactionHome messageData={mockState} switchSmartContract={switchSmartContractStub}/>);
         component.find('li').at(0).simulate('click');
-        switchSmartContractSpy.should.not.have.been.called;
-        expect(component.state().activeSmartContract).toBe('greenContract@0.0.1');
+        switchSmartContractStub.should.not.have.been.called;
     });
 
 });
diff --git a/enzyme/tests/__snapshots__/TransactionCreate.test.tsx.snap b/enzyme/tests/__snapshots__/TransactionCreate.test.tsx.snap
index ffe2f59c58..807b3bd214 100644
--- a/enzyme/tests/__snapshots__/TransactionCreate.test.tsx.snap
+++ b/enzyme/tests/__snapshots__/TransactionCreate.test.tsx.snap
@@ -57,8 +57,12 @@ exports[`TransactionCreate component should render the expected snapshot 1`] = `
       <div
         className="titles-container"
       >
-        <span>
-          smartContract@0.0.1 home
+        <span
+          className="home-link"
+          onClick={[Function]}
+        >
+          greenContract@0.0.1
+           home
         </span>
       </div>
       <div
@@ -145,46 +149,31 @@ exports[`TransactionCreate component should render the expected snapshot 1`] = `
                     <select
                       className="bx--select-input"
                       id="transaction-name-select"
+                      onChange={[Function]}
                     >
                       <option
                         className="bx--select-option"
                         disabled={false}
-                        hidden={false}
-                        value="create-penguin"
-                      >
-                        Create Penguin
-                      </option>
-                      <option
-                        className="bx--select-option"
-                        disabled={false}
-                        hidden={false}
-                        value="read-penguin"
-                      >
-                        Read Penguin
-                      </option>
-                      <option
-                        className="bx--select-option"
-                        disabled={false}
-                        hidden={false}
-                        value="update-penguin"
+                        hidden={true}
+                        value="placeholder-item"
                       >
-                        Update Penguin
+                        Select the transaction name
                       </option>
                       <option
                         className="bx--select-option"
                         disabled={false}
                         hidden={false}
-                        value="delete-penguin"
+                        value="transactionOne"
                       >
-                        Delete Penguin
+                        transactionOne
                       </option>
                       <option
                         className="bx--select-option"
                         disabled={false}
                         hidden={false}
-                        value="penguin-exists"
+                        value="transactionTwo"
                       >
-                        Penguin Exists
+                        transactionTwo
                       </option>
                     </select>
                     <svg
@@ -313,6 +302,7 @@ exports[`TransactionCreate component should render the expected snapshot 1`] = `
               >
                 <label
                   className="bx--label"
+                  htmlFor="arguments-text-area"
                 >
                   Arguments
                 </label>
@@ -326,10 +316,12 @@ exports[`TransactionCreate component should render the expected snapshot 1`] = `
                     className="bx--text-area"
                     cols={50}
                     disabled={false}
+                    id="arguments-text-area"
                     onChange={[Function]}
                     onClick={[Function]}
                     placeholder=""
                     rows={4}
+                    value=""
                   />
                 </div>
               </div>
diff --git a/extension/commands/openTransactionViewCommand.ts b/extension/commands/openTransactionViewCommand.ts
index bc8876d444..ef51859a14 100644
--- a/extension/commands/openTransactionViewCommand.ts
+++ b/extension/commands/openTransactionViewCommand.ts
@@ -27,7 +27,9 @@ import { GlobalState } from '../util/GlobalState';
 export async function openTransactionView(treeItem?: InstantiatedTreeItem): Promise<void> {
     const outputAdapter: VSCodeBlockchainOutputAdapter = VSCodeBlockchainOutputAdapter.instance();
     outputAdapter.log(LogType.INFO, undefined, `Open Transaction View`);
-    let smartContract: string;
+    let smartContractLabel: string;
+    let contract: { name: string, contractInstance: {}, transactions: Array<{}>, info: {} };
+    let data: { name: string, version: string, channel: string, label: string, transactions: Array<{}>, namespace: string };
 
     let connection: IFabricClientConnection = FabricConnectionManager.instance().getConnection();
 
@@ -41,30 +43,48 @@ export async function openTransactionView(treeItem?: InstantiatedTreeItem): Prom
     }
 
     if (treeItem) {
-        smartContract = treeItem.name + '@' + treeItem.version;
+        smartContractLabel = treeItem.name + '@' + treeItem.version;
     } else {
         const chosenSmartContract: IBlockchainQuickPickItem<{ name: string, channel: string, version: string }> = await UserInputUtil.showClientInstantiatedSmartContractsQuickPick(`Choose a smart contract`, null);
         if (!chosenSmartContract) {
             return;
         }
-        smartContract = chosenSmartContract.data.name + '@' + chosenSmartContract.data.version;
+        smartContractLabel = chosenSmartContract.data.name + '@' + chosenSmartContract.data.version;
     }
 
     const channelMap: Map<string, Array<string>> = await connection.createChannelMap();
 
-    const instantiatedChaincodes: Array<string> = [];
+    const instantiatedChaincodes: Array<{ label: string, channel: string }> = [];
+
+    let metadataObj: any = {
+        contracts: {
+            '' : {
+                name: '',
+                transactions: [],
+            }
+        }
+    };
 
     for (const [thisChannelName] of channelMap) {
         const chaincodes: Array<FabricChaincode> = await connection.getInstantiatedChaincode(thisChannelName); // returns array of objects
         for (const chaincode of chaincodes) {
-            const data: string = chaincode.name + '@' + chaincode.version;
+            metadataObj = await connection.getMetadata(chaincode.name, thisChannelName);
+            contract = metadataObj.contracts[Object.keys(metadataObj.contracts)[0]];
+            data = {
+                name: chaincode.name,
+                version: chaincode.version,
+                channel: thisChannelName,
+                label: chaincode.name + '@' + chaincode.version,
+                transactions: contract.transactions,
+                namespace: contract.name
+            };
             instantiatedChaincodes.push(data);
         }
     }
 
-    const appState: {smartContracts: Array<string>, activeSmartContract: string} = {
+    const appState: {} = {
         smartContracts: instantiatedChaincodes,
-        activeSmartContract: smartContract
+        activeSmartContract: instantiatedChaincodes.filter((obj: any) => obj.label === smartContractLabel)[0]
     };
 
     const context: vscode.ExtensionContext = GlobalState.getExtensionContext();
diff --git a/src/App.tsx b/src/App.tsx
index da1825617b..a0513d8c8f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -3,10 +3,14 @@ import './App.scss';
 import { HashRouter as Router, Route, Redirect } from 'react-router-dom';
 import TransactionHome from './components/TransactionHome/TransactionHome';
 import TransactionCreate from './components/TransactionCreate/TransactionCreate';
+import ISmartContract from './interfaces/ISmartContract';
 
 interface AppState {
     redirectPath: string;
-    childState: any;
+    childState: {
+        activeSmartContract: ISmartContract,
+        smartContracts: Array<ISmartContract>
+    };
 }
 
 class App extends React.Component<{}, AppState> {
@@ -14,30 +18,50 @@ class App extends React.Component<{}, AppState> {
         super(props);
         this.state = {
             redirectPath: '',
-            childState: {}
+            childState: {
+                activeSmartContract: {
+                    name: '',
+                    version: '',
+                    channel: '',
+                    label: '',
+                    transactions: [],
+                    namespace: ''
+                },
+                smartContracts : []
+            }
         };
+
+        this.switchSmartContract = this.switchSmartContract.bind(this);
     }
 
     componentDidMount(): void {
         window.addEventListener('message', (event: MessageEvent) => {
             this.setState({
                 redirectPath: event.data.path,
-                childState: event.data.state
+                childState: event.data.state ? event.data.state : this.state.childState
             });
         });
     }
 
+    public switchSmartContract(newActiveContractLabel: string): void {
+        this.setState({
+            childState: {
+                activeSmartContract: this.state.childState.smartContracts.filter((obj: ISmartContract) => obj.label === newActiveContractLabel)[0],
+                smartContracts: this.state.childState.smartContracts
+            }
+        });
+    }
+
     public render(): any {
         if (this.state.redirectPath === '') {
-            // Maybe we should display a loading spinner instead?
             return <div></div>;
         } else {
             return (
                 <Router>
                     <div>
-                    <Route render={(): any => <Redirect push to={this.state.redirectPath}/>}></Route>
-                    <Route exact path='/transaction' render={(): any => <TransactionHome messageData={this.state.childState}/>}></Route>
-                    <Route exact path='/transaction/create' render={(): any => <TransactionCreate/>}></Route>
+                        <Route render={(): any => <Redirect push to={this.state.redirectPath}/>}></Route>
+                        <Route exact path='/transaction' render={(): any => <TransactionHome messageData={this.state.childState} switchSmartContract={this.switchSmartContract}/>}></Route>
+                        <Route exact path='/transaction/create' render={(): any => <TransactionCreate activeSmartContract={this.state.childState.activeSmartContract}/>}></Route>
                     </div>
                 </Router>
             );
diff --git a/src/Utils.ts b/src/Utils.ts
new file mode 100644
index 0000000000..75fce2443f
--- /dev/null
+++ b/src/Utils.ts
@@ -0,0 +1,13 @@
+const Utils: any = {
+
+    changeRoute(newPath: string): void {
+        dispatchEvent(new MessageEvent('message', {
+            data: {
+                path: newPath
+            }
+        }));
+    }
+
+};
+
+export default Utils;
diff --git a/src/components/TransactionCreate/TransactionCreate.scss b/src/components/TransactionCreate/TransactionCreate.scss
index d26cbeda99..6de6082929 100644
--- a/src/components/TransactionCreate/TransactionCreate.scss
+++ b/src/components/TransactionCreate/TransactionCreate.scss
@@ -15,6 +15,14 @@ fieldset > legend {
     }
 }
 
+.home-link {
+    color: $carbon--blue-50;
+
+    &:hover {
+        cursor: pointer;
+    }
+}
+
 .select-width {
     width: 100%;
 
@@ -28,6 +36,7 @@ fieldset > legend {
     width: 100%;
 
     textarea {
+        font-size: 100%;
         width: 100%;
         resize: vertical;
     }
diff --git a/src/components/TransactionCreate/TransactionCreate.tsx b/src/components/TransactionCreate/TransactionCreate.tsx
index c53ee31ec0..45f9dffac4 100644
--- a/src/components/TransactionCreate/TransactionCreate.tsx
+++ b/src/components/TransactionCreate/TransactionCreate.tsx
@@ -1,64 +1,113 @@
 import React, { Component } from 'react';
 import './TransactionCreate.scss';
 import Sidebar from '../TransactionSidebar/TransactionSidebar';
+import Utils from '../../Utils';
 import { Button, Form, FormGroup, TextInput, Select, SelectItem, Checkbox, TextArea } from 'carbon-components-react';
+import ITransaction from '../../interfaces/ITransaction';
+import ISmartContract from '../../interfaces/ISmartContract';
 
-class TransactionCreate extends Component {
+interface CreateProps {
+    activeSmartContract: ISmartContract;
+}
+
+interface CreateState {
+    activeSmartContract: ISmartContract;
+    transactionArguments: string;
+}
+
+class TransactionCreate extends Component<CreateProps, CreateState> {
+    constructor(props: Readonly<CreateProps>) {
+        super(props);
+        this.state = {
+            activeSmartContract: this.props.activeSmartContract,
+            transactionArguments: ''
+        };
+        this.getTransactionArguments = this.getTransactionArguments.bind(this);
+        this.updateTextArea = this.updateTextArea.bind(this);
+    }
+
+    public getTransactionArguments(event: React.FormEvent<HTMLSelectElement>): void {
+        const transaction: ITransaction | undefined = this.state.activeSmartContract.transactions.find((txn: ITransaction) => txn.name === event.currentTarget.value);
+
+        let templateText: string = '';
+
+        if (transaction !== undefined) {
+            for (let i: number = 0; i < transaction.parameters.length; i++) {
+                templateText += (transaction.parameters[i].name + ': \n');
+            }
+            this.setState({
+                transactionArguments: templateText
+            });
+        }
+    }
 
     public render(): any {
         return (
             <div className='page-container bx--grid' data-test-id='txn-page'>
                 <div className='inner-container bx--row'>
                     <Sidebar/>
-            <div className='page-contents bx--col'>
-                <div className='titles-container'>
-                    <span>smartContract@0.0.1 home</span>
-                </div>
-                <div className='contents-container bx--row'>
-                    <div className='bx--col-lg-11'>
-                        <Form id='create-txn-form'>
-                            <FormGroup legendText='Transaction label'>
-                                <div className='bx--row inline-row hide-label'>
-                                    <TextInput id='transaction-label-input' labelText='Enter transaction label' hideLabel={true} defaultValue='Enter transaction label'></TextInput>
-                                    <Button id='save-txn-button' size='field'>Save</Button>
+                    <div className='page-contents bx--col'>
+                        <div className='titles-container'>
+                            <span className='home-link' onClick={(): void => Utils.changeRoute('/transaction')}>{this.state.activeSmartContract.label} home</span>
+                        </div>
+                        <div className='contents-container bx--row'>
+                            <div className='bx--col-lg-11'>
+                                <Form id='create-txn-form'>
+                                    <FormGroup legendText='Transaction label'>
+                                        <div className='bx--row inline-row hide-label'>
+                                            <TextInput id='transaction-label-input' labelText='Enter transaction label' hideLabel={true} defaultValue='Enter transaction label'></TextInput>
+                                            <Button id='save-txn-button' size='field'>Save</Button>
+                                        </div>
+                                    </FormGroup>
+                                    <FormGroup legendText='Transaction name'>
+                                        <Select id='transaction-name-select' labelText='Transaction name' className='select-width' onChange={this.getTransactionArguments}>
+                                            {this.populateTransactionSelect()}
+                                        </Select>
+                                    </FormGroup>
+                                    <FormGroup legendText='Peer targeting' id='target-peer-input'>
+                                        <Checkbox id='target-peer-checkbox' labelText='Target custom peer'/>
+                                        <Select id='peers-select' labelText='Peers' className='select-width hide-label'>
+                                            <SelectItem disabled={false} hidden={false} text='Peer 1, Peer 2' value='peer-1-and-2'/>
+                                        </Select>
+                                    </FormGroup>
+                                    <FormGroup legendText='Arguments'>
+                                        <TextArea labelText='Arguments' id='arguments-text-area' onChange={this.updateTextArea} value={this.state.transactionArguments}/>
+                                    </FormGroup>
+                                    <FormGroup legendText='Transient data'>
+                                    <TextInput id='transient-data-input' labelText='Transient data' hideLabel={true}></TextInput>
+                                    </FormGroup>
+                                </Form>
+                            </div>
+                            <div className='bx--col-lg-5'>
+                                <div>Transaction output</div>
+                                <div className='txn-output-container' id='txn-output-container'>
+                                    {this.getTransactionOutput()}
                                 </div>
-                            </FormGroup>
-                            <FormGroup legendText='Transaction name'>
-                                <Select id='transaction-name-select' labelText='Transaction name' className='select-width'>
-                                    <SelectItem disabled={false} hidden={false} text='Create Penguin' value='create-penguin'/>
-                                    <SelectItem disabled={false} hidden={false} text='Read Penguin' value='read-penguin'/>
-                                    <SelectItem disabled={false} hidden={false} text='Update Penguin' value='update-penguin'/>
-                                    <SelectItem disabled={false} hidden={false} text='Delete Penguin' value='delete-penguin'/>
-                                    <SelectItem disabled={false} hidden={false} text='Penguin Exists' value='penguin-exists'/>
-                                </Select>
-                            </FormGroup>
-                            <FormGroup legendText='Peer targeting' id='target-peer-input'>
-                                <Checkbox id='target-peer-checkbox' labelText='Target custom peer'/>
-                                <Select id='peers-select' labelText='Peers' className='select-width hide-label'>
-                                    <SelectItem disabled={false} hidden={false} text='Peer 1, Peer 2' value='peer-1-and-2'/>
-                                </Select>
-                            </FormGroup>
-                            <FormGroup legendText='Arguments'>
-                                <TextArea labelText='Arguments'/>
-                            </FormGroup>
-                            <FormGroup legendText='Transient data'>
-                            <TextInput id='transient-data-input' labelText='Transient data' hideLabel={true}></TextInput>
-                            </FormGroup>
-                        </Form>
-                    </div>
-                    <div className='bx--col-lg-5'>
-                        <div>Transaction output</div>
-                        <div className='txn-output-container' id='txn-output-container'>
-                            {this.getTransactionOutput()}
+                            </div>
                         </div>
                     </div>
                 </div>
             </div>
-            </div>
-            </div>
         );
     }
 
+    private populateTransactionSelect(): any {
+        const options: any = [];
+        options.push(<SelectItem disabled={false} hidden={true} text='Select the transaction name' value='placeholder-item'/>);
+
+        for (const txn of this.state.activeSmartContract.transactions) {
+            options.push(<SelectItem disabled={false} hidden={false} text={txn.name} value={txn.name}/>);
+        }
+
+        return options;
+    }
+
+    private updateTextArea(event: React.FormEvent<HTMLTextAreaElement>): void {
+        this.setState({
+            transactionArguments: event.currentTarget.value
+        });
+    }
+
     private getTransactionOutput(): any {
         return (
             <div>
diff --git a/src/components/TransactionHome/TransactionHome.tsx b/src/components/TransactionHome/TransactionHome.tsx
index 6466e7e83c..1292f53436 100644
--- a/src/components/TransactionHome/TransactionHome.tsx
+++ b/src/components/TransactionHome/TransactionHome.tsx
@@ -2,30 +2,35 @@ import React, { Component } from 'react';
 import './TransactionHome.scss';
 import { Accordion, AccordionItem } from 'carbon-components-react';
 import Sidebar from '../TransactionSidebar/TransactionSidebar';
+import ISmartContract from '../../interfaces/ISmartContract';
 
-interface PageProps {
-    messageData: {smartContracts: Array<string>, activeSmartContract: string};
+interface HomeProps {
+    messageData: {
+        activeSmartContract: ISmartContract,
+        smartContracts: Array<ISmartContract>
+    };
+    switchSmartContract: (newActiveContract: string) => void;
 }
 
-interface PageState {
-    smartContracts: string[];
-    activeSmartContract: string;
+interface HomeState {
+    activeSmartContractLabel: string;
+    smartContractLabels: Array<string>;
+    switchSmartContract: (newActiveContract: string) => void;
 }
 
-class TransactionHome extends Component<PageProps, PageState> {
+class TransactionHome extends Component<HomeProps, HomeState> {
 
-    constructor(props: Readonly<PageProps>) {
+    constructor(props: Readonly<HomeProps>) {
         super(props);
-        this.state = {
-            smartContracts: this.props.messageData.smartContracts,
-            activeSmartContract: this.props.messageData.activeSmartContract
-        };
+        this.state = this.setUpState(this.props);
     }
 
-    public switchSmartContract(selectedSmartContract: string): void {
-        this.setState({
-            activeSmartContract: selectedSmartContract
-        });
+    componentDidUpdate(prevProps: HomeProps): void {
+        if (prevProps.messageData.activeSmartContract.label !== this.props.messageData.activeSmartContract.label) {
+            this.setState({
+                activeSmartContractLabel: this.props.messageData.activeSmartContract.label
+            });
+        }
     }
 
     public render(): any {
@@ -35,17 +40,17 @@ class TransactionHome extends Component<PageProps, PageState> {
                     <Sidebar/>
                     <div className='page-contents bx--col'>
                         <div className='titles-container'>
-                            <span>{this.state.activeSmartContract} home</span>
+                            <span>{this.state.activeSmartContractLabel} home</span>
                             <h1>Transactions</h1>
                         </div>
                         <div className='contents-container bx--row'>
                             <div className='contents-left bx--col'>
-                                <p>Welcome to your transaction web view for <span className='disabled-smart-contract'>{this.state.activeSmartContract}</span>; use this to submit and evaluate new and existing transactions.</p>
+                                <p>Welcome to your transaction web view for <span className='disabled-smart-contract'>{this.state.activeSmartContractLabel}</span>; use this to submit and evaluate new and existing transactions.</p>
                                 <p>Unsure of where to start? Follow our introductory Getting Started section opposite.</p>
                                 <br/>
                                 <h5>Smart Contracts</h5>
                                 <p>To switch to the web view for a different smart contract, select the smart contract below</p>
-                                {this.getSmartContractItems(this.state.smartContracts)}
+                                {this.getSmartContractItems(this.state.smartContractLabels)}
                             </div>
                             <div className='contents-right bx--col' id='contents-right'>
                                 <h5>Getting Started</h5>
@@ -69,14 +74,27 @@ class TransactionHome extends Component<PageProps, PageState> {
         );
     }
 
-    private getSmartContractItems(smartContracts: string[]): any {
+    private setUpState(receivedProps: HomeProps): HomeState {
+        const contractLabels: Array<string> = [];
+        for (const contract of receivedProps.messageData.smartContracts) {
+            contractLabels.push(contract.label);
+        }
+
+        return {
+            activeSmartContractLabel: receivedProps.messageData.activeSmartContract.label,
+            smartContractLabels: contractLabels,
+            switchSmartContract: receivedProps.switchSmartContract
+        };
+    }
+
+    private getSmartContractItems(smartContracts: Array<string>): any {
         const smartContractItems: any = [];
 
         for (const contract of smartContracts) {
-            if (contract === this.state.activeSmartContract) {
+            if (contract === this.state.activeSmartContractLabel) {
                 smartContractItems.push(<li className='smart-contract-item disabled-smart-contract' key={contract}>{contract}</li>);
             } else {
-                smartContractItems.push(<li className='smart-contract-item clickable-smart-contract' key={contract}  onClick={(): void => this.switchSmartContract(contract)}>{contract}</li>);
+                smartContractItems.push(<li className='smart-contract-item clickable-smart-contract' key={contract}  onClick={(): void => this.state.switchSmartContract(contract)}>{contract}</li>);
             }
         }
 
diff --git a/src/components/TransactionSidebar/TransactionSidebar.tsx b/src/components/TransactionSidebar/TransactionSidebar.tsx
index 670346a404..1d96cacffa 100644
--- a/src/components/TransactionSidebar/TransactionSidebar.tsx
+++ b/src/components/TransactionSidebar/TransactionSidebar.tsx
@@ -3,14 +3,13 @@ import './TransactionSidebar.scss';
 import SidebarPanel from '../TransactionSidebarPanel/TransactionSidebarPanel';
 
 function TransactionSidebar(): any {
-
-        return (
-            <div className='sidebar-container' id='sidebar-container'>
-                <SidebarPanel panelType={'buttons'}/>
-                <SidebarPanel panelType={'filters'}/>
-                <SidebarPanel panelType={'log'}/>
-            </div>
-        );
+    return (
+        <div className='sidebar-container' id='sidebar-container'>
+            <SidebarPanel panelType={'buttons'}/>
+            <SidebarPanel panelType={'filters'}/>
+            <SidebarPanel panelType={'log'}/>
+        </div>
+    );
 }
 
 export default TransactionSidebar;
diff --git a/src/components/TransactionSidebarPanel/TransactionSidebarPanel.tsx b/src/components/TransactionSidebarPanel/TransactionSidebarPanel.tsx
index d0b24bf108..166cf607e8 100644
--- a/src/components/TransactionSidebarPanel/TransactionSidebarPanel.tsx
+++ b/src/components/TransactionSidebarPanel/TransactionSidebarPanel.tsx
@@ -1,5 +1,6 @@
 import React, { Component } from 'react';
 import './TransactionSidebarPanel.scss';
+import Utils from '../../Utils';
 import { Button } from 'carbon-components-react';
 
 interface SidebarPanelProps {
@@ -19,14 +20,6 @@ class TransactionSidebarPanel extends Component<SidebarPanelProps, SidebarPanelS
         };
     }
 
-    public createTxn(): void {
-        dispatchEvent(new MessageEvent('message', {
-            data: {
-                path: '/transaction/create'
-            }
-        }));
-    }
-
     public importTxn(): void {
         // tslint:disable-next-line: no-console
         console.log('import an existing transaction');
@@ -42,7 +35,7 @@ class TransactionSidebarPanel extends Component<SidebarPanelProps, SidebarPanelS
         if (this.state.panelType === 'buttons') {
             panelTSX = (
                 <div className='panel-container'>
-                    <Button id='create-button' size='field' onClick={this.createTxn}>Create a new transaction</Button>
+                    <Button id='create-button' size='field' onClick={(): void => Utils.changeRoute('/transaction/create')}>Create a new transaction</Button>
                     <Button id='import-button' size='field' onClick={this.importTxn}>Import existing transaction</Button>
                  </div>
             );
diff --git a/src/interfaces/ISmartContract.ts b/src/interfaces/ISmartContract.ts
new file mode 100644
index 0000000000..06d9e58e91
--- /dev/null
+++ b/src/interfaces/ISmartContract.ts
@@ -0,0 +1,12 @@
+import ITransaction from './ITransaction';
+
+interface ISmartContract {
+    name: string;
+    version: string;
+    channel: string;
+    label: string;
+    transactions: Array<ITransaction>;
+    namespace: string;
+}
+
+export default ISmartContract;
diff --git a/src/interfaces/ITransaction.ts b/src/interfaces/ITransaction.ts
new file mode 100644
index 0000000000..dfbbf27948
--- /dev/null
+++ b/src/interfaces/ITransaction.ts
@@ -0,0 +1,8 @@
+interface ITransaction {
+    name: string;
+    parameters: Array<{ description: string, name: string, schema: {} }>;
+    returns: { type: string };
+    tag: Array<string>;
+}
+
+export default ITransaction;
diff --git a/test/commands/openTransactionViewCommand.test.ts b/test/commands/openTransactionViewCommand.test.ts
index 06e452020c..ee867c927d 100644
--- a/test/commands/openTransactionViewCommand.test.ts
+++ b/test/commands/openTransactionViewCommand.test.ts
@@ -92,12 +92,26 @@ describe('OpenTransactionViewCommand', () => {
 
             fabricClientConnectionMock.getAllPeerNames.returns(['peerOne']);
             fabricClientConnectionMock.getAllChannelsForPeer.withArgs('peerOne').resolves(['myChannel']);
-            fabricClientConnectionMock.getInstantiatedChaincode.resolves([
+
+            fabricClientConnectionMock.getInstantiatedChaincode.resolves([{ name: 'mySmartContract', version: '0.0.1' }]);
+
+            fabricClientConnectionMock.getMetadata.resolves(
                 {
-                    name: 'myContract',
-                    version: '0.0.1',
+                    contracts: {
+                        'my-contract': {
+                            name: 'my-contract',
+                            transactions: [
+                                {
+                                    name: 'transaction1'
+                                },
+                                {
+                                    name: 'transaction2'
+                                }
+                            ],
+                        }
+                    }
                 }
-            ]);
+            );
 
             showInstantiatedSmartContractQuickPickStub = mySandBox.stub(UserInputUtil, 'showClientInstantiatedSmartContractsQuickPick').resolves({
                 label: 'myContract',
diff --git a/test/webview/TransactionView.test.ts b/test/webview/TransactionView.test.ts
index e01338ca4b..99778dee86 100644
--- a/test/webview/TransactionView.test.ts
+++ b/test/webview/TransactionView.test.ts
@@ -22,6 +22,8 @@ import { TransactionView } from '../../extension/webview/TransactionView';
 import { View } from '../../extension/webview/View';
 import { TestUtil } from '../TestUtil';
 import { GlobalState } from '../../extension/util/GlobalState';
+import ITransaction from '../../src/interfaces/ITransaction';
+import ISmartContract from '../../src/interfaces/ISmartContract';
 chai.use(sinonChai);
 
 describe('TransactionView', () => {
@@ -31,9 +33,53 @@ describe('TransactionView', () => {
     let postMessageStub: sinon.SinonStub;
     let executeCommandStub: sinon.SinonStub;
 
-    const mockAppState: {smartContracts: Array<string>, activeSmartContract: string} = {
-        smartContracts: ['greenContract@0.0.1', 'blueContract@0.0.1'],
-        activeSmartContract: 'greenContract@0.0.1'
+    const transactionOne: ITransaction = {
+        name: 'transactionOne',
+        parameters: [{
+            description: '',
+            name: 'name',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const transactionTwo: ITransaction = {
+        name: 'transactionTwo',
+        parameters: [{
+            description: '',
+            name: 'size',
+            schema: {}
+        }],
+        returns: {
+            type: ''
+        },
+        tag: ['submit']
+    };
+
+    const greenContract: ISmartContract = {
+        name: 'greenContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'greenContract@0.0.1',
+        transactions: [transactionOne, transactionTwo],
+        namespace: 'GreenContract'
+    };
+
+    const blueContract: ISmartContract = {
+        name: 'blueContract',
+        version: '0.0.1',
+        channel: 'mychannel',
+        label: 'blueContract@0.0.1',
+        transactions: [transactionOne, transactionTwo],
+        namespace: 'BlueContract'
+    };
+
+    const mockAppState: {smartContracts: Array<ISmartContract>, activeSmartContract: ISmartContract} = {
+        smartContracts: [greenContract, blueContract],
+        activeSmartContract: greenContract
     };
 
     before(async () => {