@metoncash/sdk-v1 0.2.0 → 0.3.0

package/dist/utils/keys.d.ts

@@ -1,23 +1,65 @@
 /**
- * utils/keys.ts — wallet key generation.
+ * utils/keys.ts - wallet key generation.
  *
- * Each wallet has a SPEND key (authorizes spends; bound on-chain by address)
- * and a VIEW key derived one-way from it. `viewSk` decrypts incoming notes and
- * is safe to share with an auditor — it grants read access, not spend ability.
+ * Each wallet has a SPEND secret (the client-side root seed) and a VIEW key
+ * derived one-way from it. Only `viewPk` ever reaches the chain (Register,
+ * immutable once set); `viewSk` decrypts incoming notes and is safe to share
+ * with an auditor - it grants read access, not spend ability. There is no
+ * on-chain spend key: spend authority is the owner's TON address, enforced by
+ * the Wallet contract's sender check. `spendPk` exists for convenience only and
+ * is never registered or checked on-chain.
+ *
+ * Persist `spendSk` (everything else re-derives from it) and never publish it.
  */
 import { Point } from "../jubjub";
+import type { SubgroupWitness, CellRef } from "../wrappers/Minter.gen";
+/** A wallet's full key set. `spendSk` is the root secret; the rest derive from it. */
 export interface WalletKeys {
+    /** SECRET root seed in [1, L); persist it, never share it */
     spendSk: bigint;
+    /** sk_spend * G; not used by the protocol */
     spendPk: Point;
+    /** MiMC(7, spendSk) mod L, one-way from spendSk; shareable for audit */
     viewSk: bigint;
+    /** sk_view * G - registered on-chain, notes are encrypted to this */
     viewPk: Point;
 }
-/** Generate a fresh wallet keypair (random spend secret + derived view key). */
+/**
+ * Generate a fresh wallet keypair (random spend secret + derived view key).
+ * The spend secret comes from randomScalar (CSPRNG, never 0), so `viewPk` is
+ * always a non-identity prime-order-subgroup point and passes registerWitness.
+ */
 export declare function generateWalletKeys(): WalletKeys;
-/** Derive the full key set from an existing spend secret. */
+/**
+ * Derive the full key set from an existing spend secret (deterministic, so a
+ * wallet can be restored from `spendSk` alone).
+ * @param spendSk any integer; a sane seed is in [1, L)
+ */
 export declare function walletKeysFromSpend(spendSk: bigint): WalletKeys;
-/** Derive just the viewing keypair (read-only; shareable for audit). */
+/**
+ * Derive just the viewing keypair (read-only; shareable for audit). Same
+ * derivation as walletKeysFromSpend without computing spendPk.
+ */
 export declare function viewKeyFromSpend(spendSk: bigint): {
     viewSk: bigint;
     viewPk: Point;
 };
+/**
+ * The `witness` field of a `Register` message: the cofactor witness the Minter
+ * uses to verify `viewPk` is in the Jubjub prime-order subgroup without a
+ * scalar multiplication on-chain (Q = [8^-1 mod L]*pk, [2]Q, [4]Q; it checks
+ * [8]*Q == pk). Keys from `generateWalletKeys()` always qualify.
+ *
+ * Why the Minter insists: the transfer circuit requires every receiver key to be
+ * a subgroup point, and the registered key is immutable, so a torsion or
+ * mixed-order key would make the wallet permanently unable to receive. The
+ * Minter checks Q on-curve and q2 == Q (+) Q, q4 == q2 (+) q2, pk == q4 (+) q4
+ * with Point.verifySum (Errors.InvalidPoint on failure); the two doublings are
+ * shipped in refs because two points do not fit one cell.
+ * @param viewPk the key that goes in `Register.publicViewKey` (same message)
+ * @returns the `Register.witness` field, ready for the Minter wrapper
+ * @throws RangeError if a coordinate is not canonical (< r), the key is the
+ *   identity, off-curve or not of prime order - the same cases the Minter
+ *   rejects (requireField / isIdentity / isOnCurve / the doubling chain)
+ */
+export declare function registerWitness(viewPk: Point): CellRef<SubgroupWitness>;

package/dist/utils/keys.js

