wasm-ast-types 0.19.0 → 0.20.0

package/main/client/client.js

@@ -34,10 +34,12 @@ var createWasmQueryMethod = function createWasmQueryMethod(context, jsonschema)
   var underscoreName = Object.keys(jsonschema.properties)[0];
   var methodName = (0, _case.camel)(underscoreName);
   var responseType = (0, _types2.getResponseType)(context, underscoreName);
-  var obj = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
+  var param = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
   var args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  var actionArg = t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
-  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(obj ? [obj] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([actionArg])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
+  var msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  var msgActionValue = (param === null || param === void 0 ? void 0 : param.type) === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(param ? [param] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
 };
 
 exports.createWasmQueryMethod = createWasmQueryMethod;
@@ -68,12 +70,16 @@ var getWasmMethodArgs = function getWasmMethodArgs(context, jsonschema) {
   var keys = Object.keys((_jsonschema$propertie = jsonschema.properties) !== null && _jsonschema$propertie !== void 0 ? _jsonschema$propertie : {}); // only 1 degree $ref-lookup
 
   if (!keys.length && jsonschema.$ref) {
-    var obj = context.refLookup(jsonschema.$ref);
+    var obj = context.refLookup(jsonschema.$ref); // properties
 
     if (obj) {
       var _obj$properties;
 
       keys = Object.keys((_obj$properties = obj.properties) !== null && _obj$properties !== void 0 ? _obj$properties : {});
+    } // tuple struct or otherwise, use the name of the reference
+
+
+    if (!keys.length && obj !== null && obj !== void 0 && obj.oneOf) {// TODO????? ADAIR
     }
   }
 
@@ -91,10 +97,13 @@ var createWasmExecMethod = function createWasmExecMethod(context, jsonschema) {
   context.addUtil('Coin');
   var underscoreName = Object.keys(jsonschema.properties)[0];
   var methodName = (0, _case.camel)(underscoreName);
-  var obj = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
+  var param = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
   var args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(obj ? [// props
-  obj].concat(CONSTANT_EXEC_PARAMS) : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression((0, _toConsumableArray2["default"])(args)))]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
+  var msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  var msgActionValue = (param === null || param === void 0 ? void 0 : param.type) === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(param ? [// props
+  param].concat(CONSTANT_EXEC_PARAMS) : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier('ExecuteResult'))]))), true));
 };
 

package/main/client/test/ts-client.issue-101.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _client = require("../client");
+
+var _testUtils = require("../../../test-utils");
+
+var _ownership = _interopRequireDefault(require("../../../../../__fixtures__/basic/ownership.json"));
+
+// it('query classes', () => {
+//     const ctx = makeContext(cosmos_msg_for__empty);
+//     expectCode(createQueryClass(
+//         ctx,
+//         'SG721QueryClient',
+//         'SG721ReadOnlyInstance',
+//         cosmos_msg_for__empty
+//     ))
+// });
+it('execute interfaces no extends', function () {
+  var ctx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)((0, _client.createExecuteInterface)(ctx, 'OwnershipInstance', null, _ownership["default"]));
+});
+it('ownership client with tuple', function () {
+  var ctx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)((0, _client.createExecuteClass)(ctx, 'OwnershipClient', 'OwnershipInstance', null, _ownership["default"]));
+});

package/main/message-composer/message-composer.js

@@ -34,11 +34,20 @@ var createWasmExecMethodMessageComposer = function createWasmExecMethodMessageCo
   context.addUtil('toUtf8');
   var underscoreName = Object.keys(jsonschema.properties)[0];
   var methodName = (0, _case.camel)(underscoreName);
-  var obj = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
-  var args = (0, _client.getWasmMethodArgs)(context, jsonschema.properties[underscoreName]);
+  var param = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
+  var args = (0, _client.getWasmMethodArgs)(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  var actionValue;
+
+  if ((param === null || param === void 0 ? void 0 : param.type) === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.objectExpression(args);
+  }
+
   var constantParams = [(0, _babel.identifier)('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
-  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(obj ? [// props
-  obj].concat(constantParams) : constantParams, t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')), t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [t.objectExpression([t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))), t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))), t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression(args))])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
+  return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)(param ? [// props
+  param].concat(constantParams) : constantParams, t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')), t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [t.objectExpression([t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))), t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))), t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.objectExpression([t.objectProperty(t.identifier(underscoreName), actionValue)])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('MsgExecuteContractEncodeObject'))), false));
 };
 

package/main/message-composer/message-composer.spec.js

@@ -4,15 +4,25 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _execute_msg_for__empty = _interopRequireDefault(require("../../../../__fixtures__/basic/execute_msg_for__empty.json"));
 
+var _ownership = _interopRequireDefault(require("../../../../__fixtures__/basic/ownership.json"));
+
 var _messageComposer = require("./message-composer");
 
 var _testUtils = require("../../test-utils");
 
-it('execute classes', function () {
+it("execute classes", function () {
   var ctx = (0, _testUtils.makeContext)(_execute_msg_for__empty["default"]);
-  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerClass)(ctx, 'SG721MessageComposer', 'SG721Message', _execute_msg_for__empty["default"]));
+  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerClass)(ctx, "SG721MessageComposer", "SG721Message", _execute_msg_for__empty["default"]));
 });
-it('createMessageComposerInterface', function () {
+it("createMessageComposerInterface", function () {
   var ctx = (0, _testUtils.makeContext)(_execute_msg_for__empty["default"]);
-  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerInterface)(ctx, 'SG721Message', _execute_msg_for__empty["default"]));
+  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerInterface)(ctx, "SG721Message", _execute_msg_for__empty["default"]));
+});
+it("ownershipClass", function () {
+  var ctx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerClass)(ctx, "OwnershipMessageComposer", "OwnershipMessage", _ownership["default"]));
+});
+it("ownershipInterface", function () {
+  var ownershipCtx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)((0, _messageComposer.createMessageComposerInterface)(ownershipCtx, "OwnershipMessage", _ownership["default"]));
 });

