adding XML docs

joaquim-verges · joaquim-verges · commit fc5e0984fd2c · 2022-11-15T10:03:33.000-08:00
diff --git a/Assets/Thirdweb/Scripts/Contract.cs b/Assets/Thirdweb/Scripts/Contract.cs
@@ -9,9 +9,21 @@ public class Contract
     {
         public string chain;
         public string address;
+        /// <summary>
+        /// Call any ERC20 supported functions
+        /// </summary>
         public ERC20 ERC20;
+        /// <summary>
+        /// Call any ERC721 supported functions
+        /// </summary>
         public ERC721 ERC721;
+        /// <summary>
+        /// Call any ERC1155 supported functions
+        /// </summary>
         public ERC1155 ERC1155;
+        /// <summary>
+        /// Call any Marketplace supported functions
+        /// </summary>
         public Marketplace marketplace;
 
         public Contract(string chain, string address) {
@@ -23,6 +35,12 @@ public Contract(string chain, string address) {
             this.marketplace = new Marketplace(chain, address);
         }
 
+        /// <summary>
+        /// Read data from a contract
+        /// </summary>
+        /// <param name="functionName">The contract function name to call</param>
+        /// <param name="args">The function arguments. Structs and Lists will get serialized automatically</param>
+        /// <returns>The data deserialized to the given typed</returns>
         public async Task<T> Read<T>(string functionName, params object[] args)
         {
             string [] argsEncoded = new string[args.Length + 1];
@@ -31,6 +49,12 @@ public async Task<T> Read<T>(string functionName, params object[] args)
             return await Bridge.InvokeRoute<T>(getRoute("call"), argsEncoded);
         }
 
+        /// <summary>
+        /// Execute a write transaction on a contract
+        /// </summary>
+        /// <param name="functionName">The contract function name to call</param>
+        /// <param name="args">The function arguments. Structs and Lists will get serialized automatically</param>
+        /// <returns>The transaction receipt</returns>
         public async Task<TransactionResult> Write(string functionName, params object[] args)
         {
             string [] argsEncoded = new string[args.Length + 1];
diff --git a/Assets/Thirdweb/Scripts/ERC20.cs b/Assets/Thirdweb/Scripts/ERC20.cs
@@ -10,6 +10,9 @@ public class ERC20
     {
         public string chain;
         public string address;
+        /// <summary>
+        /// Handle signature minting functionality
+        /// </summary>
         public ERC20Signature signature;
 
         public ERC20(string chain, string address)
@@ -19,76 +22,115 @@ public ERC20(string chain, string address)
             this.signature = new ERC20Signature(chain, address);
         }
 
-        /// READ FUNCTIONS
+        // READ FUNCTIONS
 
+        /// <summary>
+        /// Get the currency information
+        /// </summary>
         public async Task<Currency> Get()
         {
             return await Bridge.InvokeRoute<Currency>(getRoute("get"), new string[] { });
         }
 
+        /// <summary>
+        /// Get the balance of the connected wallet
+        /// </summary>
         public async Task<CurrencyValue> Balance()
         {
             return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balance"), new string[] { });
         }
 
+        /// <summary>
+        /// Get the balance of the specified wallet
+        /// </summary>
         public async Task<CurrencyValue> BalanceOf(string address)
         {
             return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balanceOf"), Utils.ToJsonStringArray(address));
         }
 
+        /// <summary>
+        /// Get how much allowance the given address is allowed to spend on behalf of the connected wallet
+        /// </summary>
         public async Task<string> Allowance(string spender)
         {
             return await Bridge.InvokeRoute<string>(getRoute("allowance"), Utils.ToJsonStringArray(spender));
         }
 
+        /// <summary>
+        /// Get how much allowance the given address is allowed to spend on behalf of the specified wallet
+        /// </summary>
         public async Task<string> AllowanceOf(string owner, string spender)
         {
             return await Bridge.InvokeRoute<string>(getRoute("allowanceOf"), Utils.ToJsonStringArray(owner, spender));
         }
 
+        /// <summary>
+        /// Get the total supply in circulation
+        /// </summary>
         public async Task<CurrencyValue> TotalSupply()
         {
             return await Bridge.InvokeRoute<CurrencyValue>(getRoute("totalSupply"), new string[] { });
         }
 
-        /// WRITE FUNCTIONS
+        // WRITE FUNCTIONS
 
+        /// <summary>
+        /// Set how much allowance the given address is allowed to spend on behalf of the connected wallet
+        /// </summary>
         public async Task<TransactionResult> SetAllowance(string spender, bool amount)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("setAllowance"), Utils.ToJsonStringArray(spender, amount));
         }
 
+        /// <summary>
+        /// Transfer a given amount of currency to another wallet
+        /// </summary>
         public async Task<TransactionResult> Transfer(string to, string amount)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("transfer"), Utils.ToJsonStringArray(to, amount));
         }
 