@@ -1,28 +1,78 @@
 "use strict";
 /**
- * utils/keys.ts — wallet key generation.
+ * utils/keys.ts - wallet key generation.
  *
- * Each wallet has a SPEND key (authorizes spends; bound on-chain by address)
- * and a VIEW key derived one-way from it. `viewSk` decrypts incoming notes and
- * is safe to share with an auditor — it grants read access, not spend ability.
+ * Each wallet has a SPEND secret (the client-side root seed) and a VIEW key
+ * derived one-way from it. Only `viewPk` ever reaches the chain (Register,
+ * immutable once set); `viewSk` decrypts incoming notes and is safe to share
+ * with an auditor - it grants read access, not spend ability. There is no
+ * on-chain spend key: spend authority is the owner's TON address, enforced by
+ * the Wallet contract's sender check. `spendPk` exists for convenience only and
+ * is never registered or checked on-chain.
+ *
+ * Persist `spendSk` (everything else re-derives from it) and never publish it.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateWalletKeys = generateWalletKeys;
 exports.walletKeysFromSpend = walletKeysFromSpend;
 exports.viewKeyFromSpend = viewKeyFromSpend;
+exports.registerWitness = registerWitness;
 const jubjub_1 = require("../jubjub");
 const note_1 = require("../note");
-/** Generate a fresh wallet keypair (random spend secret + derived view key). */
+/**
+ * Generate a fresh wallet keypair (random spend secret + derived view key).
+ * The spend secret comes from randomScalar (CSPRNG, never 0), so `viewPk` is
+ * always a non-identity prime-order-subgroup point and passes registerWitness.
+ */
 function generateWalletKeys() {
     return walletKeysFromSpend((0, jubjub_1.randomScalar)(252));
 }
-/** Derive the full key set from an existing spend secret. */
+/**
+ * Derive the full key set from an existing spend secret (deterministic, so a
+ * wallet can be restored from `spendSk` alone).
+ * @param spendSk any integer; a sane seed is in [1, L)
+ */
 function walletKeysFromSpend(spendSk) {
     const { skView, pkView } = (0, note_1.deriveViewKey)(spendSk);
     return { spendSk, spendPk: (0, jubjub_1.derivePub)(spendSk), viewSk: skView, viewPk: pkView };
 }
-/** Derive just the viewing keypair (read-only; shareable for audit). */
+/**
+ * Derive just the viewing keypair (read-only; shareable for audit). Same
+ * derivation as walletKeysFromSpend without computing spendPk.
+ */
 function viewKeyFromSpend(spendSk) {
     const { skView, pkView } = (0, note_1.deriveViewKey)(spendSk);
     return { viewSk: skView, viewPk: pkView };
 }
+/**
+ * The `witness` field of a `Register` message: the cofactor witness the Minter
+ * uses to verify `viewPk` is in the Jubjub prime-order subgroup without a
+ * scalar multiplication on-chain (Q = [8^-1 mod L]*pk, [2]Q, [4]Q; it checks
+ * [8]*Q == pk). Keys from `generateWalletKeys()` always qualify.
+ *
+ * Why the Minter insists: the transfer circuit requires every receiver key to be
+ * a subgroup point, and the registered key is immutable, so a torsion or
+ * mixed-order key would make the wallet permanently unable to receive. The
+ * Minter checks Q on-curve and q2 == Q (+) Q, q4 == q2 (+) q2, pk == q4 (+) q4
+ * with Point.verifySum (Errors.InvalidPoint on failure); the two doublings are
+ * shipped in refs because two points do not fit one cell.
+ * @param viewPk the key that goes in `Register.publicViewKey` (same message)
+ * @returns the `Register.witness` field, ready for the Minter wrapper
+ * @throws RangeError if a coordinate is not canonical (< r), the key is the
+ *   identity, off-curve or not of prime order - the same cases the Minter
+ *   rejects (requireField / isIdentity / isOnCurve / the doubling chain)
+ */
+function registerWitness(viewPk) {
+    const [x, y] = viewPk;
+    // mirror the contract's checks so a bad key fails here with a clear message
+    if (x < 0n || x >= jubjub_1.r || y < 0n || y >= jubjub_1.r)
+        throw new RangeError("registerWitness: viewPk coordinates must be canonical (< r)");
+    if ((0, jubjub_1.isIdentity)(x, y))
+        throw new RangeError("registerWitness: viewPk must not be the identity");
+    if (!(0, jubjub_1.isInPrimeSubgroup)(x, y)) {
+        throw new RangeError("registerWitness: viewPk is not a Jubjub prime-order-subgroup point");
+    }
+    const { q, q2, q4 } = (0, jubjub_1.cofactorWitness)(viewPk[0], viewPk[1]);
+    const pt = (p) => ({ $: "Point", x: p[0], y: p[1] });
+    return { ref: { $: "SubgroupWitness", q: pt(q), q2: { ref: pt(q2) }, q4: { ref: pt(q4) } } };
+}