package/main/msg-builder/msg-builder.js

@@ -36,19 +36,33 @@ var createMsgBuilderClass = function createMsgBuilderClass(context, className, m
 exports.createMsgBuilderClass = createMsgBuilderClass;
 
 function createExtractTypeAnnotation(underscoreName, msgTitle) {
-  return t.tsTypeAnnotation(t.tsTypeReference(t.identifier("CamelCasedProperties"), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier("Extract"), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(msgTitle)), t.tsTypeLiteral([t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))])])), t.tsLiteralType(t.stringLiteral(underscoreName)))])));
+  return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CamelCasedProperties'), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier('Extract'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(msgTitle)), t.tsTypeLiteral([t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))])])), t.tsLiteralType(t.stringLiteral(underscoreName)))])));
 }
 
 var createStaticExecMethodMsgBuilder = function createStaticExecMethodMsgBuilder(context, jsonschema, msgTitle) {
   var underscoreName = Object.keys(jsonschema.properties)[0];
   var methodName = (0, _case.camel)(underscoreName);
-  var obj = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
-  var args = (0, _client.getWasmMethodArgs)(context, jsonschema.properties[underscoreName]);
-  if (obj) obj.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  var param = (0, _types2.createTypedObjectParams)(context, jsonschema.properties[underscoreName]);
+  var args = (0, _client.getWasmMethodArgs)(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  var actionValue;
+
+  if ((param === null || param === void 0 ? void 0 : param.type) === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
+  } // TODO: this is a hack to get the type annotation to work
+  // all type annotations in the future should be the extracted and camelized type
+
+
+  if (param && param.typeAnnotation.type === 'TSTypeAnnotation' && param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
+    param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  }
+
   return t.classProperty(t.identifier(methodName), (0, _utils.arrowFunctionExpression)( // params
-  obj ? [// props
-  obj] : [], // body
-  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const'))))]))]), // return type
+  param ? [// props
+  param] : [], // body
+  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), actionValue)]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))), false), null, null, false, // static
   true);
 };

package/main/msg-builder/msg-builder.spec.js

@@ -6,6 +6,8 @@ var _execute_msg_for__empty = _interopRequireDefault(require("../../../../__fixt
 
 var _query_msg = _interopRequireDefault(require("../../../../__fixtures__/basic/query_msg.json"));
 
+var _ownership = _interopRequireDefault(require("../../../../__fixtures__/basic/ownership.json"));
+
 var _msgBuilder = require("./msg-builder");
 
 var _testUtils = require("../../test-utils");
@@ -15,6 +17,10 @@ it('execute class', function () {
   (0, _testUtils.expectCode)((0, _msgBuilder.createMsgBuilderClass)(ctx, 'SG721MsgBuilder', _execute_msg_for__empty["default"]));
 });
 it('query class', function () {
-  var ctx = (0, _testUtils.makeContext)(_execute_msg_for__empty["default"]);
+  var ctx = (0, _testUtils.makeContext)(_query_msg["default"]);
   (0, _testUtils.expectCode)((0, _msgBuilder.createMsgBuilderClass)(ctx, 'SG721MsgBuilder', _query_msg["default"]));
+});
+it('ownership', function () {
+  var ctx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)((0, _msgBuilder.createMsgBuilderClass)(ctx, 'Ownership', _ownership["default"]));
 });

package/main/react-query/react-query.spec.js

@@ -10,6 +10,8 @@ var _query_msg = _interopRequireDefault(require("../../../../__fixtures__/basic/
 
 var _execute_msg_for__empty = _interopRequireDefault(require("../../../../__fixtures__/basic/execute_msg_for__empty.json"));
 
+var _ownership = _interopRequireDefault(require("../../../../__fixtures__/basic/ownership.json"));
+
 var _reactQuery = require("./react-query");
 
 var _testUtils = require("../../test-utils");
@@ -77,4 +79,13 @@ it('createReactQueryHooks', function () {
     contractName: 'Sg721',
     ExecuteClient: 'Sg721Client'
   })));
+});
+it('ownership', function () {
+  var ownershipCtx = (0, _testUtils.makeContext)(_ownership["default"]);
+  (0, _testUtils.expectCode)(t.program((0, _reactQuery.createReactQueryMutationHooks)({
+    context: ownershipCtx,
+    execMsg: _ownership["default"],
+    contractName: 'Ownership',
+    ExecuteClient: 'OwnershipClient'
+  })));
 });