+        /// <summary>
+        /// Burn a given amount of currency
+        /// </summary>
         public async Task<TransactionResult> Burn(string amount)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("burn"), Utils.ToJsonStringArray(amount));
         }
 
+        /// <summary>
+        /// Claim a given amount of currency for compatible drop contracts
+        /// </summary>
         public async Task<TransactionResult[]> Claim(string amount)
         {
             return await Bridge.InvokeRoute<TransactionResult[]>(getRoute("claim"), Utils.ToJsonStringArray(amount));
         }
 
+        /// <summary>
+        /// Claim a given amount of currency to a given destination wallet for compatible drop contracts
+        /// </summary>
         public async Task<TransactionResult[]> ClaimTo(string address, int amount)
         {
             return await Bridge.InvokeRoute<TransactionResult[]>(getRoute("claimTo"), Utils.ToJsonStringArray(address, amount));
         }
 
+        /// <summary>
+        /// Mint a given amount of currency
+        /// </summary>
         public async Task<TransactionResult> Mint(string amount)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("mint"), Utils.ToJsonStringArray(amount));
         }
 
+        /// <summary>
+        /// Mint a given amount of currency to a given destination wallet
+        /// </summary>
         public async Task<TransactionResult> MintTo(string address, string amount)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("mintTo"), Utils.ToJsonStringArray(address, amount));
         }
 
-        /// PRIVATE
+        // PRIVATE
 
         private string getRoute(string functionPath) {
             return this.address + ".erc20." + functionPath;
@@ -153,16 +195,25 @@ public ERC20Signature(string chain, string address)
             this.address = address;
         }
 
+        /// <summary>
+        /// Generate a signed mintable payload. Requires minting permission.
+        /// </summary>
         public async Task<ERC20SignedPayload> Generate(ERC20MintPayload payloadToSign)
         {
             return await Bridge.InvokeRoute<ERC20SignedPayload>(getRoute("generate"), Utils.ToJsonStringArray(payloadToSign));
         }
 
+        /// <summary>
+        /// Verify that a signed mintable payload is valid
+        /// </summary>
         public async Task<bool> Verify(ERC20SignedPayload signedPayload)
         {
             return await Bridge.InvokeRoute<bool>(getRoute("verify"), Utils.ToJsonStringArray(signedPayload));
         }
 
+        /// <summary>
+        /// Mint a signed mintable payload
+        /// </summary>
         public async Task<TransactionResult> Mint(ERC20SignedPayload signedPayload)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("mint"), Utils.ToJsonStringArray(signedPayload));
