Amino bigint array

packages/ast/src/encoding/proto/from-amino/index.ts

@@ -57,15 +57,15 @@ export const fromAminoJSONMethodFields = (context: ProtoParseContext, name: stri
                 case 'sfixed32':
                     return fromAminoJSON.array(args, arrayTypes.sfixed32());
                 case 'int64':
-                    return fromAminoJSON.array(args, arrayTypes.int64());
+                    return fromAminoJSON.array(args, arrayTypes.int64(args));
                 case 'sint64':
-                    return fromAminoJSON.array(args, arrayTypes.sint64());
+                    return fromAminoJSON.array(args, arrayTypes.sint64(args));
                 case 'uint64':
-                    return fromAminoJSON.array(args, arrayTypes.uint64());
+                    return fromAminoJSON.array(args, arrayTypes.uint64(args));
                 case 'fixed64':
-                    return fromAminoJSON.array(args, arrayTypes.fixed64());
+                    return fromAminoJSON.array(args, arrayTypes.fixed64(args));
                 case 'sfixed64':
-                    return fromAminoJSON.array(args, arrayTypes.sfixed64());
+                    return fromAminoJSON.array(args, arrayTypes.sfixed64(args));
                 default:
                     switch (field.parsedType.type) {
                         case 'Enum':

packages/ast/src/encoding/proto/from-amino/utils.ts

@@ -610,23 +610,23 @@ export const arrayTypes = {
         return arrayTypes.scalar();
     },
 
-    long() {
-        return arrayTypes.scalar();
+    long(args: FromAminoJSONMethod) {
+      return TypeLong.getFromStringArray(args.context);
     },
-    uint64() {
-        return arrayTypes.scalar();
+    uint64(args: FromAminoJSONMethod) {
+        return arrayTypes.long(args);
     },
-    int64() {
-        return arrayTypes.scalar();
+    int64(args: FromAminoJSONMethod) {
+        return arrayTypes.long(args);
     },
-    sint64() {
-        return arrayTypes.scalar();
+    sint64(args: FromAminoJSONMethod) {
+        return arrayTypes.long(args);
     },
-    fixed64() {
-        return arrayTypes.scalar();
+    fixed64(args: FromAminoJSONMethod) {
+        return arrayTypes.long(args);
     },
-    sfixed64() {
-        return arrayTypes.scalar();
+    sfixed64(args: FromAminoJSONMethod) {
+        return arrayTypes.long(args);
     },
     number() {
         return arrayTypes.scalar();

packages/ast/src/encoding/proto/to-amino/utils.ts

@@ -577,7 +577,7 @@ export const arrayTypes = {
         return arrayTypes.number();
     },
     long(args: ToAminoJSONMethod) {
-        return arrayTypes.scalar();
+        return TypeLong.getToStringArray(args.context);
     },
     int64(args: ToAminoJSONMethod) {
         return arrayTypes.long(args);

packages/ast/src/utils/type-long-expression.ts

@@ -21,6 +21,19 @@ export const TypeLong = {
     long: t.identifier('Long')
   },
 
+  fromStringArray: {
+    bigint: t.callExpression(t.identifier('BigInt'), [t.identifier('e')]),
+    long: t.identifier('e')
+  },
+
+  toStringArray: {
+    bigint: t.callExpression(
+      t.memberExpression(t.identifier('e'), t.identifier('toString')),
+      []
+    ),
+    long: t.identifier('e')
+  },
+
   uzeroExpressions: {
     bigint: t.callExpression(t.identifier('BigInt'), [t.numericLiteral(0)]),
     long: t.memberExpression(t.identifier('Long'), t.identifier('UZERO'))
@@ -68,6 +81,14 @@ export const TypeLong = {
     return TypeLong.getNode(ctx, TypeLong.types);
   },
 
+  getFromStringArray: (ctx: GenericParseContext): t.Expression => {
+    return TypeLong.getNode(ctx, TypeLong.fromStringArray);
+  },
+
+  getToStringArray: (ctx: GenericParseContext): t.Expression => {
+    return TypeLong.getNode(ctx, TypeLong.toStringArray);
+  },
+
   getPropIdentifier: (ctx: GenericParseContext): t.Identifier => {
     return TypeLong.getNode(ctx, TypeLong.propIdentifiers);
   },
@@ -103,7 +124,7 @@ export const TypeLong = {
             []
           )
         );
-      break;
+        break;
 
       case 'long':
         args.push(arg);

packages/ast/types/src/encoding/proto/from-amino/utils.d.ts

@@ -38,12 +38,12 @@ export declare const arrayTypes: {
     string(): t.Identifier;
     bool(): t.Identifier;
     bytes(args: FromAminoJSONMethod): t.Identifier;
-    long(): t.Identifier;
-    uint64(): t.Identifier;
-    int64(): t.Identifier;
-    sint64(): t.Identifier;
-    fixed64(): t.Identifier;
-    sfixed64(): t.Identifier;
+    long(args: FromAminoJSONMethod): t.Expression;
+    uint64(args: FromAminoJSONMethod): t.Expression;
+    int64(args: FromAminoJSONMethod): t.Expression;
+    sint64(args: FromAminoJSONMethod): t.Expression;
+    fixed64(args: FromAminoJSONMethod): t.Expression;
+    sfixed64(args: FromAminoJSONMethod): t.Expression;
     number(): t.Identifier;
     uint32(): t.Identifier;
     int32(): t.Identifier;

packages/ast/types/src/encoding/proto/to-amino/utils.d.ts

@@ -45,12 +45,12 @@ export declare const arrayTypes: {
     sint32(): t.Identifier;
     fixed32(): t.Identifier;
     sfixed32(): t.Identifier;
-    long(args: ToAminoJSONMethod): t.Identifier;
-    int64(args: ToAminoJSONMethod): t.Identifier;
-    uint64(args: ToAminoJSONMethod): t.Identifier;
-    sint64(args: ToAminoJSONMethod): t.Identifier;
-    fixed64(args: ToAminoJSONMethod): t.Identifier;
-    sfixed64(args: ToAminoJSONMethod): t.Identifier;
+    long(args: ToAminoJSONMethod): t.Expression;
+    int64(args: ToAminoJSONMethod): t.Expression;
+    uint64(args: ToAminoJSONMethod): t.Expression;
+    sint64(args: ToAminoJSONMethod): t.Expression;
+    fixed64(args: ToAminoJSONMethod): t.Expression;
+    sfixed64(args: ToAminoJSONMethod): t.Expression;
     bytes(args: ToAminoJSONMethod): t.Identifier;
     enum(args: ToAminoJSONMethod): t.CallExpression;
     anyType(args: ToAminoJSONMethod): t.ConditionalExpression;

packages/test/src/test-lcd-balance.ts

@@ -1,17 +1,33 @@
-import { LCDClient } from "@osmonauts/lcd";
-import { cosmos } from "./codegen";
+import { LCDClient } from '@osmonauts/lcd';
+import { cosmos } from './codegen';
+import { createRPCQueryClient } from './codegen/cosmos/rpc.query';
+import { PageRequest } from './codegen/cosmos/base/query/v1beta1/pagination';
 
-const REST_ENDPOINT = 'https://rest.cosmos.directory/osmosis'
+const REST_ENDPOINT = 'https://rest.cosmos.directory/osmosis';
 
 export const main = async () => {
-    const requestClient = new LCDClient({ restEndpoint: REST_ENDPOINT });
-    const client = new cosmos.bank.v1beta1.LCDQueryClient({ requestClient });
-    const pools = await client.allBalances({
-        address: 'osmo19mywfjzj324w5ukf7ss6jak0dg9hnljfp0rfx4'
-    })
-    console.log(pools);
+  const requestClient = new LCDClient({ restEndpoint: REST_ENDPOINT });
+  const bankClient = new cosmos.bank.v1beta1.LCDQueryClient({ requestClient });
+  const pools = await bankClient.allBalances({
+      address: 'osmo19mywfjzj324w5ukf7ss6jak0dg9hnljfp0rfx4'
+  })
+  console.log(pools);
+
+  const balance = await bankClient.balance({
+    address: 'osmo19mywfjzj324w5ukf7ss6jak0dg9hnljfp0rfx4',
+    denom: 'uatom',
+  })
+  console.log(balance);
+
+  const authClient = new cosmos.auth.v1beta1.LCDQueryClient({ requestClient });
+
+  const accounts = await authClient.accounts({
+    pagination: PageRequest.fromPartial({})
+  });
+
+  console.log(accounts)
 };
 
 main().then(() => {
-    console.log('all done')
-})
+  console.log('all done');
+});