package/main/utils/types.js

@@ -400,9 +400,17 @@ var createTypedObjectParams = function createTypedObjectParams(context, jsonsche
   if (!keys.length) {
     // is there a ref?
     if (jsonschema.$ref) {
-      var _obj = context.refLookup(jsonschema.$ref);
+      var _obj = context.refLookup(jsonschema.$ref); // If there is a oneOf, then we need to create a type for it
 
-      if (_obj) {
+
+      if (_obj !== null && _obj !== void 0 && _obj.oneOf) {
+        // the actual type of the ref
+        var refType = jsonschema.$ref.split('/').pop();
+        var refName = (0, _case.camel)(refType);
+        var id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id;
+      } else if (_obj) {
         return createTypedObjectParams(context, _obj, camelize);
       }
     } // no results...

package/module/client/client.js

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { camel } from 'case';
-import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from '../utils';
-import { getPropertyType, getType, createTypedObjectParams, getResponseType } from '../utils/types';
+import { arrowFunctionExpression, bindMethod, classDeclaration, classProperty, getMessageProperties, promiseTypeAnnotation, typedIdentifier } from '../utils';
+import { createTypedObjectParams, getPropertyType, getResponseType, getType } from '../utils/types';
 import { identifier, propertySignature } from '../utils/babel';
 export const CONSTANT_EXEC_PARAMS = [t.assignmentPattern(identifier('fee', t.tsTypeAnnotation(t.tsUnionType([t.tSNumberKeyword(), t.tsTypeReference(t.identifier('StdFee')), t.tsLiteralType(t.stringLiteral('auto'))])), false), t.stringLiteral('auto')), identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true), identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
 export const FIXED_EXECUTE_PARAMS = [identifier('fee', t.tsTypeAnnotation(t.tsUnionType([t.tsNumberKeyword(), t.tsTypeReference(t.identifier('StdFee')), t.tsLiteralType(t.stringLiteral('auto'))])), true), identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true), identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
@@ -9,10 +9,12 @@ export const createWasmQueryMethod = (context, jsonschema) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
   const responseType = getResponseType(context, underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
   const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  const actionArg = t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
-  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [obj] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([actionArg])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
+  const msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [param] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
 };
 export const createQueryClass = (context, className, implementsClassName, queryMsg) => {
   context.addUtil('CosmWasmClient');
@@ -31,10 +33,14 @@ export const getWasmMethodArgs = (context, jsonschema) => {
   let keys = Object.keys(jsonschema.properties ?? {}); // only 1 degree $ref-lookup
 
   if (!keys.length && jsonschema.$ref) {
-    const obj = context.refLookup(jsonschema.$ref);
+    const obj = context.refLookup(jsonschema.$ref); // properties
 
     if (obj) {
       keys = Object.keys(obj.properties ?? {});
+    } // tuple struct or otherwise, use the name of the reference
+
+
+    if (!keys.length && obj?.oneOf) {// TODO????? ADAIR
     }
   }
 
@@ -49,10 +55,13 @@ export const createWasmExecMethod = (context, jsonschema) => {
   context.addUtil('Coin');
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
   const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [// props
-  obj, ...CONSTANT_EXEC_PARAMS] : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression([...args]))]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
+  const msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [// props
+  param, ...CONSTANT_EXEC_PARAMS] : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier('ExecuteResult'))]))), true));
 };
 export const createExecuteClass = (context, className, implementsClassName, extendsClassName, execMsg) => {

package/module/client/test/ts-client.issue-101.spec.js

@@ -0,0 +1,20 @@
+import { createExecuteClass, createExecuteInterface } from '../client';
+import { expectCode, makeContext } from '../../../test-utils';
+import ownership from '../../../../../__fixtures__/basic/ownership.json'; // it('query classes', () => {
+//     const ctx = makeContext(cosmos_msg_for__empty);
+//     expectCode(createQueryClass(
+//         ctx,
+//         'SG721QueryClient',
+//         'SG721ReadOnlyInstance',
+//         cosmos_msg_for__empty
+//     ))
+// });
+
+it('execute interfaces no extends', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createExecuteInterface(ctx, 'OwnershipInstance', null, ownership));
+});
+it('ownership client with tuple', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createExecuteClass(ctx, 'OwnershipClient', 'OwnershipInstance', null, ownership));
+});

package/module/message-composer/message-composer.js