diff --git a/Assets/Thirdweb/Scripts/ThirdwebSDK.cs b/Assets/Thirdweb/Scripts/ThirdwebSDK.cs
@@ -5,12 +5,18 @@ namespace Thirdweb
     /// </summary>
     public class ThirdwebSDK
     {
+        /// <summary>
+        /// Options for the thirdweb SDK.
+        /// </summary>
         [System.Serializable]
         public struct Options
         {
             public GaslessOptions? gasless;
         }
 
+        /// <summary>
+        /// Gasless configuration options.
+        /// </summary>
         [System.Serializable]
         public struct GaslessOptions
         {
@@ -19,13 +25,19 @@ public struct GaslessOptions
             public bool experimentalChainlessSupport;
         }
 
+        /// <summary>
+        /// OpenZeppelin Defender Gasless configuration options.
+        /// </summary>
         [System.Serializable]
         public struct OZDefenderOptions
         {
             public string relayerUrl;
             public string relayerForwarderAddress;
         }
 
+        /// <summary>
+        /// Biconomy Gasless configuration options.
+        /// </summary>
         [System.Serializable]
         public struct BiconomyOptions
         {
@@ -34,9 +46,21 @@ public struct BiconomyOptions
         }
 
         private string chainOrRPC;
+
+        /// <summary>
+        /// Connect and Interact with a user's wallet
+        /// </summary>
         public Wallet wallet;
+        /// <summary>
+        /// Deploy new contracts
+        /// </summary>
         public Deployer deployer;
 
+        /// <summary>
+        /// Create an instance of the thirdweb SDK. Requires a webGL browser context.
+        /// </summary>
+        /// <param name="chainOrRPC">The chain name or RPC url to connect to</param>
+        /// <param name="options">Configuration options</param>
         public ThirdwebSDK(string chainOrRPC, Options options = new Options()) 
         {
             this.chainOrRPC = chainOrRPC;
@@ -45,6 +69,11 @@ public struct BiconomyOptions
             Bridge.Initialize(chainOrRPC, options);
         }
 
+        /// <summary>
+        /// Get an instance of a deployed contract.
+        /// </summary>
+        /// <param name="address">The contract address</param>
+        /// <returns>A contract instance</returns>
         public Contract GetContract(string address)
         {
             return new Contract(this.chainOrRPC, address);
diff --git a/Assets/Thirdweb/Scripts/Wallet.cs b/Assets/Thirdweb/Scripts/Wallet.cs
@@ -3,65 +3,95 @@
 namespace Thirdweb
 {
     /// <summary>
-    /// Interact with a Wallet.
+    /// Connect and Interact with a Wallet.
     /// </summary>
     public class Wallet
     {
+        /// <summary>
+        /// Connect a user's wallet via browser extension
+        /// </summary>
         public Task<string> Connect() 
         {
             return Bridge.Connect();
         }
 
+        /// <summary>
+        /// Authenticate the user by signing a payload that can be used to securely identify users. See https://portal.thirdweb.com/auth
+        /// </summary>
+        /// <param name="domain">The domain to authenticate to</param>
         public async Task<LoginPayload> Authenticate(string domain) 
         {
             return await Bridge.InvokeRoute<LoginPayload>("sdk#auth.login", Utils.ToJsonStringArray(domain));
         }
 
+        /// <summary>
+        /// Get the balance of the connected wallet
+        /// </summary>
+        /// <param name="currencyAddress">Optional address of the currency to check balance of</param>
         public async Task<CurrencyValue> GetBalance(string currencyAddress = Utils.NativeTokenAddress)
         {
             return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balance"), Utils.ToJsonStringArray(currencyAddress));
         }
 
+        /// <summary>
+        /// Get the connected wallet address
+        /// </summary>
         public async Task<string> GetAddress()
         {
             return await Bridge.InvokeRoute<string>(getRoute("getAddress"), new string[] { });
         }
 
+        /// <summary>
+        /// Check if a wallet is connected
+        /// </summary>
         public async Task<bool> IsConnected()
         {
             return await Bridge.InvokeRoute<bool>(getRoute("isConnected"), new string[] { });
         }
 
+        /// <summary>
+        /// Get the connected chainId
+        /// </summary>
         public async Task<int> GetChainId()
         {
             return await Bridge.InvokeRoute<int>(getRoute("getChainId"), new string[] { });
         }
 
-        public async Task<bool> IsOnCorrectChain()
-        {
-            return await Bridge.InvokeRoute<bool>(getRoute("isOnCorrectChain"), new string[] { });
-        }
-
+        /// <summary>
+        /// Prompt the connected wallet to switch to the giiven chainId
+        /// </summary>
         public void SwitchNetwork(int chainId)
         {
             Bridge.SwitchNetwork(chainId);
         }
 
+        /// <summary>
+        /// Transfer currency to a given address
+        /// </summary>
         public async Task<TransactionResult> Transfer(string to, string amount, string currencyAddress = Utils.NativeTokenAddress)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("transfer"), Utils.ToJsonStringArray(to, amount, currencyAddress));
         }
 
+        /// <summary>
+        /// Prompt the connected wallet to sign the given message
+        /// </summary>
         public async Task<string> Sign(string message)
         {
             return await Bridge.InvokeRoute<string>(getRoute("sign"), Utils.ToJsonStringArray(message));
         }
 
+        /// <summary>
+        /// Recover the original wallet address that signed a message
+        /// </summary>
         public async Task<string> RecoverAddress(string message, string signature)
         {
             return await Bridge.InvokeRoute<string>(getRoute("recoverAddress"), Utils.ToJsonStringArray(message, signature));
         }
 
+        /// <summary>
+        /// Send a raw transaction from the connected wallet
+        /// </summary>
         public async Task<TransactionResult> SendRawTransaction(TransactionRequest transactionRequest)
         {
             return await Bridge.InvokeRoute<TransactionResult>(getRoute("sendRawTransaction"), Utils.ToJsonStringArray(transactionRequest));

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,9 @@ public class ERC20`
`10`	`10`	`{`
`11`	`11`	`public string chain;`
`12`	`12`	`public string address;`
	`13`	`+ /// <summary>`
	`14`	`+ /// Handle signature minting functionality`
	`15`	`+ /// </summary>`
`13`	`16`	`public ERC20Signature signature;`
`14`	`17`
`15`	`18`	`public ERC20(string chain, string address)`
`@@ -19,76 +22,115 @@ public ERC20(string chain, string address)`
`19`	`22`	`this.signature = new ERC20Signature(chain, address);`
`20`	`23`	`}`
`21`	`24`
`22`		`- /// READ FUNCTIONS`
	`25`	`+ // READ FUNCTIONS`
`23`	`26`
	`27`	`+ /// <summary>`
	`28`	`+ /// Get the currency information`
	`29`	`+ /// </summary>`
`24`	`30`	`public async Task<Currency> Get()`
`25`	`31`	`{`
`26`	`32`	`return await Bridge.InvokeRoute<Currency>(getRoute("get"), new string[] { });`
`27`	`33`	`}`
`28`	`34`
	`35`	`+ /// <summary>`
	`36`	`+ /// Get the balance of the connected wallet`
	`37`	`+ /// </summary>`
`29`	`38`	`public async Task<CurrencyValue> Balance()`
`30`	`39`	`{`
`31`	`40`	`return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balance"), new string[] { });`
`32`	`41`	`}`
`33`	`42`
	`43`	`+ /// <summary>`
	`44`	`+ /// Get the balance of the specified wallet`
	`45`	`+ /// </summary>`
`34`	`46`	`public async Task<CurrencyValue> BalanceOf(string address)`
`35`	`47`	`{`
`36`	`48`	`return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balanceOf"), Utils.ToJsonStringArray(address));`
`37`	`49`	`}`
`38`	`50`
	`51`	`+ /// <summary>`
	`52`	`+ /// Get how much allowance the given address is allowed to spend on behalf of the connected wallet`
	`53`	`+ /// </summary>`
`39`	`54`	`public async Task<string> Allowance(string spender)`
`40`	`55`	`{`
`41`	`56`	`return await Bridge.InvokeRoute<string>(getRoute("allowance"), Utils.ToJsonStringArray(spender));`
`42`	`57`	`}`
`43`	`58`
	`59`	`+ /// <summary>`
	`60`	`+ /// Get how much allowance the given address is allowed to spend on behalf of the specified wallet`
	`61`	`+ /// </summary>`
`44`	`62`	`public async Task<string> AllowanceOf(string owner, string spender)`
`45`	`63`	`{`
`46`	`64`	`return await Bridge.InvokeRoute<string>(getRoute("allowanceOf"), Utils.ToJsonStringArray(owner, spender));`
`47`	`65`	`}`
`48`	`66`
	`67`	`+ /// <summary>`
	`68`	`+ /// Get the total supply in circulation`
	`69`	`+ /// </summary>`
`49`	`70`	`public async Task<CurrencyValue> TotalSupply()`
`50`	`71`	`{`
`51`	`72`	`return await Bridge.InvokeRoute<CurrencyValue>(getRoute("totalSupply"), new string[] { });`
`52`	`73`	`}`
`53`	`74`
`54`		`- /// WRITE FUNCTIONS`
	`75`	`+ // WRITE FUNCTIONS`
`55`	`76`
	`77`	`+ /// <summary>`
	`78`	`+ /// Set how much allowance the given address is allowed to spend on behalf of the connected wallet`
	`79`	`+ /// </summary>`
`56`	`80`	`public async Task<TransactionResult> SetAllowance(string spender, bool amount)`
`57`	`81`	`{`
`58`	`82`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("setAllowance"), Utils.ToJsonStringArray(spender, amount));`
`59`	`83`	`}`
`60`	`84`
	`85`	`+ /// <summary>`
	`86`	`+ /// Transfer a given amount of currency to another wallet`
	`87`	`+ /// </summary>`
`61`	`88`	`public async Task<TransactionResult> Transfer(string to, string amount)`
`62`	`89`	`{`
`63`	`90`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("transfer"), Utils.ToJsonStringArray(to, amount));`
`64`	`91`	`}`
`65`	`92`
	`93`	`+ /// <summary>`
	`94`	`+ /// Burn a given amount of currency`
	`95`	`+ /// </summary>`
