@typemove/sui 1.0.0-rc.19 → 1.0.0-rc.21

package/dist/builtin/0x2.js

@@ -5,7 +5,8 @@
 import { TypeDescriptor, ANY_TYPE } from "@typemove/move";
 import { defaultMoveCoder } from "@typemove/sui";
 import { ZERO_ADDRESS } from "@typemove/sui";
-import { TransactionBlock, TransactionArgument, } from "@mysten/sui.js";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TransactionArgument } from "@mysten/sui.js";
 import * as _0x1 from "./0x1.js";
 export var address;
 (function (address) {
@@ -97,80 +98,80 @@ export var address;
     })(builder = address.builder || (address.builder = {}));
     let view;
     (function (view) {
-        async function fromBytes(provider, args) {
+        async function fromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.fromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fromBytes = fromBytes;
-        async function fromU256(provider, args) {
+        async function fromU256(client, args) {
             const tx = new TransactionBlock();
             builder.fromU256(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fromU256 = fromU256;
-        async function length(provider, args) {
+        async function length(client, args) {
             const tx = new TransactionBlock();
             builder.length(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function max(provider, args) {
+        async function max(client, args) {
             const tx = new TransactionBlock();
             builder.max(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.max = max;
-        async function toAsciiString(provider, args) {
+        async function toAsciiString(client, args) {
             const tx = new TransactionBlock();
             builder.toAsciiString(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.toAsciiString = toAsciiString;
-        async function toBytes(provider, args) {
+        async function toBytes(client, args) {
             const tx = new TransactionBlock();
             builder.toBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.toBytes = toBytes;
-        async function toString(provider, args) {
+        async function toString(client, args) {
             const tx = new TransactionBlock();
             builder.toString(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.toString = toString;
-        async function toU256(provider, args) {
+        async function toU256(client, args) {
             const tx = new TransactionBlock();
             builder.toU256(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -347,100 +348,100 @@ export var bag;
     })(builder = bag.builder || (bag.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function containsWithType(provider, args, typeArguments) {
+        async function containsWithType(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.containsWithType(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.containsWithType = containsWithType;
-        async function destroyEmpty(provider, args) {
+        async function destroyEmpty(client, args) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function isEmpty(provider, args) {
+        async function isEmpty(client, args) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args) {
+        async function length(client, args) {
             const tx = new TransactionBlock();
             builder.length(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function new_(provider, args) {
+        async function new_(client, args) {
             const tx = new TransactionBlock();
             builder.new_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -627,100 +628,100 @@ export var balance;
     })(builder = balance.builder || (balance.builder = {}));
     let view;
     (function (view) {
-        async function createSupply(provider, args, typeArguments) {
+        async function createSupply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.createSupply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.createSupply = createSupply;
-        async function decreaseSupply(provider, args, typeArguments) {
+        async function decreaseSupply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.decreaseSupply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.decreaseSupply = decreaseSupply;
-        async function destroyZero(provider, args, typeArguments) {
+        async function destroyZero(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyZero(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyZero = destroyZero;
-        async function increaseSupply(provider, args, typeArguments) {
+        async function increaseSupply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.increaseSupply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.increaseSupply = increaseSupply;
-        async function join(provider, args, typeArguments) {
+        async function join(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.join(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.join = join;
-        async function split(provider, args, typeArguments) {
+        async function split(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.split(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.split = split;
-        async function supplyValue(provider, args, typeArguments) {
+        async function supplyValue(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.supplyValue(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.supplyValue = supplyValue;
-        async function value(provider, args, typeArguments) {
+        async function value(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.value(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.value = value;
-        async function withdrawAll(provider, args, typeArguments) {
+        async function withdrawAll(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.withdrawAll(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.withdrawAll = withdrawAll;
-        async function zero(provider, args, typeArguments) {
+        async function zero(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.zero(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -955,200 +956,200 @@ export var bcs;
     })(builder = bcs.builder || (bcs.builder = {}));
     let view;
     (function (view) {
-        async function intoRemainderBytes(provider, args) {
+        async function intoRemainderBytes(client, args) {
             const tx = new TransactionBlock();
             builder.intoRemainderBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.intoRemainderBytes = intoRemainderBytes;
-        async function new_(provider, args) {
+        async function new_(client, args) {
             const tx = new TransactionBlock();
             builder.new_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function peelAddress(provider, args) {
+        async function peelAddress(client, args) {
             const tx = new TransactionBlock();
             builder.peelAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelAddress = peelAddress;
-        async function peelBool(provider, args) {
+        async function peelBool(client, args) {
             const tx = new TransactionBlock();
             builder.peelBool(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelBool = peelBool;
-        async function peelOptionAddress(provider, args) {
+        async function peelOptionAddress(client, args) {
             const tx = new TransactionBlock();
             builder.peelOptionAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelOptionAddress = peelOptionAddress;
-        async function peelOptionBool(provider, args) {
+        async function peelOptionBool(client, args) {
             const tx = new TransactionBlock();
             builder.peelOptionBool(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelOptionBool = peelOptionBool;
-        async function peelOptionU128(provider, args) {
+        async function peelOptionU128(client, args) {
             const tx = new TransactionBlock();
             builder.peelOptionU128(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelOptionU128 = peelOptionU128;
-        async function peelOptionU64(provider, args) {
+        async function peelOptionU64(client, args) {
             const tx = new TransactionBlock();
             builder.peelOptionU64(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelOptionU64 = peelOptionU64;
-        async function peelOptionU8(provider, args) {
+        async function peelOptionU8(client, args) {
             const tx = new TransactionBlock();
             builder.peelOptionU8(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelOptionU8 = peelOptionU8;
-        async function peelU128(provider, args) {
+        async function peelU128(client, args) {
             const tx = new TransactionBlock();
             builder.peelU128(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelU128 = peelU128;
-        async function peelU64(provider, args) {
+        async function peelU64(client, args) {
             const tx = new TransactionBlock();
             builder.peelU64(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelU64 = peelU64;
-        async function peelU8(provider, args) {
+        async function peelU8(client, args) {
             const tx = new TransactionBlock();
             builder.peelU8(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelU8 = peelU8;
-        async function peelVecAddress(provider, args) {
+        async function peelVecAddress(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecAddress = peelVecAddress;
-        async function peelVecBool(provider, args) {
+        async function peelVecBool(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecBool(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecBool = peelVecBool;
-        async function peelVecLength(provider, args) {
+        async function peelVecLength(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecLength(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecLength = peelVecLength;
-        async function peelVecU128(provider, args) {
+        async function peelVecU128(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecU128(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecU128 = peelVecU128;
-        async function peelVecU64(provider, args) {
+        async function peelVecU64(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecU64(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecU64 = peelVecU64;
-        async function peelVecU8(provider, args) {
+        async function peelVecU8(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecU8(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecU8 = peelVecU8;
-        async function peelVecVecU8(provider, args) {
+        async function peelVecVecU8(client, args) {
             const tx = new TransactionBlock();
             builder.peelVecVecU8(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.peelVecVecU8 = peelVecVecU8;
-        async function toBytes(provider, args, typeArguments) {
+        async function toBytes(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.toBytes(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -1188,20 +1189,20 @@ export var bls12381;
     })(builder = bls12381.builder || (bls12381.builder = {}));
     let view;
     (function (view) {
-        async function bls12381MinPkVerify(provider, args) {
+        async function bls12381MinPkVerify(client, args) {
             const tx = new TransactionBlock();
             builder.bls12381MinPkVerify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.bls12381MinPkVerify = bls12381MinPkVerify;
-        async function bls12381MinSigVerify(provider, args) {
+        async function bls12381MinSigVerify(client, args) {
             const tx = new TransactionBlock();
             builder.bls12381MinSigVerify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -1298,40 +1299,40 @@ export var borrow;
     })(builder = borrow_1.builder || (borrow_1.builder = {}));
     let view;
     (function (view) {
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function destroy(provider, args, typeArguments) {
+        async function destroy(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroy(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroy = destroy;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function putBack(provider, args, typeArguments) {
+        async function putBack(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.putBack(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -1366,10 +1367,10 @@ export var clock;
     })(builder = clock.builder || (clock.builder = {}));
     let view;
     (function (view) {
-        async function timestampMs(provider, args) {
+        async function timestampMs(client, args) {
             const tx = new TransactionBlock();
             builder.timestampMs(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -1931,310 +1932,310 @@ export var coin;
     })(builder = coin.builder || (coin.builder = {}));
     let view;
     (function (view) {
-        async function balance(provider, args, typeArguments) {
+        async function balance(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.balance(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.balance = balance;
-        async function balanceMut(provider, args, typeArguments) {
+        async function balanceMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.balanceMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.balanceMut = balanceMut;
-        async function burn(provider, args, typeArguments) {
+        async function burn(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.burn(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.burn = burn;
-        async function createCurrency(provider, args, typeArguments) {
+        async function createCurrency(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.createCurrency(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.createCurrency = createCurrency;
-        async function destroyZero(provider, args, typeArguments) {
+        async function destroyZero(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyZero(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyZero = destroyZero;
-        async function divideIntoN(provider, args, typeArguments) {
+        async function divideIntoN(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.divideIntoN(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.divideIntoN = divideIntoN;
-        async function fromBalance(provider, args, typeArguments) {
+        async function fromBalance(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.fromBalance(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fromBalance = fromBalance;
-        async function getDecimals(provider, args, typeArguments) {
+        async function getDecimals(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getDecimals(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getDecimals = getDecimals;
-        async function getDescription(provider, args, typeArguments) {
+        async function getDescription(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getDescription(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getDescription = getDescription;
-        async function getIconUrl(provider, args, typeArguments) {
+        async function getIconUrl(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getIconUrl(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getIconUrl = getIconUrl;
-        async function getName(provider, args, typeArguments) {
+        async function getName(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getName(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getName = getName;
-        async function getSymbol(provider, args, typeArguments) {
+        async function getSymbol(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getSymbol(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getSymbol = getSymbol;
-        async function intoBalance(provider, args, typeArguments) {
+        async function intoBalance(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.intoBalance(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.intoBalance = intoBalance;
-        async function join(provider, args, typeArguments) {
+        async function join(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.join(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.join = join;
-        async function mint(provider, args, typeArguments) {
+        async function mint(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.mint(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.mint = mint;
-        async function mintAndTransfer(provider, args, typeArguments) {
+        async function mintAndTransfer(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.mintAndTransfer(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.mintAndTransfer = mintAndTransfer;
-        async function mintBalance(provider, args, typeArguments) {
+        async function mintBalance(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.mintBalance(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.mintBalance = mintBalance;
-        async function put(provider, args, typeArguments) {
+        async function put(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.put(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.put = put;
-        async function split(provider, args, typeArguments) {
+        async function split(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.split(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.split = split;
-        async function supply(provider, args, typeArguments) {
+        async function supply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.supply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.supply = supply;
-        async function supplyImmut(provider, args, typeArguments) {
+        async function supplyImmut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.supplyImmut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.supplyImmut = supplyImmut;
-        async function supplyMut(provider, args, typeArguments) {
+        async function supplyMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.supplyMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.supplyMut = supplyMut;
-        async function take(provider, args, typeArguments) {
+        async function take(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.take(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.take = take;
-        async function totalSupply(provider, args, typeArguments) {
+        async function totalSupply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.totalSupply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.totalSupply = totalSupply;
-        async function treasuryIntoSupply(provider, args, typeArguments) {
+        async function treasuryIntoSupply(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.treasuryIntoSupply(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.treasuryIntoSupply = treasuryIntoSupply;
-        async function updateDescription(provider, args, typeArguments) {
+        async function updateDescription(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.updateDescription(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.updateDescription = updateDescription;
-        async function updateIconUrl(provider, args, typeArguments) {
+        async function updateIconUrl(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.updateIconUrl(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.updateIconUrl = updateIconUrl;
-        async function updateName(provider, args, typeArguments) {
+        async function updateName(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.updateName(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.updateName = updateName;
-        async function updateSymbol(provider, args, typeArguments) {
+        async function updateSymbol(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.updateSymbol(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.updateSymbol = updateSymbol;
-        async function value(provider, args, typeArguments) {
+        async function value(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.value(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.value = value;
-        async function zero(provider, args, typeArguments) {
+        async function zero(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.zero(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -2474,110 +2475,110 @@ export var display;
     })(builder = display.builder || (display.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function addMultiple(provider, args, typeArguments) {
+        async function addMultiple(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.addMultiple(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.addMultiple = addMultiple;
-        async function createAndKeep(provider, args, typeArguments) {
+        async function createAndKeep(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.createAndKeep(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.createAndKeep = createAndKeep;
-        async function edit(provider, args, typeArguments) {
+        async function edit(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.edit(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.edit = edit;
-        async function fields(provider, args, typeArguments) {
+        async function fields(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.fields(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fields = fields;
-        async function isAuthorized(provider, args, typeArguments) {
+        async function isAuthorized(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isAuthorized(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isAuthorized = isAuthorized;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function newWithFields(provider, args, typeArguments) {
+        async function newWithFields(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.newWithFields(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.newWithFields = newWithFields;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function updateVersion(provider, args, typeArguments) {
+        async function updateVersion(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.updateVersion(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.updateVersion = updateVersion;
-        async function version(provider, args, typeArguments) {
+        async function version(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.version(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -2733,70 +2734,70 @@ export var dynamic_field;
     })(builder = dynamic_field.builder || (dynamic_field.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function exists_(provider, args, typeArguments) {
+        async function exists_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.exists_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.exists_ = exists_;
-        async function existsWithType(provider, args, typeArguments) {
+        async function existsWithType(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.existsWithType(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.existsWithType = existsWithType;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function removeIfExists(provider, args, typeArguments) {
+        async function removeIfExists(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.removeIfExists(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -2949,70 +2950,70 @@ export var dynamic_object_field;
     })(builder = dynamic_object_field.builder || (dynamic_object_field.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function exists_(provider, args, typeArguments) {
+        async function exists_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.exists_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.exists_ = exists_;
-        async function existsWithType(provider, args, typeArguments) {
+        async function existsWithType(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.existsWithType(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.existsWithType = existsWithType;
-        async function id(provider, args, typeArguments) {
+        async function id(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.id(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.id = id;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3063,30 +3064,30 @@ export var ecdsa_k1;
     })(builder = ecdsa_k1.builder || (ecdsa_k1.builder = {}));
     let view;
     (function (view) {
-        async function decompressPubkey(provider, args) {
+        async function decompressPubkey(client, args) {
             const tx = new TransactionBlock();
             builder.decompressPubkey(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.decompressPubkey = decompressPubkey;
-        async function secp256k1Ecrecover(provider, args) {
+        async function secp256k1Ecrecover(client, args) {
             const tx = new TransactionBlock();
             builder.secp256k1Ecrecover(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.secp256k1Ecrecover = secp256k1Ecrecover;
-        async function secp256k1Verify(provider, args) {
+        async function secp256k1Verify(client, args) {
             const tx = new TransactionBlock();
             builder.secp256k1Verify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3127,20 +3128,20 @@ export var ecdsa_r1;
     })(builder = ecdsa_r1.builder || (ecdsa_r1.builder = {}));
     let view;
     (function (view) {
-        async function secp256r1Ecrecover(provider, args) {
+        async function secp256r1Ecrecover(client, args) {
             const tx = new TransactionBlock();
             builder.secp256r1Ecrecover(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.secp256r1Ecrecover = secp256r1Ecrecover;
-        async function secp256r1Verify(provider, args) {
+        async function secp256r1Verify(client, args) {
             const tx = new TransactionBlock();
             builder.secp256r1Verify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3169,10 +3170,10 @@ export var ecvrf;
     })(builder = ecvrf.builder || (ecvrf.builder = {}));
     let view;
     (function (view) {
-        async function ecvrfVerify(provider, args) {
+        async function ecvrfVerify(client, args) {
             const tx = new TransactionBlock();
             builder.ecvrfVerify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3200,10 +3201,10 @@ export var ed25519;
     })(builder = ed25519.builder || (ed25519.builder = {}));
     let view;
     (function (view) {
-        async function ed25519Verify(provider, args) {
+        async function ed25519Verify(client, args) {
             const tx = new TransactionBlock();
             builder.ed25519Verify(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3234,10 +3235,10 @@ export var event;
     })(builder = event.builder || (event.builder = {}));
     let view;
     (function (view) {
-        async function emit(provider, args, typeArguments) {
+        async function emit(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.emit(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3404,80 +3405,80 @@ export var groth16;
     })(builder = groth16.builder || (groth16.builder = {}));
     let view;
     (function (view) {
-        async function bls12381(provider, args) {
+        async function bls12381(client, args) {
             const tx = new TransactionBlock();
             builder.bls12381(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.bls12381 = bls12381;
-        async function bn254(provider, args) {
+        async function bn254(client, args) {
             const tx = new TransactionBlock();
             builder.bn254(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.bn254 = bn254;
-        async function prepareVerifyingKey(provider, args) {
+        async function prepareVerifyingKey(client, args) {
             const tx = new TransactionBlock();
             builder.prepareVerifyingKey(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.prepareVerifyingKey = prepareVerifyingKey;
-        async function proofPointsFromBytes(provider, args) {
+        async function proofPointsFromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.proofPointsFromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.proofPointsFromBytes = proofPointsFromBytes;
-        async function publicProofInputsFromBytes(provider, args) {
+        async function publicProofInputsFromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.publicProofInputsFromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publicProofInputsFromBytes = publicProofInputsFromBytes;
-        async function pvkFromBytes(provider, args) {
+        async function pvkFromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.pvkFromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pvkFromBytes = pvkFromBytes;
-        async function pvkToBytes(provider, args) {
+        async function pvkToBytes(client, args) {
             const tx = new TransactionBlock();
             builder.pvkToBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pvkToBytes = pvkToBytes;
-        async function verifyGroth16Proof(provider, args) {
+        async function verifyGroth16Proof(client, args) {
             const tx = new TransactionBlock();
             builder.verifyGroth16Proof(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3513,20 +3514,20 @@ export var hash;
     })(builder = hash.builder || (hash.builder = {}));
     let view;
     (function (view) {
-        async function blake2b256(provider, args) {
+        async function blake2b256(client, args) {
             const tx = new TransactionBlock();
             builder.blake2b256(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.blake2b256 = blake2b256;
-        async function keccak256(provider, args) {
+        async function keccak256(client, args) {
             const tx = new TransactionBlock();
             builder.keccak256(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3572,20 +3573,20 @@ export var hex;
     })(builder = hex.builder || (hex.builder = {}));
     let view;
     (function (view) {
-        async function decode(provider, args) {
+        async function decode(client, args) {
             const tx = new TransactionBlock();
             builder.decode(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.decode = decode;
-        async function encode(provider, args) {
+        async function encode(client, args) {
             const tx = new TransactionBlock();
             builder.encode(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -3612,10 +3613,10 @@ export var hmac;
     })(builder = hmac.builder || (hmac.builder = {}));
     let view;
     (function (view) {
-        async function hmacSha3256(provider, args) {
+        async function hmacSha3256(client, args) {
             const tx = new TransactionBlock();
             builder.hmacSha3256(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -4222,360 +4223,360 @@ export var kiosk;
     })(builder = kiosk.builder || (kiosk.builder = {}));
     let view;
     (function (view) {
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function borrowVal(provider, args, typeArguments) {
+        async function borrowVal(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowVal(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowVal = borrowVal;
-        async function closeAndWithdraw(provider, args) {
+        async function closeAndWithdraw(client, args) {
             const tx = new TransactionBlock();
             builder.closeAndWithdraw(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.closeAndWithdraw = closeAndWithdraw;
-        async function delist(provider, args, typeArguments) {
+        async function delist(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.delist(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.delist = delist;
-        async function hasAccess(provider, args) {
+        async function hasAccess(client, args) {
             const tx = new TransactionBlock();
             builder.hasAccess(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.hasAccess = hasAccess;
-        async function hasItem(provider, args) {
+        async function hasItem(client, args) {
             const tx = new TransactionBlock();
             builder.hasItem(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.hasItem = hasItem;
-        async function hasItemWithType(provider, args, typeArguments) {
+        async function hasItemWithType(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.hasItemWithType(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.hasItemWithType = hasItemWithType;
-        async function isListed(provider, args) {
+        async function isListed(client, args) {
             const tx = new TransactionBlock();
             builder.isListed(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isListed = isListed;
-        async function isListedExclusively(provider, args) {
+        async function isListedExclusively(client, args) {
             const tx = new TransactionBlock();
             builder.isListedExclusively(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isListedExclusively = isListedExclusively;
-        async function isLocked(provider, args) {
+        async function isLocked(client, args) {
             const tx = new TransactionBlock();
             builder.isLocked(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isLocked = isLocked;
-        async function itemCount(provider, args) {
+        async function itemCount(client, args) {
             const tx = new TransactionBlock();
             builder.itemCount(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.itemCount = itemCount;
-        async function list(provider, args, typeArguments) {
+        async function list(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.list(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.list = list;
-        async function listWithPurchaseCap(provider, args, typeArguments) {
+        async function listWithPurchaseCap(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.listWithPurchaseCap(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.listWithPurchaseCap = listWithPurchaseCap;
-        async function lock(provider, args, typeArguments) {
+        async function lock(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.lock(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.lock = lock;
-        async function new_(provider, args) {
+        async function new_(client, args) {
             const tx = new TransactionBlock();
             builder.new_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function owner(provider, args) {
+        async function owner(client, args) {
             const tx = new TransactionBlock();
             builder.owner(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.owner = owner;
-        async function place(provider, args, typeArguments) {
+        async function place(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.place(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.place = place;
-        async function placeAndList(provider, args, typeArguments) {
+        async function placeAndList(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.placeAndList(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.placeAndList = placeAndList;
-        async function profitsAmount(provider, args) {
+        async function profitsAmount(client, args) {
             const tx = new TransactionBlock();
             builder.profitsAmount(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.profitsAmount = profitsAmount;
-        async function profitsMut(provider, args) {
+        async function profitsMut(client, args) {
             const tx = new TransactionBlock();
             builder.profitsMut(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.profitsMut = profitsMut;
-        async function purchase(provider, args, typeArguments) {
+        async function purchase(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.purchase(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.purchase = purchase;
-        async function purchaseCapItem(provider, args, typeArguments) {
+        async function purchaseCapItem(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.purchaseCapItem(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.purchaseCapItem = purchaseCapItem;
-        async function purchaseCapKiosk(provider, args, typeArguments) {
+        async function purchaseCapKiosk(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.purchaseCapKiosk(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.purchaseCapKiosk = purchaseCapKiosk;
-        async function purchaseCapMinPrice(provider, args, typeArguments) {
+        async function purchaseCapMinPrice(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.purchaseCapMinPrice(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.purchaseCapMinPrice = purchaseCapMinPrice;
-        async function purchaseWithCap(provider, args, typeArguments) {
+        async function purchaseWithCap(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.purchaseWithCap(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.purchaseWithCap = purchaseWithCap;
-        async function returnPurchaseCap(provider, args, typeArguments) {
+        async function returnPurchaseCap(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.returnPurchaseCap(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.returnPurchaseCap = returnPurchaseCap;
-        async function returnVal(provider, args, typeArguments) {
+        async function returnVal(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.returnVal(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.returnVal = returnVal;
-        async function setAllowExtensions(provider, args) {
+        async function setAllowExtensions(client, args) {
             const tx = new TransactionBlock();
             builder.setAllowExtensions(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.setAllowExtensions = setAllowExtensions;
-        async function setOwner(provider, args) {
+        async function setOwner(client, args) {
             const tx = new TransactionBlock();
             builder.setOwner(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.setOwner = setOwner;
-        async function setOwnerCustom(provider, args) {
+        async function setOwnerCustom(client, args) {
             const tx = new TransactionBlock();
             builder.setOwnerCustom(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.setOwnerCustom = setOwnerCustom;
-        async function take(provider, args, typeArguments) {
+        async function take(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.take(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.take = take;
-        async function uid(provider, args) {
+        async function uid(client, args) {
             const tx = new TransactionBlock();
             builder.uid(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uid = uid;
-        async function uidMut(provider, args) {
+        async function uidMut(client, args) {
             const tx = new TransactionBlock();
             builder.uidMut(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidMut = uidMut;
-        async function uidMutAsOwner(provider, args) {
+        async function uidMutAsOwner(client, args) {
             const tx = new TransactionBlock();
             builder.uidMutAsOwner(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidMutAsOwner = uidMutAsOwner;
-        async function withdraw(provider, args) {
+        async function withdraw(client, args) {
             const tx = new TransactionBlock();
             builder.withdraw(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -4925,170 +4926,170 @@ export var linked_table;
     })(builder = linked_table.builder || (linked_table.builder = {}));
     let view;
     (function (view) {
-        async function back(provider, args, typeArguments) {
+        async function back(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.back(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.back = back;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function destroyEmpty(provider, args, typeArguments) {
+        async function destroyEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function drop(provider, args, typeArguments) {
+        async function drop(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.drop(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.drop = drop;
-        async function front(provider, args, typeArguments) {
+        async function front(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.front(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.front = front;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args, typeArguments) {
+        async function length(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.length(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function next(provider, args, typeArguments) {
+        async function next(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.next(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.next = next;
-        async function popBack(provider, args, typeArguments) {
+        async function popBack(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.popBack(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.popBack = popBack;
-        async function popFront(provider, args, typeArguments) {
+        async function popFront(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.popFront(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.popFront = popFront;
-        async function prev(provider, args, typeArguments) {
+        async function prev(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.prev(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.prev = prev;
-        async function pushBack(provider, args, typeArguments) {
+        async function pushBack(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.pushBack(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pushBack = pushBack;
-        async function pushFront(provider, args, typeArguments) {
+        async function pushFront(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.pushFront(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pushFront = pushFront;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -5179,70 +5180,70 @@ export var math;
     })(builder = math.builder || (math.builder = {}));
     let view;
     (function (view) {
-        async function diff(provider, args) {
+        async function diff(client, args) {
             const tx = new TransactionBlock();
             builder.diff(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.diff = diff;
-        async function divideAndRoundUp(provider, args) {
+        async function divideAndRoundUp(client, args) {
             const tx = new TransactionBlock();
             builder.divideAndRoundUp(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.divideAndRoundUp = divideAndRoundUp;
-        async function max(provider, args) {
+        async function max(client, args) {
             const tx = new TransactionBlock();
             builder.max(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.max = max;
-        async function min(provider, args) {
+        async function min(client, args) {
             const tx = new TransactionBlock();
             builder.min(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.min = min;
-        async function pow(provider, args) {
+        async function pow(client, args) {
             const tx = new TransactionBlock();
             builder.pow(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pow = pow;
-        async function sqrt(provider, args) {
+        async function sqrt(client, args) {
             const tx = new TransactionBlock();
             builder.sqrt(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.sqrt = sqrt;
-        async function sqrtU128(provider, args) {
+        async function sqrtU128(client, args) {
             const tx = new TransactionBlock();
             builder.sqrtU128(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -5441,140 +5442,140 @@ export var object_;
     })(builder = object_.builder || (object_.builder = {}));
     let view;
     (function (view) {
-        async function borrowId(provider, args, typeArguments) {
+        async function borrowId(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowId(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowId = borrowId;
-        async function delete_(provider, args) {
+        async function delete_(client, args) {
             const tx = new TransactionBlock();
             builder.delete_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.delete_ = delete_;
-        async function id(provider, args, typeArguments) {
+        async function id(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.id(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.id = id;
-        async function idAddress(provider, args, typeArguments) {
+        async function idAddress(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.idAddress(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idAddress = idAddress;
-        async function idBytes(provider, args, typeArguments) {
+        async function idBytes(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.idBytes(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idBytes = idBytes;
-        async function idFromAddress(provider, args) {
+        async function idFromAddress(client, args) {
             const tx = new TransactionBlock();
             builder.idFromAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idFromAddress = idFromAddress;
-        async function idFromBytes(provider, args) {
+        async function idFromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.idFromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idFromBytes = idFromBytes;
-        async function idToAddress(provider, args) {
+        async function idToAddress(client, args) {
             const tx = new TransactionBlock();
             builder.idToAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idToAddress = idToAddress;
-        async function idToBytes(provider, args) {
+        async function idToBytes(client, args) {
             const tx = new TransactionBlock();
             builder.idToBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.idToBytes = idToBytes;
-        async function new_(provider, args) {
+        async function new_(client, args) {
             const tx = new TransactionBlock();
             builder.new_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function uidAsInner(provider, args) {
+        async function uidAsInner(client, args) {
             const tx = new TransactionBlock();
             builder.uidAsInner(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidAsInner = uidAsInner;
-        async function uidToAddress(provider, args) {
+        async function uidToAddress(client, args) {
             const tx = new TransactionBlock();
             builder.uidToAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidToAddress = uidToAddress;
-        async function uidToBytes(provider, args) {
+        async function uidToBytes(client, args) {
             const tx = new TransactionBlock();
             builder.uidToBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidToBytes = uidToBytes;
-        async function uidToInner(provider, args) {
+        async function uidToInner(client, args) {
             const tx = new TransactionBlock();
             builder.uidToInner(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -5767,110 +5768,110 @@ export var object_bag;
     })(builder = object_bag.builder || (object_bag.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function containsWithType(provider, args, typeArguments) {
+        async function containsWithType(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.containsWithType(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.containsWithType = containsWithType;
-        async function destroyEmpty(provider, args) {
+        async function destroyEmpty(client, args) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function isEmpty(provider, args) {
+        async function isEmpty(client, args) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args) {
+        async function length(client, args) {
             const tx = new TransactionBlock();
             builder.length(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function new_(provider, args) {
+        async function new_(client, args) {
             const tx = new TransactionBlock();
             builder.new_(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function valueId(provider, args, typeArguments) {
+        async function valueId(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.valueId(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -6082,100 +6083,100 @@ export var object_table;
     })(builder = object_table.builder || (object_table.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function destroyEmpty(provider, args, typeArguments) {
+        async function destroyEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args, typeArguments) {
+        async function length(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.length(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function valueId(provider, args, typeArguments) {
+        async function valueId(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.valueId(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -6484,230 +6485,230 @@ export var package_;
     })(builder = package_.builder || (package_.builder = {}));
     let view;
     (function (view) {
-        async function additivePolicy(provider, args) {
+        async function additivePolicy(client, args) {
             const tx = new TransactionBlock();
             builder.additivePolicy(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.additivePolicy = additivePolicy;
-        async function authorizeUpgrade(provider, args) {
+        async function authorizeUpgrade(client, args) {
             const tx = new TransactionBlock();
             builder.authorizeUpgrade(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.authorizeUpgrade = authorizeUpgrade;
-        async function burnPublisher(provider, args) {
+        async function burnPublisher(client, args) {
             const tx = new TransactionBlock();
             builder.burnPublisher(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.burnPublisher = burnPublisher;
-        async function claim(provider, args, typeArguments) {
+        async function claim(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.claim(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.claim = claim;
-        async function claimAndKeep(provider, args, typeArguments) {
+        async function claimAndKeep(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.claimAndKeep(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.claimAndKeep = claimAndKeep;
-        async function commitUpgrade(provider, args) {
+        async function commitUpgrade(client, args) {
             const tx = new TransactionBlock();
             builder.commitUpgrade(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.commitUpgrade = commitUpgrade;
-        async function compatiblePolicy(provider, args) {
+        async function compatiblePolicy(client, args) {
             const tx = new TransactionBlock();
             builder.compatiblePolicy(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.compatiblePolicy = compatiblePolicy;
-        async function depOnlyPolicy(provider, args) {
+        async function depOnlyPolicy(client, args) {
             const tx = new TransactionBlock();
             builder.depOnlyPolicy(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.depOnlyPolicy = depOnlyPolicy;
-        async function fromModule(provider, args, typeArguments) {
+        async function fromModule(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.fromModule(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fromModule = fromModule;
-        async function fromPackage(provider, args, typeArguments) {
+        async function fromPackage(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.fromPackage(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.fromPackage = fromPackage;
-        async function makeImmutable(provider, args) {
+        async function makeImmutable(client, args) {
             const tx = new TransactionBlock();
             builder.makeImmutable(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.makeImmutable = makeImmutable;
-        async function onlyAdditiveUpgrades(provider, args) {
+        async function onlyAdditiveUpgrades(client, args) {
             const tx = new TransactionBlock();
             builder.onlyAdditiveUpgrades(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.onlyAdditiveUpgrades = onlyAdditiveUpgrades;
-        async function onlyDepUpgrades(provider, args) {
+        async function onlyDepUpgrades(client, args) {
             const tx = new TransactionBlock();
             builder.onlyDepUpgrades(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.onlyDepUpgrades = onlyDepUpgrades;
-        async function publishedModule(provider, args) {
+        async function publishedModule(client, args) {
             const tx = new TransactionBlock();
             builder.publishedModule(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publishedModule = publishedModule;
-        async function publishedPackage(provider, args) {
+        async function publishedPackage(client, args) {
             const tx = new TransactionBlock();
             builder.publishedPackage(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publishedPackage = publishedPackage;
-        async function receiptCap(provider, args) {
+        async function receiptCap(client, args) {
             const tx = new TransactionBlock();
             builder.receiptCap(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.receiptCap = receiptCap;
-        async function receiptPackage(provider, args) {
+        async function receiptPackage(client, args) {
             const tx = new TransactionBlock();
             builder.receiptPackage(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.receiptPackage = receiptPackage;
-        async function ticketDigest(provider, args) {
+        async function ticketDigest(client, args) {
             const tx = new TransactionBlock();
             builder.ticketDigest(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.ticketDigest = ticketDigest;
-        async function ticketPackage(provider, args) {
+        async function ticketPackage(client, args) {
             const tx = new TransactionBlock();
             builder.ticketPackage(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.ticketPackage = ticketPackage;
-        async function ticketPolicy(provider, args) {
+        async function ticketPolicy(client, args) {
             const tx = new TransactionBlock();
             builder.ticketPolicy(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.ticketPolicy = ticketPolicy;
-        async function upgradePackage(provider, args) {
+        async function upgradePackage(client, args) {
             const tx = new TransactionBlock();
             builder.upgradePackage(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.upgradePackage = upgradePackage;
-        async function upgradePolicy(provider, args) {
+        async function upgradePolicy(client, args) {
             const tx = new TransactionBlock();
             builder.upgradePolicy(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.upgradePolicy = upgradePolicy;
-        async function version(provider, args) {
+        async function version(client, args) {
             const tx = new TransactionBlock();
             builder.version(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -6871,80 +6872,80 @@ export var pay;
     })(builder = pay.builder || (pay.builder = {}));
     let view;
     (function (view) {
-        async function divideAndKeep(provider, args, typeArguments) {
+        async function divideAndKeep(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.divideAndKeep(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.divideAndKeep = divideAndKeep;
-        async function join(provider, args, typeArguments) {
+        async function join(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.join(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.join = join;
-        async function joinVec(provider, args, typeArguments) {
+        async function joinVec(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.joinVec(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.joinVec = joinVec;
-        async function joinVecAndTransfer(provider, args, typeArguments) {
+        async function joinVecAndTransfer(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.joinVecAndTransfer(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.joinVecAndTransfer = joinVecAndTransfer;
-        async function keep(provider, args, typeArguments) {
+        async function keep(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.keep(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.keep = keep;
-        async function split(provider, args, typeArguments) {
+        async function split(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.split(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.split = split;
-        async function splitAndTransfer(provider, args, typeArguments) {
+        async function splitAndTransfer(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.splitAndTransfer(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.splitAndTransfer = splitAndTransfer;
-        async function splitVec(provider, args, typeArguments) {
+        async function splitVec(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.splitVec(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -7087,60 +7088,60 @@ export var priority_queue;
     })(builder = priority_queue.builder || (priority_queue.builder = {}));
     let view;
     (function (view) {
-        async function createEntries(provider, args, typeArguments) {
+        async function createEntries(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.createEntries(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.createEntries = createEntries;
-        async function insert(provider, args, typeArguments) {
+        async function insert(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.insert(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.insert = insert;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function newEntry(provider, args, typeArguments) {
+        async function newEntry(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.newEntry(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.newEntry = newEntry;
-        async function popMax(provider, args, typeArguments) {
+        async function popMax(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.popMax(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.popMax = popMax;
-        async function priorities(provider, args, typeArguments) {
+        async function priorities(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.priorities(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -7176,10 +7177,10 @@ export var sui;
     })(builder = sui.builder || (sui.builder = {}));
     let view;
     (function (view) {
-        async function transfer(provider, args) {
+        async function transfer(client, args) {
             const tx = new TransactionBlock();
             builder.transfer(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -7390,100 +7391,100 @@ export var table;
     })(builder = table.builder || (table.builder = {}));
     let view;
     (function (view) {
-        async function add(provider, args, typeArguments) {
+        async function add(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.add(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.add = add;
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function destroyEmpty(provider, args, typeArguments) {
+        async function destroyEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function drop(provider, args, typeArguments) {
+        async function drop(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.drop(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.drop = drop;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args, typeArguments) {
+        async function length(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.length(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -7647,90 +7648,90 @@ export var table_vec;
     })(builder = table_vec.builder || (table_vec.builder = {}));
     let view;
     (function (view) {
-        async function borrow(provider, args, typeArguments) {
+        async function borrow(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrow(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrow = borrow;
-        async function borrowMut(provider, args, typeArguments) {
+        async function borrowMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.borrowMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.borrowMut = borrowMut;
-        async function destroyEmpty(provider, args, typeArguments) {
+        async function destroyEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function empty(provider, args, typeArguments) {
+        async function empty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.empty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.empty = empty;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function length(provider, args, typeArguments) {
+        async function length(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.length(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.length = length;
-        async function popBack(provider, args, typeArguments) {
+        async function popBack(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.popBack(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.popBack = popBack;
-        async function pushBack(provider, args, typeArguments) {
+        async function pushBack(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.pushBack(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pushBack = pushBack;
-        async function singleton(provider, args, typeArguments) {
+        async function singleton(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.singleton(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -7838,60 +7839,60 @@ export var transfer;
     })(builder = transfer_1.builder || (transfer_1.builder = {}));
     let view;
     (function (view) {
-        async function freezeObject(provider, args, typeArguments) {
+        async function freezeObject(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.freezeObject(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.freezeObject = freezeObject;
-        async function publicFreezeObject(provider, args, typeArguments) {
+        async function publicFreezeObject(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.publicFreezeObject(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publicFreezeObject = publicFreezeObject;
-        async function publicShareObject(provider, args, typeArguments) {
+        async function publicShareObject(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.publicShareObject(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publicShareObject = publicShareObject;
-        async function publicTransfer(provider, args, typeArguments) {
+        async function publicTransfer(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.publicTransfer(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.publicTransfer = publicTransfer;
-        async function shareObject(provider, args, typeArguments) {
+        async function shareObject(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.shareObject(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.shareObject = shareObject;
-        async function transfer(provider, args, typeArguments) {
+        async function transfer(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.transfer(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -8252,170 +8253,170 @@ export var transfer_policy;
     })(builder = transfer_policy.builder || (transfer_policy.builder = {}));
     let view;
     (function (view) {
-        async function addReceipt(provider, args, typeArguments) {
+        async function addReceipt(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.addReceipt(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.addReceipt = addReceipt;
-        async function addRule(provider, args, typeArguments) {
+        async function addRule(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.addRule(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.addRule = addRule;
-        async function addToBalance(provider, args, typeArguments) {
+        async function addToBalance(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.addToBalance(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.addToBalance = addToBalance;
-        async function confirmRequest(provider, args, typeArguments) {
+        async function confirmRequest(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.confirmRequest(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.confirmRequest = confirmRequest;
-        async function destroyAndWithdraw(provider, args, typeArguments) {
+        async function destroyAndWithdraw(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyAndWithdraw(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyAndWithdraw = destroyAndWithdraw;
-        async function from(provider, args, typeArguments) {
+        async function from(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.from(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.from = from;
-        async function getRule(provider, args, typeArguments) {
+        async function getRule(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getRule(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getRule = getRule;
-        async function hasRule(provider, args, typeArguments) {
+        async function hasRule(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.hasRule(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.hasRule = hasRule;
-        async function item(provider, args, typeArguments) {
+        async function item(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.item(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.item = item;
-        async function new_(provider, args, typeArguments) {
+        async function new_(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.new_(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.new_ = new_;
-        async function newRequest(provider, args, typeArguments) {
+        async function newRequest(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.newRequest(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.newRequest = newRequest;
-        async function paid(provider, args, typeArguments) {
+        async function paid(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.paid(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.paid = paid;
-        async function removeRule(provider, args, typeArguments) {
+        async function removeRule(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.removeRule(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.removeRule = removeRule;
-        async function rules(provider, args, typeArguments) {
+        async function rules(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.rules(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.rules = rules;
-        async function uid(provider, args, typeArguments) {
+        async function uid(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.uid(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uid = uid;
-        async function uidMutAsOwner(provider, args, typeArguments) {
+        async function uidMutAsOwner(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.uidMutAsOwner(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.uidMutAsOwner = uidMutAsOwner;
-        async function withdraw(provider, args, typeArguments) {
+        async function withdraw(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.withdraw(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -8480,40 +8481,40 @@ export var tx_context;
     })(builder = tx_context.builder || (tx_context.builder = {}));
     let view;
     (function (view) {
-        async function epoch(provider, args) {
+        async function epoch(client, args) {
             const tx = new TransactionBlock();
             builder.epoch(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.epoch = epoch;
-        async function epochTimestampMs(provider, args) {
+        async function epochTimestampMs(client, args) {
             const tx = new TransactionBlock();
             builder.epochTimestampMs(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.epochTimestampMs = epochTimestampMs;
-        async function freshObjectAddress(provider, args) {
+        async function freshObjectAddress(client, args) {
             const tx = new TransactionBlock();
             builder.freshObjectAddress(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.freshObjectAddress = freshObjectAddress;
-        async function sender(provider, args) {
+        async function sender(client, args) {
             const tx = new TransactionBlock();
             builder.sender(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -8544,10 +8545,10 @@ export var types;
     })(builder = types.builder || (types.builder = {}));
     let view;
     (function (view) {
-        async function isOneTimeWitness(provider, args, typeArguments) {
+        async function isOneTimeWitness(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isOneTimeWitness(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -8618,40 +8619,40 @@ export var url;
     })(builder = url.builder || (url.builder = {}));
     let view;
     (function (view) {
-        async function innerUrl(provider, args) {
+        async function innerUrl(client, args) {
             const tx = new TransactionBlock();
             builder.innerUrl(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.innerUrl = innerUrl;
-        async function newUnsafe(provider, args) {
+        async function newUnsafe(client, args) {
             const tx = new TransactionBlock();
             builder.newUnsafe(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.newUnsafe = newUnsafe;
-        async function newUnsafeFromBytes(provider, args) {
+        async function newUnsafeFromBytes(client, args) {
             const tx = new TransactionBlock();
             builder.newUnsafeFromBytes(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.newUnsafeFromBytes = newUnsafeFromBytes;
-        async function update(provider, args) {
+        async function update(client, args) {
             const tx = new TransactionBlock();
             builder.update(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -9020,180 +9021,180 @@ export var vec_map;
     })(builder = vec_map.builder || (vec_map.builder = {}));
     let view;
     (function (view) {
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function destroyEmpty(provider, args, typeArguments) {
+        async function destroyEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroyEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroyEmpty = destroyEmpty;
-        async function empty(provider, args, typeArguments) {
+        async function empty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.empty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.empty = empty;
-        async function get(provider, args, typeArguments) {
+        async function get(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.get(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.get = get;
-        async function getEntryByIdx(provider, args, typeArguments) {
+        async function getEntryByIdx(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getEntryByIdx(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getEntryByIdx = getEntryByIdx;
-        async function getEntryByIdxMut(provider, args, typeArguments) {
+        async function getEntryByIdxMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getEntryByIdxMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getEntryByIdxMut = getEntryByIdxMut;
-        async function getIdx(provider, args, typeArguments) {
+        async function getIdx(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getIdx(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getIdx = getIdx;
-        async function getIdxOpt(provider, args, typeArguments) {
+        async function getIdxOpt(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getIdxOpt(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getIdxOpt = getIdxOpt;
-        async function getMut(provider, args, typeArguments) {
+        async function getMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.getMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.getMut = getMut;
-        async function insert(provider, args, typeArguments) {
+        async function insert(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.insert(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.insert = insert;
-        async function intoKeysValues(provider, args, typeArguments) {
+        async function intoKeysValues(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.intoKeysValues(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.intoKeysValues = intoKeysValues;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function keys(provider, args, typeArguments) {
+        async function keys(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.keys(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.keys = keys;
-        async function pop(provider, args, typeArguments) {
+        async function pop(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.pop(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.pop = pop;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function removeEntryByIdx(provider, args, typeArguments) {
+        async function removeEntryByIdx(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.removeEntryByIdx(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.removeEntryByIdx = removeEntryByIdx;
-        async function size(provider, args, typeArguments) {
+        async function size(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.size(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.size = size;
-        async function tryGet(provider, args, typeArguments) {
+        async function tryGet(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.tryGet(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -9340,80 +9341,80 @@ export var vec_set;
     })(builder = vec_set.builder || (vec_set.builder = {}));
     let view;
     (function (view) {
-        async function contains(provider, args, typeArguments) {
+        async function contains(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.contains(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.contains = contains;
-        async function empty(provider, args, typeArguments) {
+        async function empty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.empty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.empty = empty;
-        async function insert(provider, args, typeArguments) {
+        async function insert(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.insert(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.insert = insert;
-        async function intoKeys(provider, args, typeArguments) {
+        async function intoKeys(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.intoKeys(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.intoKeys = intoKeys;
-        async function isEmpty(provider, args, typeArguments) {
+        async function isEmpty(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.isEmpty(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.isEmpty = isEmpty;
-        async function remove(provider, args, typeArguments) {
+        async function remove(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.remove(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.remove = remove;
-        async function singleton(provider, args, typeArguments) {
+        async function singleton(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.singleton(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.singleton = singleton;
-        async function size(provider, args, typeArguments) {
+        async function size(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.size(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
@@ -9552,70 +9553,70 @@ export var versioned;
     })(builder = versioned.builder || (versioned.builder = {}));
     let view;
     (function (view) {
-        async function create(provider, args, typeArguments) {
+        async function create(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.create(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.create = create;
-        async function destroy(provider, args, typeArguments) {
+        async function destroy(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.destroy(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.destroy = destroy;
-        async function loadValue(provider, args, typeArguments) {
+        async function loadValue(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.loadValue(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.loadValue = loadValue;
-        async function loadValueMut(provider, args, typeArguments) {
+        async function loadValueMut(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.loadValueMut(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.loadValueMut = loadValueMut;
-        async function removeValueForUpgrade(provider, args, typeArguments) {
+        async function removeValueForUpgrade(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.removeValueForUpgrade(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.removeValueForUpgrade = removeValueForUpgrade;
-        async function upgrade(provider, args, typeArguments) {
+        async function upgrade(client, args, typeArguments) {
             const tx = new TransactionBlock();
             builder.upgrade(tx, args, typeArguments);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });
             return res;
         }
         view.upgrade = upgrade;
-        async function version(provider, args) {
+        async function version(client, args) {
             const tx = new TransactionBlock();
             builder.version(tx, args);
-            const res = await provider.devInspectTransactionBlock({
+            const res = await client.devInspectTransactionBlock({
                 transactionBlock: tx,
                 sender: ZERO_ADDRESS,
             });