@@ -12,11 +12,20 @@ const createWasmExecMethodMessageComposer = (context, jsonschema) => {
   context.addUtil('toUtf8');
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
-  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  let actionValue;
+
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.objectExpression(args);
+  }
+
   const constantParams = [identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
-  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [// props
-  obj, ...constantParams] : constantParams, t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')), t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [t.objectExpression([t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))), t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))), t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression(args))])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [// props
+  param, ...constantParams] : constantParams, t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')), t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [t.objectExpression([t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))), t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))), t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.objectExpression([t.objectProperty(t.identifier(underscoreName), actionValue)])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('MsgExecuteContractEncodeObject'))), false));
 };
 

package/module/message-composer/message-composer.spec.js

@@ -1,11 +1,20 @@
-import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import { createMessageComposerClass, createMessageComposerInterface } from './message-composer';
-import { expectCode, makeContext } from '../../test-utils';
-it('execute classes', () => {
+import execute_msg from "../../../../__fixtures__/basic/execute_msg_for__empty.json";
+import ownership from "../../../../__fixtures__/basic/ownership.json";
+import { createMessageComposerClass, createMessageComposerInterface } from "./message-composer";
+import { expectCode, makeContext } from "../../test-utils";
+it("execute classes", () => {
   const ctx = makeContext(execute_msg);
-  expectCode(createMessageComposerClass(ctx, 'SG721MessageComposer', 'SG721Message', execute_msg));
+  expectCode(createMessageComposerClass(ctx, "SG721MessageComposer", "SG721Message", execute_msg));
 });
-it('createMessageComposerInterface', () => {
+it("createMessageComposerInterface", () => {
   const ctx = makeContext(execute_msg);
-  expectCode(createMessageComposerInterface(ctx, 'SG721Message', execute_msg));
+  expectCode(createMessageComposerInterface(ctx, "SG721Message", execute_msg));
+});
+it("ownershipClass", () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMessageComposerClass(ctx, "OwnershipMessageComposer", "OwnershipMessage", ownership));
+});
+it("ownershipInterface", () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(createMessageComposerInterface(ownershipCtx, "OwnershipMessage", ownership));
 });

package/module/msg-builder/msg-builder.js

@@ -1,8 +1,8 @@
-import * as t from "@babel/types";
-import { camel } from "case";
-import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from "../utils";
-import { createTypedObjectParams } from "../utils/types";
-import { getWasmMethodArgs } from "../client/client";
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { createTypedObjectParams } from '../utils/types';
+import { getWasmMethodArgs } from '../client/client';
 export const createMsgBuilderClass = (context, className, msg) => {
   const staticMethods = getMessageProperties(msg).map(schema => {
     return createStaticExecMethodMsgBuilder(context, schema, msg.title);
@@ -15,19 +15,33 @@ export const createMsgBuilderClass = (context, className, msg) => {
  */
 
 function createExtractTypeAnnotation(underscoreName, msgTitle) {
-  return t.tsTypeAnnotation(t.tsTypeReference(t.identifier("CamelCasedProperties"), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier("Extract"), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(msgTitle)), t.tsTypeLiteral([t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))])])), t.tsLiteralType(t.stringLiteral(underscoreName)))])));
+  return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CamelCasedProperties'), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier('Extract'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(msgTitle)), t.tsTypeLiteral([t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))])])), t.tsLiteralType(t.stringLiteral(underscoreName)))])));
 }
 
 const createStaticExecMethodMsgBuilder = (context, jsonschema, msgTitle) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
-  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  if (obj) obj.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  let actionValue;
+
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
+  } // TODO: this is a hack to get the type annotation to work
+  // all type annotations in the future should be the extracted and camelized type
+
+
+  if (param && param.typeAnnotation.type === 'TSTypeAnnotation' && param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
+    param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  }
+
   return t.classProperty(t.identifier(methodName), arrowFunctionExpression( // params
-  obj ? [// props
-  obj] : [], // body
-  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const'))))]))]), // return type
+  param ? [// props
+  param] : [], // body
+  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), actionValue)]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))), false), null, null, false, // static
   true);
 };

package/module/msg-builder/msg-builder.spec.js

@@ -1,5 +1,6 @@
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
+import ownership from '../../../../__fixtures__/basic/ownership.json';
 import { createMsgBuilderClass } from './msg-builder';
 import { expectCode, makeContext } from '../../test-utils';
 it('execute class', () => {
@@ -7,6 +8,10 @@ it('execute class', () => {
   expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', execute_msg));
 });
 it('query class', () => {
-  const ctx = makeContext(execute_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', query_msg));
+});
+it('ownership', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMsgBuilderClass(ctx, 'Ownership', ownership));
 });

package/module/react-query/react-query.spec.js

@@ -1,6 +1,7 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import ownership from '../../../../__fixtures__/basic/ownership.json';
 import { createReactQueryHooks, createReactQueryMutationHooks } from './react-query';
 import { expectCode, makeContext } from '../../test-utils';
 const execCtx = makeContext(execute_msg);
@@ -62,4 +63,13 @@ it('createReactQueryHooks', () => {
     contractName: 'Sg721',
     ExecuteClient: 'Sg721Client'
   })));
+});
+it('ownership', () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(t.program(createReactQueryMutationHooks({
+    context: ownershipCtx,
+    execMsg: ownership,
+    contractName: 'Ownership',
+    ExecuteClient: 'OwnershipClient'
+  })));
 });