package/dist/utils/note.d.ts

@@ -1,28 +1,51 @@
 /**
- * utils/note.ts — seal an encrypted note for a recipient.
+ * utils/note.ts - seal an encrypted note for a recipient.
  *
  * "Signing" a note here means producing the sender-side ECDH-sealed payload
- * (R, enc_amount, enc_blind): a fresh ephemeral key R = k·G, with the amount and
- * blind masked by a key derived from the ECDH shared secret k·pk_view. Only the
+ * (R, enc_amount, enc_blind): a fresh ephemeral key R = k*G, with the amount and
+ * blind masked by a key derived from the ECDH shared secret k*pk_view. Only the
  * holder of the recipient's viewing secret can open it. There is no separate
- * signature — authenticity/secrecy come from the ECDH to the recipient's key.
+ * signature - authenticity/secrecy come from the ECDH to the recipient's key.
  */
 import { Point } from "../jubjub";
 import { Note } from "../note";
-/** Minimal note fields needed to open it (the on-chain payload). */
-export type SealedNote = Pick<Note, "Rx" | "Ry" | "enc_amount" | "enc_blind">;
+/** The on-chain note payload (public). Kept as an alias for API stability. */
+export type SealedNote = Note;
+/** Inputs for sealNote. */
 export interface SealNoteArgs {
+    /** the amount being transferred (64-bit) */
     amount: bigint;
+    /** the blinding of the amount commitment the receiver will open (252-bit) */
     amountBlind: bigint;
+    /** recipient's registered pk_view; must be a non-identity subgroup point */
     receiverViewPk: Point;
-    /** Ephemeral scalar k. Defaults to fresh randomness — MUST be unique per note. */
+    /** Ephemeral scalar k. Defaults to fresh randomness - MUST be unique per note. */
     ephScalar?: bigint;
 }
