@agoric/orchestration 0.2.0-upgrade-17-dev-a1453b2.0 → 0.2.0-upgrade-18-dev-bf39b10.0

package/src/exos/cosmos-orchestration-account.js

@@ -1,16 +1,34 @@
 /** @file Use-object for the owner of a staking account */
 import { toRequestQueryJson } from '@agoric/cosmic-proto';
 import {
-  QueryBalanceRequest,
-  QueryBalanceResponse,
   QueryAllBalancesRequest,
   QueryAllBalancesResponse,
+  QueryBalanceRequest,
+  QueryBalanceResponse,
 } from '@agoric/cosmic-proto/cosmos/bank/v1beta1/query.js';
 import { MsgSend } from '@agoric/cosmic-proto/cosmos/bank/v1beta1/tx.js';
+import {
+  QueryDelegationRewardsRequest,
+  QueryDelegationRewardsResponse,
+  QueryDelegationTotalRewardsRequest,
+  QueryDelegationTotalRewardsResponse,
+} from '@agoric/cosmic-proto/cosmos/distribution/v1beta1/query.js';
 import {
   MsgWithdrawDelegatorReward,
   MsgWithdrawDelegatorRewardResponse,
 } from '@agoric/cosmic-proto/cosmos/distribution/v1beta1/tx.js';