package/module/utils/types.js

@@ -322,9 +322,16 @@ export const createTypedObjectParams = (context, jsonschema, camelize = true) =>
   if (!keys.length) {
     // is there a ref?
     if (jsonschema.$ref) {
-      const obj = context.refLookup(jsonschema.$ref);
-
-      if (obj) {
+      const obj = context.refLookup(jsonschema.$ref); // If there is a oneOf, then we need to create a type for it
+
+      if (obj?.oneOf) {
+        // the actual type of the ref
+        const refType = jsonschema.$ref.split('/').pop();
+        const refName = camel(refType);
+        const id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id;
+      } else if (obj) {
         return createTypedObjectParams(context, obj, camelize);
       }
     } // no results...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "CosmWasm TypeScript AST generation",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/pyramation/cosmwasm-typescript-gen/tree/master/packages/wasm-ast-types#readme",
@@ -88,5 +88,5 @@
     "case": "1.6.3",
     "deepmerge": "4.2.2"
   },
-  "gitHead": "dccd0edd182dc4d5e58b30e7f46732e0be483bc1"
+  "gitHead": "d2edba320c63e2db5fe2db0bfb1f4cd5e44f2188"
 }

package/src/client/client.ts

@@ -1,23 +1,19 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel } from 'case';
 import {
+  arrowFunctionExpression,
   bindMethod,
-  typedIdentifier,
-  promiseTypeAnnotation,
   classDeclaration,
   classProperty,
-  arrowFunctionExpression,
-  getMessageProperties
-} from '../utils'
+  getMessageProperties,
+  promiseTypeAnnotation,
+  typedIdentifier
+} from '../utils';
 
-import {
-  QueryMsg,
-  ExecuteMsg
-} from '../types';
+import { ExecuteMsg, JSONSchema, QueryMsg } from '../types';
 
-import { getPropertyType, getType, createTypedObjectParams, getResponseType } from '../utils/types';
+import { createTypedObjectParams, getPropertyType, getResponseType, getType } from '../utils/types';
 import { RenderContext } from '../context';