`66`	`96`	`public async Task<TransactionResult> Burn(string amount)`
`67`	`97`	`{`
`68`	`98`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("burn"), Utils.ToJsonStringArray(amount));`
`69`	`99`	`}`
`70`	`100`
	`101`	`+ /// <summary>`
	`102`	`+ /// Claim a given amount of currency for compatible drop contracts`
	`103`	`+ /// </summary>`
`71`	`104`	`public async Task<TransactionResult[]> Claim(string amount)`
`72`	`105`	`{`
`73`	`106`	`return await Bridge.InvokeRoute<TransactionResult[]>(getRoute("claim"), Utils.ToJsonStringArray(amount));`
`74`	`107`	`}`
`75`	`108`
	`109`	`+ /// <summary>`
	`110`	`+ /// Claim a given amount of currency to a given destination wallet for compatible drop contracts`
	`111`	`+ /// </summary>`
`76`	`112`	`public async Task<TransactionResult[]> ClaimTo(string address, int amount)`
`77`	`113`	`{`
`78`	`114`	`return await Bridge.InvokeRoute<TransactionResult[]>(getRoute("claimTo"), Utils.ToJsonStringArray(address, amount));`
`79`	`115`	`}`
`80`	`116`
	`117`	`+ /// <summary>`
	`118`	`+ /// Mint a given amount of currency`
	`119`	`+ /// </summary>`