-/** Seal (encrypt) a note to the recipient's viewing key. */
-export declare function sealNote(args: SealNoteArgs): Note;
+/**
+ * Seal (encrypt) a note to the recipient's viewing key.
+ *
+ * Returns the PUBLIC note (safe to put on-chain) and, separately, the ephemeral
+ * scalar that was used - a secret: never publish it, it re-derives the masks.
+ *
+ * Performs no validation of `receiverViewPk` or a caller-supplied `ephScalar`;
+ * `MetonSDK.transfer()` builds the same note with full checks and is the normal
+ * path. This helper is for callers that only need the ciphertext (tests,
+ * re-encryption, off-line tooling).
+ */
+export declare function sealNote(args: SealNoteArgs): {
+    note: SealedNote;
+    ephScalar: bigint;
+};
 /**
  * Open a sealed note with the recipient's viewing secret, recovering the
  * transferred amount and its blinding.
+ *
+ * Validates R (non-identity subgroup point, canonical coordinates) before
+ * using the secret. Does NOT check the result against the on-chain amount
+ * commitment - a wrong key yields garbage silently; use `viewNote` when the
+ * commitment is available.
+ * @throws Error if the note's R is malformed (see decryptNote)
  */
 export declare function openNote(viewSk: bigint, note: SealedNote): {
     amount: bigint;

package/dist/utils/note.js

@@ -1,26 +1,43 @@
 "use strict";
 /**
- * utils/note.ts — seal an encrypted note for a recipient.
+ * utils/note.ts - seal an encrypted note for a recipient.
  *
  * "Signing" a note here means producing the sender-side ECDH-sealed payload
- * (R, enc_amount, enc_blind): a fresh ephemeral key R = k·G, with the amount and
- * blind masked by a key derived from the ECDH shared secret k·pk_view. Only the
+ * (R, enc_amount, enc_blind): a fresh ephemeral key R = k*G, with the amount and
+ * blind masked by a key derived from the ECDH shared secret k*pk_view. Only the
  * holder of the recipient's viewing secret can open it. There is no separate
- * signature — authenticity/secrecy come from the ECDH to the recipient's key.
+ * signature - authenticity/secrecy come from the ECDH to the recipient's key.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sealNote = sealNote;
 exports.openNote = openNote;
 const jubjub_1 = require("../jubjub");
 const note_1 = require("../note");
-/** Seal (encrypt) a note to the recipient's viewing key. */
+/**
+ * Seal (encrypt) a note to the recipient's viewing key.
+ *
+ * Returns the PUBLIC note (safe to put on-chain) and, separately, the ephemeral
+ * scalar that was used - a secret: never publish it, it re-derives the masks.
+ *
+ * Performs no validation of `receiverViewPk` or a caller-supplied `ephScalar`;
+ * `MetonSDK.transfer()` builds the same note with full checks and is the normal
+ * path. This helper is for callers that only need the ciphertext (tests,
+ * re-encryption, off-line tooling).
+ */
 function sealNote(args) {
     const k = args.ephScalar ?? (0, jubjub_1.randomScalar)(252);
-    return (0, note_1.encryptNote)(args.amount, args.amountBlind, args.receiverViewPk[0], args.receiverViewPk[1], k);
+    const note = (0, note_1.encryptNote)(args.amount, args.amountBlind, args.receiverViewPk[0], args.receiverViewPk[1], k);
+    return { note, ephScalar: k };
 }
 /**
  * Open a sealed note with the recipient's viewing secret, recovering the
  * transferred amount and its blinding.
+ *
+ * Validates R (non-identity subgroup point, canonical coordinates) before
+ * using the secret. Does NOT check the result against the on-chain amount
+ * commitment - a wrong key yields garbage silently; use `viewNote` when the
+ * commitment is available.
+ * @throws Error if the note's R is malformed (see decryptNote)
  */
 function openNote(viewSk, note) {
     return (0, note_1.decryptNote)(viewSk, note.Rx, note.Ry, note.enc_amount, note.enc_blind);

package/dist/wrappers/Minter.gen.d.ts

@@ -201,22 +201,48 @@ export declare const InternalInitMinter: {
     store(self: InternalInitMinter, b: c.Builder): void;
     toCell(self: InternalInitMinter): c.Cell;
 };
+/**
+ > struct SubgroupWitness {
+ >     q: Point
+ >     q2: Cell<Point>
+ >     q4: Cell<Point>
+ > }
+ */
+export interface SubgroupWitness {
+    readonly $: 'SubgroupWitness';
+    q: Point;
+    q2: CellRef<Point>;
+    q4: CellRef<Point>;
+}
+export declare const SubgroupWitness: {
+    create(args: {
+        q: Point;
+        q2: CellRef<Point>;
+        q4: CellRef<Point>;
+    }): SubgroupWitness;
+    fromSlice(s: c.Slice): SubgroupWitness;
+    store(self: SubgroupWitness, b: c.Builder): void;
+    toCell(self: SubgroupWitness): c.Cell;
+};
 /**
  > struct (0xa68f2242) Register {
  >     queryId: uint64
  >     publicViewKey: Point
+ >     witness: Cell<SubgroupWitness>
  > }
  */
 export interface Register {
     readonly $: 'Register';
     queryId: uint64;
     publicViewKey: Point;
+    witness: CellRef<SubgroupWitness>;
 }
 export declare const Register: {
     PREFIX: number;
     create(args: {
         queryId: uint64;
         publicViewKey: Point;
+        witness: CellRef<SubgroupWitness>;
     }): Register;
     fromSlice(s: c.Slice): Register;
     store(self: Register, b: c.Builder): void;
@@ -449,6 +475,7 @@ export declare class Minter implements c.Contract {
     static createCellOfRegister(body: {
         queryId: uint64;
         publicViewKey: Point;
+        witness: CellRef<SubgroupWitness>;
     }): c.Cell;
     static createCellOfInternalWithdraw(body: {
         queryId: uint64;
@@ -481,6 +508,7 @@ export declare class Minter implements c.Contract {
     sendRegister(provider: ContractProvider, via: Sender, msgValue: coins, body: {
         queryId: uint64;
         publicViewKey: Point;
+        witness: CellRef<SubgroupWitness>;
     }, extraOptions?: ExtraSendOptions): Promise<void>;
     sendInternalWithdraw(provider: ContractProvider, via: Sender, msgValue: coins, body: {
         queryId: uint64;

package/dist/wrappers/Minter.gen.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Minter = exports.Proof = exports.Point = exports.InternalFlipWalletStatus = exports.InternalRegister = exports.InternalDeposit = exports.InternalResetGas = exports.FlipWalletStatus = exports.InternalWithdraw = exports.Register = exports.InternalInitMinter = exports.MinterStorage = exports.MinterStorageAdditionalData = exports.MinterRuntimeStorage = exports.ExcessMessage = exports.JettonTransferNotification = exports.JettonTransfer = void 0;
+exports.Minter = exports.Proof = exports.Point = exports.InternalFlipWalletStatus = exports.InternalRegister = exports.InternalDeposit = exports.InternalResetGas = exports.FlipWalletStatus = exports.InternalWithdraw = exports.Register = exports.SubgroupWitness = exports.InternalInitMinter = exports.MinterStorage = exports.MinterStorageAdditionalData = exports.MinterRuntimeStorage = exports.ExcessMessage = exports.JettonTransferNotification = exports.JettonTransfer = void 0;
 const c = __importStar(require("@ton/core"));
 const core_1 = require("@ton/core");
 function makeCellFrom(self, storeFn_T) {
@@ -344,6 +344,30 @@ exports.InternalInitMinter = {
         return makeCellFrom(self, exports.InternalInitMinter.store);
     }
 };
+exports.SubgroupWitness = {
+    create(args) {
+        return {
+            $: 'SubgroupWitness',
+            ...args
+        };
+    },
+    fromSlice(s) {
+        return {
+            $: 'SubgroupWitness',
+            q: exports.Point.fromSlice(s),
+            q2: loadCellRef(s, exports.Point.fromSlice),
+            q4: loadCellRef(s, exports.Point.fromSlice),
+        };
+    },
+    store(self, b) {
+        exports.Point.store(self.q, b);
+        storeCellRef(self.q2, b, exports.Point.store);
+        storeCellRef(self.q4, b, exports.Point.store);
+    },
+    toCell(self) {
+        return makeCellFrom(self, exports.SubgroupWitness.store);
+    }
+};
 exports.Register = {
     PREFIX: 0xa68f2242,
     create(args) {
@@ -358,12 +382,14 @@ exports.Register = {
             $: 'Register',
             queryId: s.loadUintBig(64),
             publicViewKey: exports.Point.fromSlice(s),
+            witness: loadCellRef(s, exports.SubgroupWitness.fromSlice),
         };
     },
     store(self, b) {
         b.storeUint(0xa68f2242, 32);
         b.storeUint(self.queryId, 64);
         exports.Point.store(self.publicViewKey, b);
+        storeCellRef(self.witness, b, exports.SubgroupWitness.store);
     },
     toCell(self) {
         return makeCellFrom(self, exports.Register.store);

package/dist/wrappers/Wallet.gen.d.ts

@@ -25,9 +25,23 @@ export declare const ExcessMessage: {
     store(self: ExcessMessage, b: c.Builder): void;
     toCell(self: ExcessMessage): c.Cell;
 };
+/**
+ > enum ReceiveMode { 3 variants }
+ */
+export type ReceiveMode = bigint;
+export declare const ReceiveMode: {
+    FromAnyone: bigint;
+    FromNoOne: bigint;
+    FromOnly: bigint;
+    fromSlice(s: c.Slice): ReceiveMode;
+    store(self: ReceiveMode, b: c.Builder): void;
+    toCell(self: ReceiveMode): c.Cell;
+};
 /**
  > struct WalletRuntimeStorage {
  >     locked: bool
+ >     receiverMode: ReceiveMode
+ >     receiverFrom: address?
  >     minter: address
  >     owner: address
  >     seqNo: uint32
@@ -38,6 +52,8 @@ export declare const ExcessMessage: {
 export interface WalletRuntimeStorage {
     readonly $: 'WalletRuntimeStorage';
     locked: boolean;
+    receiverMode: ReceiveMode;
+    receiverFrom: c.Address | null;
     minter: c.Address;
     owner: c.Address;
     seqNo: uint32;
@@ -47,6 +63,8 @@ export interface WalletRuntimeStorage {
 export declare const WalletRuntimeStorage: {
     create(args: {
         locked: boolean;
+        receiverMode: ReceiveMode;
+        receiverFrom: c.Address | null;
         minter: c.Address;
         owner: c.Address;
         seqNo: uint32;
@@ -60,6 +78,8 @@ export declare const WalletRuntimeStorage: {
 /**
  > struct WalletStorage {
  >     locked: bool
+ >     receiverMode: ReceiveMode
+ >     receiverFrom: address?
  >     minter: address
  >     owner: address
  >     seqNo: uint32
@@ -70,6 +90,8 @@ export declare const WalletRuntimeStorage: {
 export interface WalletStorage {
     readonly $: 'WalletStorage';
     locked: boolean;
+    receiverMode: ReceiveMode;
+    receiverFrom: c.Address | null;
     minter: c.Address;
     owner: c.Address;
     seqNo: uint32;
@@ -79,6 +101,8 @@ export interface WalletStorage {
 export declare const WalletStorage: {
     create(args: {
         locked?: boolean;
+        receiverMode?: ReceiveMode;
+        receiverFrom?: c.Address | null;
         minter: c.Address;
         owner: c.Address;
         seqNo?: uint32;
@@ -311,6 +335,33 @@ export declare const InitWithdraw: {
     store(self: InitWithdraw, b: c.Builder): void;
     toCell(self: InitWithdraw): c.Cell;
 };
+/**
+ > struct (0xd083d476) SetReceiveMode {
+ >     queryId: uint64
+ >     mode: ReceiveMode
+ >     receiverFrom: address?
+ >     excess: address
+ > }
+ */
+export interface SetReceiveMode {
+    readonly $: 'SetReceiveMode';
+    queryId: uint64;
+    mode: ReceiveMode;
+    receiverFrom: c.Address | null;
+    excess: c.Address;
+}
+export declare const SetReceiveMode: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        mode: ReceiveMode;
+        receiverFrom: c.Address | null;
+        excess: c.Address;
+    }): SetReceiveMode;
+    fromSlice(s: c.Slice): SetReceiveMode;
+    store(self: SetReceiveMode, b: c.Builder): void;
+    toCell(self: SetReceiveMode): c.Cell;
+};
 /**
  > struct (0xdde0f974) InternalRegister {
  >     queryId: uint64
@@ -472,10 +523,12 @@ export declare class Wallet implements c.Contract {
         'Errors.InvalidProof': number;
         'Errors.InvalidAmount': number;
         'Errors.AlreadyInitialized': number;
+        'Errors.ReceiveDisabled': number;
         'Errors.NotAlreadyInitialized': number;
         'Errors.NotEnoughGas': number;
         'Errors.InvalidPoint': number;
         'Errors.InvalidWorkchain': number;
+        'Errors.InvalidReceiveMode': number;
         'Errors.WrongSender': number;
         'Errors.PositionLocked': number;
         'Errors.WrongOp': number;
@@ -533,6 +586,12 @@ export declare class Wallet implements c.Contract {
         queryId: uint64;
         excess: c.Address;
     }): c.Cell;
+    static createCellOfSetReceiveMode(body: {
+        queryId: uint64;
+        mode: ReceiveMode;
+        receiverFrom: c.Address | null;
+        excess: c.Address;
+    }): c.Cell;
     sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
     sendInternalDeposit(provider: ContractProvider, via: Sender, msgValue: coins, body: {
         queryId: uint64;
@@ -577,6 +636,12 @@ export declare class Wallet implements c.Contract {
         queryId: uint64;
         excess: c.Address;
     }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendSetReceiveMode(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        mode: ReceiveMode;
+        receiverFrom: c.Address | null;
+        excess: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
     getWalletState(provider: ContractProvider): Promise<WalletRuntimeStorage>;
     getWalletData(provider: ContractProvider): Promise<[
         bigint,