-import { JSONSchema } from '../types';
 import { identifier, propertySignature } from '../utils/babel';
 
 export const CONSTANT_EXEC_PARAMS = [
@@ -89,7 +85,7 @@ export const createWasmQueryMethod = (
   const methodName = camel(underscoreName);
   const responseType = getResponseType(context, underscoreName);
 
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -99,13 +95,14 @@ export const createWasmQueryMethod = (
     jsonschema.properties[underscoreName]
   );
 
-  const actionArg =
-    t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
+  const msgAction = t.identifier(underscoreName);
+  // If the param is an identifier, we can just use it as is
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args)
 
   return t.classProperty(
     t.identifier(methodName),
     arrowFunctionExpression(
-      obj ? [obj] : [],
+      param ? [param] : [],
       t.blockStatement(
         [
           t.returnStatement(
@@ -120,7 +117,7 @@ export const createWasmQueryMethod = (
               [
                 t.memberExpression(t.thisExpression(), t.identifier('contractAddress')),
                 t.objectExpression([
-                  actionArg
+                  t.objectProperty(msgAction, msgActionValue)
                 ])
               ]
             )
@@ -237,9 +234,15 @@ export const getWasmMethodArgs = (
   // only 1 degree $ref-lookup
   if (!keys.length && jsonschema.$ref) {
     const obj = context.refLookup(jsonschema.$ref);
+    // properties
     if (obj) {
       keys = Object.keys(obj.properties ?? {})
     }
+
+    // tuple struct or otherwise, use the name of the reference
+    if (!keys.length && obj?.oneOf) {
+// TODO????? ADAIR
+    }
   }
 
   const args = keys.map(prop => {
@@ -265,7 +268,7 @@ export const createWasmExecMethod = (
 
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -274,12 +277,16 @@ export const createWasmExecMethod = (
     jsonschema.properties[underscoreName]
   );
 
+  const msgAction = t.identifier(underscoreName);
+  // If the param is an identifier, we can just use it as is
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args)
+
   return t.classProperty(
     t.identifier(methodName),
     arrowFunctionExpression(
-      obj ? [
+      param ? [
         // props
-        obj,
+        param,
         ...CONSTANT_EXEC_PARAMS
       ] : CONSTANT_EXEC_PARAMS,
       t.blockStatement(
@@ -306,10 +313,8 @@ export const createWasmExecMethod = (
                   t.objectExpression(
                     [
                       t.objectProperty(
-                        t.identifier(underscoreName),
-                        t.objectExpression([
-                          ...args
-                        ])
+                        msgAction,
+                        msgActionValue
                       )
 
                     ]

package/src/client/test/__snapshots__/ts-client.issue-101.spec.ts.snap

@@ -0,0 +1,47 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`execute interfaces no extends 1`] = `
+"export interface OwnershipInstance {
+  contractAddress: string;
+  sender: string;
+  setFactory: ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  updateOwnership: (action: Action, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+}"
+`;
+
+exports[`ownership client with tuple 1`] = `
+"export class OwnershipClient implements OwnershipInstance {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.setFactory = this.setFactory.bind(this);
+    this.updateOwnership = this.updateOwnership.bind(this);
+  }
+
+  setFactory = async ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      set_factory: {
+        new_factory: newFactory
+      }
+    }, fee, memo, funds);
+  };
+  updateOwnership = async (action: Action, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      update_ownership: action
+    }, fee, memo, funds);
+  };
+}"
+`;

package/src/client/test/__snapshots__/ts-client.vectis.spec.ts.snap

@@ -193,9 +193,9 @@ exports[`query classes 1`] = `
     this.wasm = this.wasm.bind(this);
   }
 
-  bank = async (): Promise<BankResponse> => {
+  bank = async (bankMsg: BankMsg): Promise<BankResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      bank: {}
+      bank: bankMsg
     });
   };
   custom = async (): Promise<CustomResponse> => {
@@ -203,19 +203,19 @@ exports[`query classes 1`] = `
       custom: {}
     });
   };
-  staking = async (): Promise<StakingResponse> => {
+  staking = async (stakingMsg: StakingMsg): Promise<StakingResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      staking: {}
+      staking: stakingMsg
     });
   };
-  distribution = async (): Promise<DistributionResponse> => {
+  distribution = async (distributionMsg: DistributionMsg): Promise<DistributionResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      distribution: {}
+      distribution: distributionMsg
     });
   };
-  wasm = async (): Promise<WasmResponse> => {
+  wasm = async (wasmMsg: WasmMsg): Promise<WasmResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      wasm: {}
+      wasm: wasmMsg
     });
   };
 }"

package/src/client/test/ts-client.issue-101.spec.ts

@@ -0,0 +1,37 @@
+import { createExecuteClass, createExecuteInterface } from '../client';
+import { expectCode, makeContext } from '../../../test-utils';
+import ownership from '../../../../../__fixtures__/basic/ownership.json';
+
+
+// it('query classes', () => {
+//     const ctx = makeContext(cosmos_msg_for__empty);
+//     expectCode(createQueryClass(
+//         ctx,
+//         'SG721QueryClient',
+//         'SG721ReadOnlyInstance',
+//         cosmos_msg_for__empty
+//     ))
+// });
+
+it('execute interfaces no extends', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createExecuteInterface(
+    ctx,
+    'OwnershipInstance',
+    null,
+    ownership
+  ))
+});
+
+it('ownership client with tuple', () => {
+    const ctx = makeContext(ownership);
+    expectCode(createExecuteClass(
+        ctx,
+        'OwnershipClient',
+        'OwnershipInstance',
+        null,
+        ownership
+    ))
+});
+
+

package/src/message-composer/__snapshots__/message-composer.spec.ts.snap

@@ -269,3 +269,63 @@ exports[`execute classes 1`] = `
   };
 }"
 `;
+
+exports[`ownershipClass 1`] = `
+"export class OwnershipMessageComposer implements OwnershipMessage {
+  sender: string;
+  contractAddress: string;
+
+  constructor(sender: string, contractAddress: string) {
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.setFactory = this.setFactory.bind(this);
+    this.updateOwnership = this.updateOwnership.bind(this);
+  }
+
+  setFactory = ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          set_factory: {
+            new_factory: newFactory
+          }
+        })),
+        funds
+      })
+    };
+  };
+  updateOwnership = (action: Action, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          update_ownership: action
+        })),
+        funds
+      })
+    };
+  };
+}"
+`;
+
+exports[`ownershipInterface 1`] = `
+"export interface OwnershipMessage {
+  contractAddress: string;
+  sender: string;
+  setFactory: ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  updateOwnership: (action: Action, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+}"
+`;

package/src/message-composer/message-composer.spec.ts

@@ -1,25 +1,46 @@
-import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import execute_msg from "../../../../__fixtures__/basic/execute_msg_for__empty.json";
+import ownership from "../../../../__fixtures__/basic/ownership.json";
+
 import {
-    createMessageComposerClass,
-    createMessageComposerInterface
-} from './message-composer'
-import { expectCode, makeContext } from '../../test-utils';
+  createMessageComposerClass,
+  createMessageComposerInterface,
+} from "./message-composer";
+import { expectCode, makeContext } from "../../test-utils";
+import * as t from "@babel/types";
+import { createReactQueryMutationHooks } from "../react-query";
+
+it("execute classes", () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(
+    createMessageComposerClass(
+      ctx,
+      "SG721MessageComposer",
+      "SG721Message",
+      execute_msg
+    )
+  );
+});
+
+it("createMessageComposerInterface", () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createMessageComposerInterface(ctx, "SG721Message", execute_msg));
+});
 