+import {
+  QueryDelegationRequest,
+  QueryDelegationResponse,
+  QueryDelegatorDelegationsRequest,
+  QueryDelegatorDelegationsResponse,
+  QueryDelegatorUnbondingDelegationsRequest,
+  QueryDelegatorUnbondingDelegationsResponse,
+  QueryRedelegationsRequest,
+  QueryRedelegationsResponse,
+  QueryUnbondingDelegationRequest,
+  QueryUnbondingDelegationResponse,
+} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/query.js';
 import {
   MsgBeginRedelegate,
   MsgDelegate,
@@ -36,19 +54,22 @@ import {
 import { coerceCoin, coerceDenom } from '../utils/amounts.js';
 import {
   maxClockSkew,
-  tryDecodeResponse,
+  toCosmosDelegationResponse,
+  toCosmosValidatorAddress,
   toDenomAmount,
+  toTruncatedDenomAmount,
+  tryDecodeResponse,
 } from '../utils/cosmos.js';
 import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
 import { makeTimestampHelper } from '../utils/time.js';
 
 /**
  * @import {HostOf} from '@agoric/async-flow';
- * @import {AmountArg, IcaAccount, ChainAddress, CosmosValidatorAddress, ICQConnection, StakingAccountActions, DenomAmount, OrchestrationAccountI, IBCConnectionInfo, IBCMsgTransferOptions, ChainHub} from '../types.js';
+ * @import {AmountArg, IcaAccount, ChainAddress, CosmosValidatorAddress, ICQConnection, StakingAccountActions, StakingAccountQueries, OrchestrationAccountI, CosmosRewardsResponse, IBCConnectionInfo, IBCMsgTransferOptions, ChainHub, CosmosDelegationResponse} from '../types.js';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js';
  * @import {Coin} from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
- * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  * @import {Remote} from '@agoric/internal';
+ * @import {DelegationResponse} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  * @import {InvitationMakers} from '@agoric/smart-wallet/src/types.js';
  * @import {TimerService} from '@agoric/time';
  * @import {Vow, VowTools} from '@agoric/vow';
@@ -89,20 +110,37 @@ const { Vow$ } = NetworkShape; // TODO #9611
  * }} CosmosOrchestrationAccountStorageState
  */
 
-/** @see {OrchestrationAccountI} */
-export const IcaAccountHolderI = M.interface('IcaAccountHolder', {
-  ...orchestrationAccountMethods,
+/** @see {StakingAccountActions} */
+const stakingAccountActionsMethods = {
   delegate: M.call(ChainAddressShape, AmountArgShape).returns(VowShape),
   redelegate: M.call(
     ChainAddressShape,
     ChainAddressShape,
     AmountArgShape,
   ).returns(VowShape),
+  undelegate: M.call(M.arrayOf(DelegationShape)).returns(VowShape),
   withdrawReward: M.call(ChainAddressShape).returns(
     Vow$(M.arrayOf(DenomAmountShape)),
   ),
   withdrawRewards: M.call().returns(Vow$(M.arrayOf(DenomAmountShape))),
-  undelegate: M.call(M.arrayOf(DelegationShape)).returns(VowShape),
+};
+
+/** @see {StakingAccountQueries} */
+const stakingAccountQueriesMethods = {
+  getDelegation: M.call(ChainAddressShape).returns(VowShape),
+  getDelegations: M.call().returns(VowShape),
+  getUnbondingDelegation: M.call(ChainAddressShape).returns(VowShape),
+  getUnbondingDelegations: M.call().returns(VowShape),
+  getRedelegations: M.call().returns(VowShape),
+  getReward: M.call(ChainAddressShape).returns(VowShape),
+  getRewards: M.call().returns(VowShape),
+};
+
+/** @see {OrchestrationAccountI} */
+export const IcaAccountHolderI = M.interface('IcaAccountHolder', {
+  ...orchestrationAccountMethods,
+  ...stakingAccountActionsMethods,
+  ...stakingAccountQueriesMethods,
   deactivate: M.call().returns(VowShape),
   reactivate: M.call().returns(VowShape),
 });
@@ -198,6 +236,46 @@ export const prepareCosmosOrchestrationAccountKit = (
           })
           .returns(Vow$(M.record())),
       }),
+      delegationQueryWatcher: M.interface('delegationQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(M.record()),
+      }),
+      delegationsQueryWatcher: M.interface('delegationsQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(
+          M.arrayOf(M.record()),
+        ),
+      }),
+      unbondingDelegationQueryWatcher: M.interface(
+        'unbondingDelegationQueryWatcher',
+        {
+          onFulfilled: M.call(M.arrayOf(M.record())).returns(M.record()),
+        },
+      ),
+      unbondingDelegationsQueryWatcher: M.interface(
+        'unbondingDelegationsQueryWatcher',
+        {
+          onFulfilled: M.call(M.arrayOf(M.record())).returns(
+            M.arrayOf(M.record()),
+          ),
+        },
+      ),
+      redelegationQueryWatcher: M.interface('redelegationQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(
+          M.arrayOf(M.record()),
+        ),
+      }),
+      redelegationsQueryWatcher: M.interface('redelegationsQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(
+          M.arrayOf(M.record()),
+        ),
+      }),
+      rewardQueryWatcher: M.interface('rewardQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(
+          M.arrayOf(M.record()),
+        ),
+      }),
+      rewardsQueryWatcher: M.interface('rewardsQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record())).returns(M.record()),
+      }),
       holder: IcaAccountHolderI,
       invitationMakers: CosmosOrchestrationInvitationMakersI,
     },
@@ -273,6 +351,134 @@ export const prepareCosmosOrchestrationAccountKit = (
           return harden(toDenomAmount(balance));
         },
       },