`81`	`120`	`public async Task<TransactionResult> Mint(string amount)`
`82`	`121`	`{`
`83`	`122`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("mint"), Utils.ToJsonStringArray(amount));`
`84`	`123`	`}`
`85`	`124`
	`125`	`+ /// <summary>`
	`126`	`+ /// Mint a given amount of currency to a given destination wallet`
	`127`	`+ /// </summary>`
`86`	`128`	`public async Task<TransactionResult> MintTo(string address, string amount)`
`87`	`129`	`{`
`88`	`130`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("mintTo"), Utils.ToJsonStringArray(address, amount));`
`89`	`131`	`}`
`90`	`132`
`91`		`- /// PRIVATE`
	`133`	`+ // PRIVATE`
`92`	`134`
`93`	`135`	`private string getRoute(string functionPath) {`
`94`	`136`	`return this.address + ".erc20." + functionPath;`
`@@ -153,16 +195,25 @@ public ERC20Signature(string chain, string address)`
`153`	`195`	`this.address = address;`
`154`	`196`	`}`
`155`	`197`
	`198`	`+ /// <summary>`
	`199`	`+ /// Generate a signed mintable payload. Requires minting permission.`
	`200`	`+ /// </summary>`
`156`	`201`	`public async Task<ERC20SignedPayload> Generate(ERC20MintPayload payloadToSign)`
`157`	`202`	`{`
`158`	`203`	`return await Bridge.InvokeRoute<ERC20SignedPayload>(getRoute("generate"), Utils.ToJsonStringArray(payloadToSign));`
`159`	`204`	`}`
`160`	`205`
	`206`	`+ /// <summary>`
	`207`	`+ /// Verify that a signed mintable payload is valid`
	`208`	`+ /// </summary>`
`161`	`209`	`public async Task<bool> Verify(ERC20SignedPayload signedPayload)`
`162`	`210`	`{`
`163`	`211`	`return await Bridge.InvokeRoute<bool>(getRoute("verify"), Utils.ToJsonStringArray(signedPayload));`
`164`	`212`	`}`
`165`	`213`
	`214`	`+ /// <summary>`
	`215`	`+ /// Mint a signed mintable payload`
	`216`	`+ /// </summary>`
`166`	`217`	`public async Task<TransactionResult> Mint(ERC20SignedPayload signedPayload)`
`167`	`218`	`{`
`168`	`219`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("mint"), Utils.ToJsonStringArray(signedPayload));`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,18 @@ namespace Thirdweb`
`5`	`5`	`/// </summary>`
`6`	`6`	`public class ThirdwebSDK`
`7`	`7`	`{`
	`8`	`+ /// <summary>`
	`9`	`+ /// Options for the thirdweb SDK.`
	`10`	`+ /// </summary>`