-it('execute classes', () => {
-    const ctx = makeContext(execute_msg);
-    expectCode(createMessageComposerClass(
-        ctx,
-        'SG721MessageComposer',
-        'SG721Message',
-        execute_msg
-    ))
+it("ownershipClass", () => {
+  const ctx = makeContext(ownership);
+  expectCode(
+    createMessageComposerClass(
+      ctx,
+      "OwnershipMessageComposer",
+      "OwnershipMessage",
+      ownership
+    )
+  );
 });
 
-it('createMessageComposerInterface', () => {
-    const ctx = makeContext(execute_msg);
-    expectCode(createMessageComposerInterface(
-        ctx,
-        'SG721Message',
-        execute_msg
-    ))
+it("ownershipInterface", () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(
+    createMessageComposerInterface(ownershipCtx, "OwnershipMessage", ownership)
+  );
 });

package/src/message-composer/message-composer.ts

@@ -14,6 +14,7 @@ import { JSONSchema } from '../types';
 import { RenderContext } from '../context';
 import { identifier } from '../utils/babel';
 import { getWasmMethodArgs } from '../client/client';
+import { Expression } from '@babel/types';
 
 const createWasmExecMethodMessageComposer = (
     context: RenderContext,
@@ -27,12 +28,20 @@ const createWasmExecMethodMessageComposer = (
 
     const underscoreName = Object.keys(jsonschema.properties)[0];
     const methodName = camel(underscoreName);
-    const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
     const args = getWasmMethodArgs(
         context,
         jsonschema.properties[underscoreName]
     );
 
+  // what the underscore named property in the message is assigned to
+  let actionValue: Expression
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.objectExpression(args)
+  }
+
     const constantParams = [
         identifier('funds', t.tsTypeAnnotation(
             t.tsArrayType(
@@ -46,9 +55,9 @@ const createWasmExecMethodMessageComposer = (
     return t.classProperty(
         t.identifier(methodName),
         arrowFunctionExpression(
-            obj ? [
+            param ? [
                 // props
-                obj,
+                param,
                 ...constantParams
             ] : constantParams,
             t.blockStatement(
@@ -95,10 +104,9 @@ const createWasmExecMethodMessageComposer = (
                                                             ),
                                                             [
                                                                 t.objectExpression(
-
                                                                     [
                                                                         t.objectProperty(
-                                                                            t.identifier(underscoreName), t.objectExpression(args)
+                                                                            t.identifier(underscoreName), actionValue
                                                                         )
                                                                     ]
 

package/src/msg-builder/__snapshots__/msg-builder.spec.ts.snap

@@ -113,6 +113,27 @@ exports[`execute class 1`] = `
 }"
 `;
 
+exports[`ownership 1`] = `
+"export abstract class Ownership {
+  static setFactory = ({
+    newFactory
+  }: CamelCasedProperties<Extract<ExecuteMsg, {
+    set_factory: unknown;
+  }>[\\"set_factory\\"]>): ExecuteMsg => {
+    return {
+      set_factory: ({
+        new_factory: newFactory
+      } as const)
+    };
+  };
+  static updateOwnership = (action: Action): ExecuteMsg => {
+    return {
+      update_ownership: action
+    };
+  };
+}"
+`;
+
 exports[`query class 1`] = `
 "export abstract class SG721MsgBuilder {
   static ownerOf = ({

package/src/msg-builder/msg-builder.spec.ts

@@ -1,9 +1,12 @@
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
+import ownership from '../../../../__fixtures__/basic/ownership.json';
+
 import {
     createMsgBuilderClass,
 } from './msg-builder'
 import { expectCode, makeContext } from '../../test-utils';
+import { findExecuteMsg } from '@cosmwasm/ts-codegen/src';
 
 it('execute class', () => {
     const ctx = makeContext(execute_msg);
@@ -12,6 +15,11 @@ it('execute class', () => {
 
 
 it('query class', () => {
-  const ctx = makeContext(execute_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', query_msg))
 });
+
+it('ownership', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMsgBuilderClass(ctx, 'Ownership', ownership))
+});

package/src/msg-builder/msg-builder.ts

@@ -1,16 +1,11 @@
-import * as t from "@babel/types";
-import { camel } from "case";
-import {
-  abstractClassDeclaration,
-  arrowFunctionExpression,
-  bindMethod,
-  classDeclaration,
-  getMessageProperties,
-} from "../utils";
-import { ExecuteMsg, QueryMsg } from "../types";
-import { createTypedObjectParams } from "../utils/types";
-import { RenderContext } from "../context";
-import { getWasmMethodArgs } from "../client/client";
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { ExecuteMsg, QueryMsg } from '../types';
+import { createTypedObjectParams } from '../utils/types';
+import { RenderContext } from '../context';
+import { getWasmMethodArgs } from '../client/client';
+import { Expression, Identifier, PatternLike, TSAsExpression } from '@babel/types';
 
 export const createMsgBuilderClass = (
   context: RenderContext,
@@ -34,10 +29,10 @@ export const createMsgBuilderClass = (
 function createExtractTypeAnnotation(underscoreName: string, msgTitle: string) {
   return t.tsTypeAnnotation(
     t.tsTypeReference(
-      t.identifier("CamelCasedProperties"),
+      t.identifier('CamelCasedProperties'),
       t.tsTypeParameterInstantiation([
         t.tsIndexedAccessType(
-          t.tsTypeReference(t.identifier("Extract"),
+          t.tsTypeReference(t.identifier('Extract'),
             t.tsTypeParameterInstantiation([
               t.tsTypeReference(t.identifier(msgTitle)),
               t.tsTypeLiteral([
@@ -62,7 +57,7 @@ const createStaticExecMethodMsgBuilder = (
 ) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -71,17 +66,34 @@ const createStaticExecMethodMsgBuilder = (
     jsonschema.properties[underscoreName]
   );
 
-  if (obj) obj.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle)
+  // what the underscore named property in the message is assigned to
+  let actionValue: Expression
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
+  }
+
+
+  // TODO: this is a hack to get the type annotation to work
+  // all type annotations in the future should be the extracted and camelized type
+  if (
+    param &&
+    param.typeAnnotation.type === 'TSTypeAnnotation' &&
+    param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral'
+  ) {
+      param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  }
 
   return t.classProperty(
     t.identifier(methodName),
     arrowFunctionExpression(
       // params
-      obj
+      param
         ? [
-            // props
-            obj,
-          ]
+          // props
+          param
+        ]
         : [],
       // body
       t.blockStatement([
@@ -89,10 +101,10 @@ const createStaticExecMethodMsgBuilder = (
           t.objectExpression([
             t.objectProperty(
               t.identifier(underscoreName),
-              t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')))
-            ),
+              actionValue
+            )
           ])
-        ),
+        )
       ]),
       // return type
       t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))),

package/src/react-query/__snapshots__/react-query.spec.ts.snap

@@ -1312,3 +1312,48 @@ export function useSg721TransferNftMutation(options?: Omit<UseMutationOptions<Ex
   }) => client.transferNft(msg, fee, memo, funds), options);
 }"
 `;
+
+exports[`ownership 1`] = `
+"export interface OwnershipUpdateOwnershipMutation {
+  client: OwnershipClient;
+  msg: Action;
+  args?: {
+    fee?: number | StdFee | \\"auto\\";
+    memo?: string;
+    funds?: Coin[];
+  };
+}
+export function useOwnershipUpdateOwnershipMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, OwnershipUpdateOwnershipMutation>, \\"mutationFn\\">) {
+  return useMutation<ExecuteResult, Error, OwnershipUpdateOwnershipMutation>(({
+    client,
+    msg,
+    args: {
+      fee,
+      memo,
+      funds
+    } = {}
+  }) => client.updateOwnership(msg, fee, memo, funds), options);
+}
+export interface OwnershipSetFactoryMutation {
+  client: OwnershipClient;
+  msg: {
+    newFactory: string;
+  };
+  args?: {
+    fee?: number | StdFee | \\"auto\\";
+    memo?: string;
+    funds?: Coin[];
+  };
+}
+export function useOwnershipSetFactoryMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, OwnershipSetFactoryMutation>, \\"mutationFn\\">) {
+  return useMutation<ExecuteResult, Error, OwnershipSetFactoryMutation>(({
+    client,
+    msg,
+    args: {
+      fee,
+      memo,
+      funds
+    } = {}
+  }) => client.setFactory(msg, fee, memo, funds), options);
+}"
+`;

package/src/react-query/react-query.spec.ts

@@ -1,13 +1,15 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import { RenderContext } from '../context';
+import ownership from '../../../../__fixtures__/basic/ownership.json';
+
 
 import {
   createReactQueryHooks,
   createReactQueryMutationHooks,
 } from './react-query'
 import { expectCode, makeContext } from '../../test-utils';
+import { createMsgBuilderClass } from '../msg-builder';
 
 const execCtx = makeContext(execute_msg);
 const queryCtx = makeContext(query_msg);
@@ -90,3 +92,17 @@ it('createReactQueryHooks', () => {
     )))
 });
 
+it('ownership', () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(t.program(
+    createReactQueryMutationHooks(
+      {
+        context: ownershipCtx,
+        execMsg: ownership,
+        contractName: 'Ownership',
+        ExecuteClient: 'OwnershipClient',
+      }
+    )))
+});
+
+

package/src/utils/types.ts

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel, pascal, snake } from 'case';
 import { propertySignature } from './babel';
 import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
@@ -425,15 +425,22 @@ export const createTypedObjectParams = (
   context: RenderContext,
   jsonschema: JSONSchema,
   camelize: boolean = true
-): t.ObjectPattern => {
+): (t.Identifier | t.Pattern | t.RestElement) => {
 
   const keys = Object.keys(jsonschema.properties ?? {});
   if (!keys.length) {
-
     // is there a ref?
     if (jsonschema.$ref) {
       const obj = context.refLookup(jsonschema.$ref);
-      if (obj) {
+      // If there is a oneOf, then we need to create a type for it
+      if (obj?.oneOf) {
+        // the actual type of the ref
+        const refType = jsonschema.$ref.split('/').pop();
+        const refName = camel(refType);
+        const id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id
+      } else if (obj) {
         return createTypedObjectParams(
           context,
           obj,