+      delegationQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosDelegationResponse}
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { delegationResponse } = QueryDelegationResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!delegationResponse)
+            throw Fail`Result lacked delegationResponse key: ${result}`;
+          const { chainAddress } = this.state;
+          return harden(
+            toCosmosDelegationResponse(chainAddress, delegationResponse),
+          );
+        },
+      },
+      delegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosDelegationResponse[]}
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { delegationResponses } =
+            QueryDelegatorDelegationsResponse.decode(decodeBase64(result.key));
+          if (!delegationResponses)
+            throw Fail`Result lacked delegationResponses key: ${result}`;
+          const { chainAddress } = this.state;
+          return harden(
+            delegationResponses.map(r =>
+              toCosmosDelegationResponse(chainAddress, r),
+            ),
+          );
+        },
+      },
+      unbondingDelegationQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { unbond } = QueryUnbondingDelegationResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!unbond) throw Fail`Result lacked unbond key: ${result}`;
+          return harden(unbond);
+        },
+      },
+      unbondingDelegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { unbondingResponses } =
+            QueryDelegatorUnbondingDelegationsResponse.decode(
+              decodeBase64(result.key),
+            );
+          if (!unbondingResponses)
+            throw Fail`Result lacked unbondingResponses key: ${result}`;
+          return harden(unbondingResponses);
+        },
+      },
+      redelegationQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { redelegationResponses } = QueryRedelegationsResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!redelegationResponses)
+            throw Fail`Result lacked redelegationResponses key: ${result}`;
+          return harden(redelegationResponses);
+        },
+      },
+      redelegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { redelegationResponses } = QueryRedelegationsResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!redelegationResponses)
+            throw Fail`Result lacked redelegationResponses key: ${result}`;
+          return harden(redelegationResponses);
+        },
+      },
+      rewardQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { rewards } = QueryDelegationRewardsResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!rewards) throw Fail`Result lacked rewards key: ${result}`;
+          return harden(rewards.map(toTruncatedDenomAmount));
+        },
+      },
+      rewardsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosRewardsResponse}
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { rewards, total } = QueryDelegationTotalRewardsResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!rewards || !total)
+            throw Fail`Result lacked rewards or total key: ${result}`;
+          const { chainAddress } = this.state;
+          return harden({
+            rewards: rewards.map(reward => ({
+              validator: toCosmosValidatorAddress(reward, chainAddress.chainId),
+              reward: reward.reward.map(toTruncatedDenomAmount),
+            })),
+            total: total.map(toTruncatedDenomAmount),
+          });
+        },
+      },
       allBalancesQueryWatcher: {
         /**
          * @param {JsonSafe<ResponseQuery>[]} results
@@ -475,14 +681,14 @@ export const prepareCosmosOrchestrationAccountKit = (
            *   {
            *     amount: AmountArg;
            *     destination: ChainAddress;
-           *     opts: IBCMsgTransferOptions;
+           *     opts?: IBCMsgTransferOptions;
            *   }
            * >}
            */
           const offerHandler = (seat, { amount, destination, opts }) => {
             seat.exit();
             return watch(
-              this.facets.holder.transfer(amount, destination, opts),
+              this.facets.holder.transfer(destination, amount, opts),
             );
           };
           return zcf.makeInvitation(offerHandler, 'Transfer');
@@ -675,8 +881,8 @@ export const prepareCosmosOrchestrationAccountKit = (
         },
 
         /** @type {HostOf<OrchestrationAccountI['transfer']>} */
-        transfer(amount, destination, opts) {
-          trace('transfer', amount, destination, opts);
+        transfer(destination, amount, opts) {
+          trace('transfer', destination, amount, opts);
           return asVow(() => {
             const { helper } = this.facets;
             const token = helper.amountToCoin(amount);
@@ -726,6 +932,10 @@ export const prepareCosmosOrchestrationAccountKit = (
             const { helper } = this.facets;
             const { chainAddress } = this.state;
 
+            delegations.every(d =>
+              d.delegator ? d.delegator.value === chainAddress.value : true,
+            ) || Fail`Some delegation record is for another delegator`;
+
             const undelegateV = watch(
               E(helper.owned()).executeEncodedTx(
                 delegations.map(({ validator, amount }) =>
@@ -751,6 +961,138 @@ export const prepareCosmosOrchestrationAccountKit = (
         reactivate() {
           return watch(E(this.facets.helper.owned()).reactivate());
         },
+        /** @type {HostOf<StakingAccountQueries['getDelegation']>} */
+        getDelegation(validator) {
+          return asVow(() => {
+            trace('getDelegation', validator);
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryDelegationRequest.toProtoMsg({
+                  delegatorAddr: chainAddress.value,
+                  validatorAddr: validator.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.delegationQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getDelegations']>} */
+        getDelegations() {
+          return asVow(() => {
+            trace('getDelegations');
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryDelegatorDelegationsRequest.toProtoMsg({
+                  delegatorAddr: chainAddress.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.delegationsQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getUnbondingDelegation']>} */
+        getUnbondingDelegation(validator) {
+          return asVow(() => {
+            trace('getUnbondingDelegation', validator);
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryUnbondingDelegationRequest.toProtoMsg({
+                  delegatorAddr: chainAddress.value,
+                  validatorAddr: validator.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.unbondingDelegationQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getUnbondingDelegations']>} */
+        getUnbondingDelegations() {
+          return asVow(() => {
+            trace('getUnbondingDelegations');
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryDelegatorUnbondingDelegationsRequest.toProtoMsg({
+                  delegatorAddr: chainAddress.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.unbondingDelegationsQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getRedelegations']>} */
+        getRedelegations() {
+          return asVow(() => {
+            trace('getRedelegations');
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryRedelegationsRequest.toProtoMsg({
+                  delegatorAddr: chainAddress.value,
+                  // These are optional but the protobufs require values to be set
+                  dstValidatorAddr: '',
+                  srcValidatorAddr: '',
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.redelegationsQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getReward']>} */
+        getReward(validator) {
+          return asVow(() => {
+            trace('getReward', validator);
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryDelegationRewardsRequest.toProtoMsg({
+                  delegatorAddress: chainAddress.value,
+                  validatorAddress: validator.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.rewardQueryWatcher);
+          });
+        },
+        /** @type {HostOf<StakingAccountQueries['getRewards']>} */
+        getRewards() {
+          return asVow(() => {
+            trace('getRewards');
+            const { chainAddress, icqConnection } = this.state;
+            if (!icqConnection) {
+              throw Fail`Queries not available for chain ${q(chainAddress.chainId)}`;
+            }
+            const results = E(icqConnection).query([
+              toRequestQueryJson(
+                QueryDelegationTotalRewardsRequest.toProtoMsg({
+                  delegatorAddress: chainAddress.value,
+                }),
+              ),
+            ]);
+            return watch(results, this.facets.rewardsQueryWatcher);
+          });
+        },
       },
     },
   );

package/src/exos/exo-interfaces.d.ts

@@ -1,8 +1,8 @@
 import type { IBCConnectionID } from '@agoric/vats';
 import type { Vow } from '@agoric/vow';
-import type { IcaAccount } from '../cosmos-api.ts';
-import type { ICAChannelAddressOpts } from '../utils/address';
-import type { ICQConnection } from './icq-connection-kit';
+import type { IcaAccount } from '../cosmos-api.js';
+import type { ICAChannelAddressOpts } from '../utils/address.js';
+import type { ICQConnection } from './icq-connection-kit.js';
 /**
  * Authority to make a Cosmos interchain account or an interchain query connection.
  */

package/src/exos/exo-interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exo-interfaces.d.ts","sourceRoot":"","sources":["exo-interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;OAQG;IACH,WAAW,CACT,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,eAAe,EACjC,sBAAsB,EAAE,eAAe,EACvC,IAAI,CAAC,EAAE,qBAAqB,GAAG,SAAS,GACvC,GAAG,CAAC,UAAU,CAAC,CAAC;IACnB;;;;OAIG;IACH,oBAAoB,CAClB,sBAAsB,EAAE,eAAe,EACvC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAC3B,GAAG,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;CACvC"}
+{"version":3,"file":"exo-interfaces.d.ts","sourceRoot":"","sources":["exo-interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;OAQG;IACH,WAAW,CACT,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,eAAe,EACjC,sBAAsB,EAAE,eAAe,EACvC,IAAI,CAAC,EAAE,qBAAqB,GAAG,SAAS,GACvC,GAAG,CAAC,UAAU,CAAC,CAAC;IACnB;;;;OAIG;IACH,oBAAoB,CAClB,sBAAsB,EAAE,eAAe,EACvC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAC3B,GAAG,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;CACvC"}

package/src/exos/exo-interfaces.ts

@@ -1,8 +1,8 @@
 import type { IBCConnectionID } from '@agoric/vats';
 import type { Vow } from '@agoric/vow';
-import type { IcaAccount } from '../cosmos-api.ts';
-import type { ICAChannelAddressOpts } from '../utils/address';
-import type { ICQConnection } from './icq-connection-kit';
+import type { IcaAccount } from '../cosmos-api.js';
+import type { ICAChannelAddressOpts } from '../utils/address.js';
+import type { ICQConnection } from './icq-connection-kit.js';
 
 /**
  * Authority to make a Cosmos interchain account or an interchain query connection.

package/src/exos/ica-account-kit.d.ts

@@ -32,9 +32,9 @@ export function prepareIcaAccountKit(zone: Zone, { watch, asVow }: VowTools): (c
          */
         executeEncodedTx(msgs: AnyJson[], opts?: Omit<TxBody, "messages"> | undefined): Vow<string>;
         /** @type {HostOf<IcaAccount['deactivate']>} */
-        deactivate(): Vow<void extends import("@endo/pass-style").Passable ? void : import("@agoric/async-flow").HostInterface<void>>;
+        deactivate(): Vow<void>;
         /** @type {HostOf<IcaAccount['reactivate']>} */
-        reactivate(): Vow<void extends import("@endo/pass-style").Passable ? void : import("@agoric/async-flow").HostInterface<void>>;
+        reactivate(): Vow<void>;
     };
     connectionHandler: {
         /**

package/src/exos/ica-account-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ica-account-kit.d.ts","sourceRoot":"","sources":["ica-account-kit.js"],"names":[],"mappings":"AA8BA;;;;;;;;;GAWG;AA0BI,2CAJI,IAAI,oBACJ,QAAQ;;QAiCX,0BAA0B;yBAAd,MAAM;;;QAMlB,8BAA8B;sBAAhB,YAAY;;;;;QAyB1B;;;;;;;;;WASG;+BALQ,OAAO,EAAE,gDAEP,IAAI,MAAM,CAAC;QAgBxB,+CAA+C;;QAS/C,+CAA+C;;;;QAiB/C;;;;WAIG;2BAHQ,OAAO,UAAU,CAAC,aAClB,eAAe,cACf,gBAAgB;QAiB3B;;;;;;;;;;;;;;;;WAgBG;6BAHQ,OAAO,UAAU,CAAC,UAClB,OAAO;;GAkBvB;;;;oBAtLU;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,IAAQ,EAAE,IAAI,CAAC;IACf,UAAc,EAAE,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC/C,YAAgB,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,sBAA0B,EAAE,MAAM,CAAC;IACnC,aAAiB,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAChD,YAAgB,EAAE,YAAY,GAAG,SAAS,CAAC;IAC3C,iBAAqB,EAAE,OAAO,CAAC;CAC5B;4BA+KU,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;0BArN1C,mBAAmB;8BAEF,aAAa;0BADlB,iBAAiB;kCAKT,aAAa;yBAJhB,aAAa;6BAC3B,sBAAsB;4BACvB,8CAA8C;gCAHpC,iBAAiB;4BACZ,aAAa;qCAGD,iCAAiC;sCAAjC,iCAAiC"}
+{"version":3,"file":"ica-account-kit.d.ts","sourceRoot":"","sources":["ica-account-kit.js"],"names":[],"mappings":"AA8BA;;;;;;;;;GAWG;AA0BI,2CAJI,IAAI,oBACJ,QAAQ;;QAiCX,0BAA0B;yBAAd,MAAM;;;QAMlB,8BAA8B;sBAAhB,YAAY;;;;;QAyB1B;;;;;;;;;WASG;+BALQ,OAAO,EAAE,gDAEP,IAAI,MAAM,CAAC;QAgBxB,+CAA+C;;QAS/C,+CAA+C;;;;QAiB/C;;;;WAIG;2BAHQ,OAAO,UAAU,CAAC,aAClB,eAAe,cACf,gBAAgB;QAiB3B;;;;;;;;;;;;;;;;WAgBG;6BAHQ,OAAO,UAAU,CAAC,UAClB,OAAO;;GAkBvB;;;;oBAtLU;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC3C,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;IAC1C,sBAAsB,EAAE,MAAM,CAAC;IAC/B,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC5C,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;IACvC,iBAAiB,EAAE,OAAO,CAAC;CAC5B;4BA+KU,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;0BArN1C,mBAAmB;8BAEF,aAAa;0BADlB,iBAAiB;kCAKT,aAAa;yBAJhB,aAAa;6BAC3B,sBAAsB;4BACvB,8CAA8C;gCAHpC,iBAAiB;4BACZ,aAAa;qCAGD,iCAAiC;sCAAjC,iCAAiC"}

package/src/exos/icq-connection-kit.d.ts

@@ -17,7 +17,23 @@ export function prepareICQConnectionKit(zone: Zone, { watch, asVow }: VowTools):
     };
     parseQueryPacketWatcher: {
         /** @param {string} ack packet acknowledgement string */
-        onFulfilled(ack: string): JsonSafe<ResponseQuery>[];
+        onFulfilled(ack: string): {
+            code: number;
+            log: string;
+            info: string;
+            index: string;
+            key: string;
+            value: string;
+            proofOps?: {
+                ops: {
+                    type: string;
+                    key: string;
+                    data: string;
+                }[];
+            } | undefined;
+            height: string;
+            codespace: string;
+        }[];
     };
     connectionHandler: {
         /**

package/src/exos/icq-connection-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AA8BI,8CAJI,IAAI,oBACJ,QAAQ;;;;QAqCX;;;;;WAKG;oBAFQ,SAAS,YAAY,CAAC,EAAE,GACtB,IAAI,SAAS,aAAa,CAAC,EAAE,CAAC;;;QAc3C,wDAAwD;yBAA5C,MAAM;;;QAMlB;;;;WAIG;2BAHQ,OAAO,UAAU,CAAC,aAClB,eAAe,cACf,gBAAgB;;;GAahC;oCArGU;IACZ,IAAQ,EAAE,IAAI,CAAC;IACf,UAAc,EAAE,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC/C,YAAgB,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,aAAiB,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC7C;+BAkGU,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAzHrB,mBAAmB;8BAEF,aAAa;0BADlB,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;yBAFrD,aAAa;gCADlB,iBAAiB;4BACZ,aAAa;qCAGD,iCAAiC;sCAAjC,iCAAiC"}
+{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AA8BI,8CAJI,IAAI,oBACJ,QAAQ;;;;QAqCX;;;;;WAKG;oBAFQ,SAAS,YAAY,CAAC,EAAE,GACtB,IAAI,SAAS,aAAa,CAAC,EAAE,CAAC;;;QAc3C,wDAAwD;yBAA5C,MAAM;;;;;;;;;;;;;;;;;;;QAMlB;;;;WAIG;2BAHQ,OAAO,UAAU,CAAC,aAClB,eAAe,cACf,gBAAgB;;;GAahC;oCArGU;IACR,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC3C,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;IAC1C,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC7C;+BAkGU,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAzHrB,mBAAmB;8BAEF,aAAa;0BADlB,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;yBAFrD,aAAa;gCADlB,iBAAiB;4BACZ,aAAa;qCAGD,iCAAiC;sCAAjC,iCAAiC"}