`8`	`11`	`[System.Serializable]`
`9`	`12`	`public struct Options`
`10`	`13`	`{`
`11`	`14`	`public GaslessOptions? gasless;`
`12`	`15`	`}`
`13`	`16`
	`17`	`+ /// <summary>`
	`18`	`+ /// Gasless configuration options.`
	`19`	`+ /// </summary>`
`14`	`20`	`[System.Serializable]`
`15`	`21`	`public struct GaslessOptions`
`16`	`22`	`{`
`@@ -19,13 +25,19 @@ public struct GaslessOptions`
`19`	`25`	`public bool experimentalChainlessSupport;`
`20`	`26`	`}`
`21`	`27`
	`28`	`+ /// <summary>`
	`29`	`+ /// OpenZeppelin Defender Gasless configuration options.`
	`30`	`+ /// </summary>`
`22`	`31`	`[System.Serializable]`
`23`	`32`	`public struct OZDefenderOptions`
`24`	`33`	`{`
`25`	`34`	`public string relayerUrl;`
`26`	`35`	`public string relayerForwarderAddress;`
`27`	`36`	`}`
`28`	`37`
	`38`	`+ /// <summary>`
	`39`	`+ /// Biconomy Gasless configuration options.`
	`40`	`+ /// </summary>`
`29`	`41`	`[System.Serializable]`
`30`	`42`	`public struct BiconomyOptions`
`31`	`43`	`{`
`@@ -34,9 +46,21 @@ public struct BiconomyOptions`
`34`	`46`	`}`
`35`	`47`
`36`	`48`	`private string chainOrRPC;`
	`49`	`+`
	`50`	`+ /// <summary>`
	`51`	`+ /// Connect and Interact with a user's wallet`
	`52`	`+ /// </summary>`
`37`	`53`	`public Wallet wallet;`
	`54`	`+ /// <summary>`
	`55`	`+ /// Deploy new contracts`
	`56`	`+ /// </summary>`
`38`	`57`	`public Deployer deployer;`
`39`	`58`
	`59`	`+ /// <summary>`
	`60`	`+ /// Create an instance of the thirdweb SDK. Requires a webGL browser context.`
	`61`	`+ /// </summary>`
	`62`	`+ /// <param name="chainOrRPC">The chain name or RPC url to connect to</param>`
	`63`	`+ /// <param name="options">Configuration options</param>`
`40`	`64`	`public ThirdwebSDK(string chainOrRPC, Options options = new Options())`
`41`	`65`	`{`
`42`	`66`	`this.chainOrRPC = chainOrRPC;`
`@@ -45,6 +69,11 @@ public struct BiconomyOptions`
`45`	`69`	`Bridge.Initialize(chainOrRPC, options);`
`46`	`70`	`}`
`47`	`71`
	`72`	`+ /// <summary>`
	`73`	`+ /// Get an instance of a deployed contract.`
	`74`	`+ /// </summary>`
	`75`	`+ /// <param name="address">The contract address</param>`
	`76`	`+ /// <returns>A contract instance</returns>`
`48`	`77`	`public Contract GetContract(string address)`
`49`	`78`	`{`
`50`	`79`	`return new Contract(this.chainOrRPC, address);`
Original file line number	Diff line number	Diff line change
`@@ -3,65 +3,95 @@`
`3`	`3`	`namespace Thirdweb`
`4`	`4`	`{`
`5`	`5`	`/// <summary>`
`6`		`- /// Interact with a Wallet.`
	`6`	`+ /// Connect and Interact with a Wallet.`
`7`	`7`	`/// </summary>`
`8`	`8`	`public class Wallet`
`9`	`9`	`{`
	`10`	`+ /// <summary>`
	`11`	`+ /// Connect a user's wallet via browser extension`
	`12`	`+ /// </summary>`
`10`	`13`	`public Task<string> Connect()`
`11`	`14`	`{`
`12`	`15`	`return Bridge.Connect();`
`13`	`16`	`}`
`14`	`17`
	`18`	`+ /// <summary>`
	`19`	`+ /// Authenticate the user by signing a payload that can be used to securely identify users. See https://portal.thirdweb.com/auth`
	`20`	`+ /// </summary>`
	`21`	`+ /// <param name="domain">The domain to authenticate to</param>`
`15`	`22`	`public async Task<LoginPayload> Authenticate(string domain)`
`16`	`23`	`{`
`17`	`24`	`return await Bridge.InvokeRoute<LoginPayload>("sdk#auth.login", Utils.ToJsonStringArray(domain));`
`18`	`25`	`}`
`19`	`26`
	`27`	`+ /// <summary>`
	`28`	`+ /// Get the balance of the connected wallet`
	`29`	`+ /// </summary>`
	`30`	`+ /// <param name="currencyAddress">Optional address of the currency to check balance of</param>`
`20`	`31`	`public async Task<CurrencyValue> GetBalance(string currencyAddress = Utils.NativeTokenAddress)`
`21`	`32`	`{`
`22`	`33`	`return await Bridge.InvokeRoute<CurrencyValue>(getRoute("balance"), Utils.ToJsonStringArray(currencyAddress));`
`23`	`34`	`}`
`24`	`35`
	`36`	`+ /// <summary>`
	`37`	`+ /// Get the connected wallet address`
	`38`	`+ /// </summary>`
`25`	`39`	`public async Task<string> GetAddress()`
`26`	`40`	`{`
`27`	`41`	`return await Bridge.InvokeRoute<string>(getRoute("getAddress"), new string[] { });`
`28`	`42`	`}`
`29`	`43`
	`44`	`+ /// <summary>`
	`45`	`+ /// Check if a wallet is connected`
	`46`	`+ /// </summary>`
`30`	`47`	`public async Task<bool> IsConnected()`
`31`	`48`	`{`
`32`	`49`	`return await Bridge.InvokeRoute<bool>(getRoute("isConnected"), new string[] { });`
`33`	`50`	`}`
`34`	`51`
	`52`	`+ /// <summary>`
	`53`	`+ /// Get the connected chainId`
	`54`	`+ /// </summary>`
`35`	`55`	`public async Task<int> GetChainId()`
`36`	`56`	`{`
`37`	`57`	`return await Bridge.InvokeRoute<int>(getRoute("getChainId"), new string[] { });`
`38`	`58`	`}`
`39`	`59`
`40`		`- public async Task<bool> IsOnCorrectChain()`
`41`		`- {`
`42`		`- return await Bridge.InvokeRoute<bool>(getRoute("isOnCorrectChain"), new string[] { });`
`43`		`- }`
`44`		`-`
	`60`	`+ /// <summary>`
	`61`	`+ /// Prompt the connected wallet to switch to the giiven chainId`
	`62`	`+ /// </summary>`
`45`	`63`	`public void SwitchNetwork(int chainId)`
`46`	`64`	`{`
`47`	`65`	`Bridge.SwitchNetwork(chainId);`
`48`	`66`	`}`
`49`	`67`
	`68`	`+ /// <summary>`
	`69`	`+ /// Transfer currency to a given address`
	`70`	`+ /// </summary>`
`50`	`71`	`public async Task<TransactionResult> Transfer(string to, string amount, string currencyAddress = Utils.NativeTokenAddress)`
`51`	`72`	`{`
`52`	`73`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("transfer"), Utils.ToJsonStringArray(to, amount, currencyAddress));`
`53`	`74`	`}`
`54`	`75`
	`76`	`+ /// <summary>`
	`77`	`+ /// Prompt the connected wallet to sign the given message`
	`78`	`+ /// </summary>`
`55`	`79`	`public async Task<string> Sign(string message)`
`56`	`80`	`{`
`57`	`81`	`return await Bridge.InvokeRoute<string>(getRoute("sign"), Utils.ToJsonStringArray(message));`
`58`	`82`	`}`
`59`	`83`
	`84`	`+ /// <summary>`
	`85`	`+ /// Recover the original wallet address that signed a message`
	`86`	`+ /// </summary>`
`60`	`87`	`public async Task<string> RecoverAddress(string message, string signature)`
`61`	`88`	`{`
`62`	`89`	`return await Bridge.InvokeRoute<string>(getRoute("recoverAddress"), Utils.ToJsonStringArray(message, signature));`
`63`	`90`	`}`
`64`	`91`
	`92`	`+ /// <summary>`
	`93`	`+ /// Send a raw transaction from the connected wallet`
	`94`	`+ /// </summary>`
`65`	`95`	`public async Task<TransactionResult> SendRawTransaction(TransactionRequest transactionRequest)`
`66`	`96`	`{`
`67`	`97`	`return await Bridge.InvokeRoute<TransactionResult>(getRoute("sendRawTransaction"), Utils.ToJsonStringArray(transactionRequest));`